Merge pull request #5469 from OpenBB-finance/feature/integration-tests

Feature/integration tests

noxfile.py

@@ -2,7 +2,7 @@ import nox
 
 test_locations = [
     "openbb_sdk/tests",
-    "openbb_sdk/sdk/core/tests",
+    "openbb_sdk/sdk",
     "openbb_sdk/providers",
 ]
 

openbb_sdk/extensions/crypto/integration/test_crypto_api.py

@@ -0,0 +1,98 @@
+import pytest
+import requests
+from openbb_provider.utils.helpers import get_querystring
+
+
+def get_token():
+    return requests.post(
+        "http://0.0.0.0:8000/api/v1/account/token",
+        data={"username": "openbb", "password": "openbb"},
+        timeout=5,
+    )
+
+
+@pytest.fixture(scope="session")
+def headers():
+    access_token = get_token().json()["access_token"]
+    return {"Authorization": f"Bearer {access_token}"}
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "BTCUSD", "start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "interval": "1min",
+                "provider": "fmp",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1day",
+                "provider": "fmp",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "minute",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "day",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "5m",
+                "period": "max",
+                "provider": "yfinance",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "period": "max",
+                "provider": "yfinance",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_crypto_load(params, headers):
+    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/load?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_sdk/extensions/crypto/integration/test_crypto_python.py

@@ -0,0 +1,89 @@
+"""Test crypto extension."""
+
+import pytest
+from openbb import obb
+from openbb_core.app.model.obbject import OBBject
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1min",
+                "provider": "fmp",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1day",
+                "provider": "fmp",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "minute",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "day",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "5m",
+                "period": "max",
+                "provider": "yfinance",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "period": "max",
+                "provider": "yfinance",
+                "symbol": "BTCUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_crypto_load(params):
+    result = obb.crypto.load(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0

openbb_sdk/extensions/econometrics/integration/test_econometrics_api.py

@@ -0,0 +1,122 @@
+import pytest
+import requests
+from openbb_provider.utils.helpers import get_querystring
+
+
+def get_token():
+    return requests.post(
+        "http://0.0.0.0:8000/api/v1/account/token",
+        data={"username": "openbb", "password": "openbb"},
+        timeout=5,
+    )
+
+
+@pytest.fixture(scope="session")
+def headers():
+    access_token = get_token().json()["access_token"]
+    return {"Authorization": f"Bearer {access_token}"}
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": ""})],
+)
+@pytest.mark.integration
+def test_econometrics_corr(params, headers):
+    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/econometrics/corr?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "y_column": "", "x_columns": ""})],
+)
+@pytest.mark.integration
+def test_econometrics_ols_summary(params, headers):
+    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/econometrics/ols_summary?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "y_column": "", "x_columns": ""})],
+)
+@pytest.mark.integration
+def test_econometrics_dwat(params, headers):
+    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/econometrics/dwat?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "y_column": "", "x_columns": "", "lags": ""})],
+)
+@pytest.mark.integration
+def test_econometrics_bgot(params, headers):
+    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/econometrics/bgot?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "columns": ""})],
+)
+@pytest.mark.integration
+def test_econometrics_coint(params, headers):
+    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/econometrics/coint?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "y_column": "", "x_column": "", "lag": ""})],
+)
+@pytest.mark.integration
+def test_econometrics_granger(params, headers):
+    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/econometrics/granger?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "column": "", "regression": ""})],
+)
+@pytest.mark.integration
+def test_econometrics_unitroot(params, headers):
+    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/econometrics/unitroot?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_sdk/extensions/economy/integration/test_economy_api.py

@@ -0,0 +1,351 @@
+import pytest
+import requests
+from openbb_provider.utils.helpers import get_querystring
+
+
+def get_token():
+    return requests.post(
+        "http://0.0.0.0:8000/api/v1/account/token",
+        data={"username": "openbb", "password": "openbb"},
+        timeout=5,
+    )
+
+
+@pytest.fixture(scope="session")
+def headers():
+    access_token = get_token().json()["access_token"]
+    return {"Authorization": f"Bearer {access_token}"}
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"index": "dowjones"})],
+)
+@pytest.mark.integration
+def test_economy_const(params, headers):
+    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/economy/const?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "countries": ["portugal", "spain"],
+                "units": "growth_same",
+                "frequency": "monthly",
+                "harmonized": True,
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_economy_cpi(params, headers):
+    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/economy/cpi?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "DJI", "start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "interval": "1m",
+                "provider": "cboe",
+                "symbol": "AAVE100",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "cboe",
+                "symbol": "AAVE100",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1min",
+                "provider": "fmp",
+                "symbol": "^DJI",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1day",
+                "provider": "fmp",
+                "symbol": "^DJI",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "timespan": "minute",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "multiplier": 1,
+                "provider": "polygon",
+                "symbol": "NDX",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "timespan": "day",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "multiplier": 1,
+                "provider": "polygon",
+                "symbol": "NDX",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "period": "max",
+                "prepost": True,
+                "rounding": True,
+                "provider": "yfinance",
+                "symbol": "DJI",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "period": "max",
+                "prepost": True,
+                "rounding": True,
+                "provider": "yfinance",
+                "symbol": "DJI",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_economy_index(params, headers):
+    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/economy/index?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "BUKBUS", "start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "interval": "1m",
+                "provider": "cboe",
+                "symbol": "BUKBUS",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "cboe",
+                "symbol": "BUKBUS",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_economy_european_index(params, headers):
+    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/economy/european_index?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "BUKBUS"})],
+)
+@pytest.mark.integration
+def test_economy_european_index_constituents(params, headers):
+    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/economy/european_index_constituents?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({}), ({"europe": True, "provider": "cboe"})],
+)
+@pytest.mark.integration
+def test_economy_available_indices(params, headers):
+    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/economy/available_indices?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({})],
+)
+@pytest.mark.integration
+def test_economy_risk(params, headers):
+    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/economy/risk?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"query": "DJ", "symbol": True}),
+        (
+            {
+                "europe": True,
+                "provider": "cboe",
+                "query": "DJ",
+                "symbol": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_economy_index_search(params, headers):
+    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/economy/index_search?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"region": "US"})],
+)
+@pytest.mark.integration
+def test_economy_index_snapshots(params, headers):
+    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/economy/index_snapshots?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"query": "grain"})],
+)
+@pytest.mark.integration
+def test_economy_cot_search(params, headers):
+    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/economy/cot_search?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({}),
+        (
+            {
+                "code": "13874P",
+                "data_type": "FO",
+                "legacy_format": True,
+                "report_type": "ALL",
+                "measure": "CR",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "transform": "diff",
+                "provider": "quandl",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_economy_cot(params, headers):
+    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/economy/cot?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "series_name": "PE Ratio by Month",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "collapse": "monthly",
+                "transform": "diff",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_economy_sp500_multiples(params, headers):
+    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/economy/sp500_multiples?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_sdk/extensions/economy/integration/test_economy_python.py

@@ -0,0 +1,329 @@
+"""Test economy extension."""
+
+import pytest
+from openbb import obb
+from openbb_core.app.model.obbject import OBBject
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"index": "dowjones"}),
+    ],
+)
+@pytest.mark.integration
+def test_economy_const(params):
+    result = obb.economy.const(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "countries": ["portugal", "spain"],
+                "units": "growth_same",
+                "frequency": "monthly",
+                "harmonized": True,
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_economy_cpi(params):
+    result = obb.economy.cpi(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "DJI",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "provider": "cboe",
+                "symbol": "AAVE100",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "cboe",
+                "symbol": "AAVE100",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1min",
+                "provider": "fmp",
+                "symbol": "^DJI",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1day",
+                "provider": "fmp",
+                "symbol": "^DJI",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "timespan": "minute",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "multiplier": 1,
+                "provider": "polygon",
+                "symbol": "NDX",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "timespan": "day",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "multiplier": 1,
+                "provider": "polygon",
+                "symbol": "NDX",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "5m",
+                "period": "max",
+                "prepost": True,
+                "rounding": True,
+                "provider": "yfinance",
+                "symbol": "DJI",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "period": "max",
+                "prepost": True,
+                "rounding": True,
+                "provider": "yfinance",
+                "symbol": "DJI",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_economy_index(params):
+    result = obb.economy.index(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "BUKBUS",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "provider": "cboe",
+                "symbol": "BUKBUS",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "cboe",
+                "symbol": "BUKBUS",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_economy_european_index(params):
+    result = obb.economy.european_index(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "BUKBUS"}),
+    ],
+)
+@pytest.mark.integration
+def test_economy_european_index_constituents(params):
+    result = obb.economy.european_index_constituents(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({}),
+        ({"europe": True, "provider": "cboe"}),
+    ],
+)
+@pytest.mark.integration
+def test_economy_available_indices(params):
+    result = obb.economy.available_indices(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({}),
+    ],
+)
+@pytest.mark.integration
+def test_economy_risk(params):
+    result = obb.economy.risk(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"query": "DJ", "symbol": True}),
+        (
+            {
+                "europe": True,
+                "provider": "cboe",
+                "query": "AA",
+                "symbol": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_economy_index_search(params):
+    result = obb.economy.index_search(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"region": "US"}),
+    ],
+)
+@pytest.mark.integration
+def test_economy_index_snapshots(params):
+    result = obb.economy.index_snapshots(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"query": "grain"}),
+    ],
+)
+@pytest.mark.integration
+def test_economy_cot_search(params):
+    result = obb.economy.cot_search(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({}),
+        (
+            {
+                "code": "13874P",
+                "data_type": "FO",
+                "legacy_format": True,
+                "report_type": "ALL",
+                "measure": "CR",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "transform": "diff",
+                "provider": "quandl",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_economy_cot(params):
+    result = obb.economy.cot(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "series_name": "PE Ratio by Month",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "collapse": "monthly",
+                "transform": "diff",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_economy_sp500_multiples(params):
+    result = obb.economy.sp500_multiples(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert len(result.results) > 0

openbb_sdk/extensions/fixedincome/integration/test_fixedincome_api.py

@@ -0,0 +1,202 @@
+import pytest
+import requests
+from openbb_provider.utils.helpers import get_querystring
+
+
+def get_token():
+    return requests.post(
+        "http://0.0.0.0:8000/api/v1/account/token",
+        data={"username": "openbb", "password": "openbb"},
+        timeout=5,
+    )
+
+
+@pytest.fixture(scope="session")
+def headers():
+    access_token = get_token().json()["access_token"]
+    return {"Authorization": f"Bearer {access_token}"}
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"start_date": "2023-01-01", "end_date": "2023-06-06"})],
+)
+@pytest.mark.integration
+def test_fixedincome_treasury(params, headers):
+    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/fixedincome/treasury?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"date": "2023-01-01", "inflation_adjusted": True})],
+)
+@pytest.mark.integration
+def test_fixedincome_ycrv(params, headers):
+    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/fixedincome/ycrv?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "period": "overnight",
+                "provider": "fred",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_sofr(params, headers):
+    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/fixedincome/sofr?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "parameter": "volume_weighted_trimmed_mean_rate",
+                "provider": "fred",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_estr(params, headers):
+    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/fixedincome/estr?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "parameter": "rate",
+                "provider": "fred",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_sonia(params, headers):
+    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/fixedincome/sonia?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "parameter": "overnight",
+                "provider": "fred",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_ameribor(params, headers):
+    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/fixedincome/ameribor?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "parameter": "weekly",
+                "provider": "fred",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_fed(params, headers):
+    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/fixedincome/fed?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({}), ({"long_run": True, "provider": "fred"})],
+)
+@pytest.mark.integration
+def test_fixedincome_projections(params, headers):
+    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/fixedincome/projections?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"start_date": "2023-01-01", "end_date": "2023-06-06"})],
+)
+@pytest.mark.integration
+def test_fixedincome_iorb(params, headers):
+    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/fixedincome/iorb?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_sdk/extensions/fixedincome/integration/test_fixedincome_python.py

@@ -0,0 +1,171 @@
+"""Test fixedincome extension."""
+import pytest
+from openbb import obb
+from openbb_core.app.model.obbject import OBBject
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_treasury(params):
+    result = obb.fixedincome.treasury(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"date": "2023-01-01", "inflation_adjusted": True}),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_ycrv(params):
+    result = obb.fixedincome.ycrv(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "period": "overnight",
+                "provider": "fred",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_sofr(params):
+    result = obb.fixedincome.sofr(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "parameter": "volume_weighted_trimmed_mean_rate",
+                "provider": "fred",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_estr(params):
+    result = obb.fixedincome.estr(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "parameter": "rate",
+                "provider": "fred",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_sonia(params):
+    result = obb.fixedincome.sonia(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "parameter": "overnight",
+                "provider": "fred",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_ameribor(params):
+    result = obb.fixedincome.ameribor(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "parameter": "weekly",
+                "provider": "fred",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_fed(params):
+    result = obb.fixedincome.fed(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({}),
+        ({"long_run": True, "provider": "fred"}),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_projections(params):
+    result = obb.fixedincome.projections(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"start_date": "2023-01-01", "end_date": "2023-06-06"}),
+    ],
+)
+@pytest.mark.integration
+def test_fixedincome_iorb(params):
+    result = obb.fixedincome.iorb(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0

openbb_sdk/extensions/forex/integration/test_forex_api.py

@@ -0,0 +1,127 @@
+import pytest
+import requests
+from openbb_provider.utils.helpers import get_querystring
+
+
+def get_token():
+    return requests.post(
+        "http://0.0.0.0:8000/api/v1/account/token",
+        data={"username": "openbb", "password": "openbb"},
+        timeout=5,
+    )
+
+
+@pytest.fixture(scope="session")
+def headers():
+    access_token = get_token().json()["access_token"]
+    return {"Authorization": f"Bearer {access_token}"}
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({}),
+        (
+            {
+                "symbol": "EURUSD",
+                "date": "2023-01-01",
+                "search": "USD",
+                "active": True,
+                "order": "asc",
+                "sort": "ticker",
+                "limit": 1000,
+                "provider": "polygon",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_forex_pairs(params, headers):
+    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/forex/pairs?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "EURUSD", "start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "interval": "1min",
+                "provider": "fmp",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1day",
+                "provider": "fmp",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "minute",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "day",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "5m",
+                "period": "max",
+                "provider": "yfinance",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "period": "max",
+                "provider": "yfinance",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_forex_load(params, headers):
+    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/forex/load?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_sdk/extensions/forex/integration/test_forex_python.py

@@ -0,0 +1,116 @@
+"""Test forex extension."""
+import datetime
+
+import pytest
+from openbb import obb
+from openbb_core.app.model.obbject import OBBject
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({}),
+        (
+            {
+                "symbol": "EURUSD",
+                "date": datetime.date(2023, 9, 25),
+                "search": "USD",
+                "active": True,
+                "order": "asc",
+                "sort": "ticker",
+                "limit": 1000,
+                "provider": "polygon",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_forex_pairs(params):
+    result = obb.forex.pairs(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1min",
+                "provider": "fmp",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1day",
+                "provider": "fmp",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "minute",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "day",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "5m",
+                "period": "max",
+                "provider": "yfinance",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "period": "max",
+                "provider": "yfinance",
+                "symbol": "EURUSD",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_forex_load(params):
+    result = obb.forex.load(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0

openbb_sdk/extensions/futures/integration/test_futures_api.py

@@ -0,0 +1,70 @@
+import pytest
+import requests
+from openbb_provider.utils.helpers import get_querystring
+
+
+def get_token():
+    return requests.post(
+        "http://0.0.0.0:8000/api/v1/account/token",
+        data={"username": "openbb", "password": "openbb"},
+        timeout=5,
+    )
+
+
+@pytest.fixture(scope="session")
+def headers():
+    access_token = get_token().json()["access_token"]
+    return {"Authorization": f"Bearer {access_token}"}
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "ES",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "expiration": "2024-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "period": "1d",
+                "prepost": True,
+                "adjust": True,
+                "back_adjust": True,
+                "provider": "yfinance",
+                "symbol": "ES",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "expiration": "2024-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_futures_load(params, headers):
+    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/futures/load?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "date": "2023-01-01"})],
+)
+@pytest.mark.integration
+def test_futures_curve(params, headers):
+    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/futures/curve?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_sdk/extensions/futures/integration/test_futures_python.py

@@ -0,0 +1,53 @@
+"""Test futures extension."""
+import pytest
+from openbb import obb
+from openbb_core.app.model.obbject import OBBject
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "ES",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "expiration": "2024-06",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "period": "1d",
+                "prepost": True,
+                "adjust": True,
+                "back_adjust": True,
+                "provider": "yfinance",
+                "symbol": "ES",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "expiration": "2024-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_futures_load(params):
+    result = obb.futures.load(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "date": "2023-01-01"}),
+    ],
+)
+@pytest.mark.integration
+def test_futures_curve(params):
+    result = obb.futures.curve(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0

openbb_sdk/extensions/news/integration/test_news_api.py

@@ -0,0 +1,54 @@
+import pytest
+import requests
+from openbb_provider.utils.helpers import get_querystring
+
+
+def get_token():
+    return requests.post(
+        "http://0.0.0.0:8000/api/v1/account/token",
+        data={"username": "openbb", "password": "openbb"},
+        timeout=5,
+    )
+
+
+@pytest.fixture(scope="session")
+def headers():
+    access_token = get_token().json()["access_token"]
+    return {"Authorization": f"Bearer {access_token}"}
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"limit": 20}),
+        (
+            {
+                "display": "full",
+                "date": "2023-01-01",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "updated_since": 1,
+                "published_since": 1,
+                "sort": "created",
+                "order": "desc",
+                "isin": "US0378331005",
+                "cusip": "037833100",
+                "channels": "General",
+                "topics": "AAPL",
+                "authors": "Benzinga Insights",
+                "content_types": "headline",
+                "provider": "benzinga",
+                "limit": 20,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_news_globalnews(params, headers):
+    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/news/globalnews?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_sdk/extensions/news/integration/test_news_python.py

@@ -0,0 +1,38 @@
+"""Test news extension."""
+
+import pytest
+from openbb import obb
+from openbb_core.app.model.obbject import OBBject
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"limit": 20}),
+        (
+            {
+                "display": "full",
+                "date": "2023-01-01",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "updated_since": 900000,
+                "published_since": 900000,
+                "sort": "created",
+                "order": "desc",
+                "isin": "US0378331005",
+                "cusip": "037833100",
+                "channels": "General",
+                "topics": "car",
+                "authors": "Benzinga Insights",
+                "content_types": "Car",
+                "provider": "benzinga",
+                "limit": 20,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_news_globalnews(params):
+    result = obb.news.globalnews(**params)
+    assert result
+    assert isinstance(result, OBBject)

openbb_sdk/extensions/qa/integration/test_qa_api.py

@@ -0,0 +1,167 @@
+import pytest
+import requests
+from openbb_provider.utils.helpers import get_querystring
+
+
+def get_token():
+    return requests.post(
+        "http://0.0.0.0:8000/api/v1/account/token",
+        data={"username": "openbb", "password": "openbb"},
+        timeout=5,
+    )
+
+
+@pytest.fixture(scope="session")
+def headers():
+    access_token = get_token().json()["access_token"]
+    return {"Authorization": f"Bearer {access_token}"}
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": ""})],
+)
+@pytest.mark.integration
+def test_qa_normality(params, headers):
+    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/qa/normality?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": ""})],
+)
+@pytest.mark.integration
+def test_qa_capm(params, headers):
+    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/qa/capm?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "threshold_start": "", "threshold_end": ""})],
+)
+@pytest.mark.integration
+def test_qa_om(params, headers):
+    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/qa/om?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "window": ""})],
+)
+@pytest.mark.integration
+def test_qa_kurtosis(params, headers):
+    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/qa/kurtosis?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "fuller_reg": "", "kpss_reg": ""})],
+)
+@pytest.mark.integration
+def test_qa_unitroot(params, headers):
+    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/qa/unitroot?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "rfr": "", "window": ""})],
+)
+@pytest.mark.integration
+def test_qa_sh(params, headers):
+    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/qa/sh?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "target_return": "", "window": "", "adjusted": ""})],
+)
+@pytest.mark.integration
+def test_qa_so(params, headers):
+    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/qa/so?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "window": ""})],
+)
+@pytest.mark.integration
+def test_qa_skew(params, headers):
+    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/qa/skew?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "window": "", "quantile_pct": ""})],
+)
+@pytest.mark.integration
+def test_qa_quantile(params, headers):
+    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/qa/quantile?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": ""})],
+)
+@pytest.mark.integration
+def test_qa_summary(params, headers):
+    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/qa/summary?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_sdk/extensions/stocks/integration/test_stocks_api.py

@@ -0,0 +1,822 @@
+import pytest
+import requests
+from openbb_provider.utils.helpers import get_querystring
+
+
+def get_token():
+    return requests.post(
+        "http://0.0.0.0:8000/api/v1/account/token",
+        data={"username": "openbb", "password": "openbb"},
+        timeout=5,
+    )
+
+
+@pytest.fixture(scope="session")
+def headers():
+    access_token = get_token().json()["access_token"]
+    return {"Authorization": f"Bearer {access_token}"}
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "period": "annual", "limit": 12}),
+        (
+            {
+                "type": "reported",
+                "year": 2023,
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+        (
+            {
+                "company_name": "Apple Inc",
+                "company_name_search": "AAPL",
+                "sic": "35719904",
+                "include_sources": True,
+                "order": "asc",
+                "sort": "filing_date",
+                "provider": "polygon",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_balance(params, headers):
+    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/stocks/fa/balance?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "limit": 10})],
+)
+@pytest.mark.integration
+def test_stocks_fa_balance_growth(params, headers):
+    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/stocks/fa/balance_growth?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"start_date": "2023-01-01", "end_date": "2023-06-06"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_cal(params, headers):
+    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/stocks/fa/cal?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "period": "annual", "limit": 12}),
+        (
+            {
+                "type": "reported",
+                "year": 2023,
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+        (
+            {
+                "company_name": "Apple Inc",
+                "company_name_search": "AAPL",
+                "sic": "35719904",
+                "include_sources": True,
+                "order": "asc",
+                "sort": "filing_date",
+                "provider": "polygon",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_cash(params, headers):
+    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/stocks/fa/cash?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "limit": 10})],
+)
+@pytest.mark.integration
+def test_stocks_fa_cash_growth(params, headers):
+    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/stocks/fa/cash_growth?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_comp(params, headers):
+    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/stocks/fa/comp?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"start_date": "2023-01-01", "end_date": "2023-06-06"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_comsplit(params, headers):
+    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/stocks/fa/comsplit?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_divs(params, headers):
+    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/stocks/fa/divs?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "limit": 50})],
+)
+@pytest.mark.integration
+def test_stocks_fa_earning(params, headers):
+    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/stocks/fa/earning?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_emp(params, headers):
+    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/stocks/fa/emp?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "period": "annual", "limit": 30})],
+)
+@pytest.mark.integration
+def test_stocks_fa_est(params, headers):
+    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/stocks/fa/est?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "period": "annual", "limit": 12}),
+        (
+            {
+                "type": "reported",
+                "year": 2023,
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+        (
+            {
+                "company_name": "Apple Inc",
+                "company_name_search": "AAPL",
+                "sic": "35719904",
+                "include_sources": True,
+                "order": "asc",
+                "sort": "filing_date",
+                "provider": "polygon",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_income(params, headers):
+    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/stocks/fa/income?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "limit": 10, "period": "annual"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_income_growth(params, headers):
+    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/stocks/fa/income_growth?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "AAPL",
+                "transactionType": ["P-Purchase"],
+                "reportingCik": 1,
+                "companyCik": 1,
+                "page": 1,
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_ins(params, headers):
+    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/stocks/fa/ins?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "include_current_quarter": True, "date": "2023-01-01"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_ins_own(params, headers):
+    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/stocks/fa/ins_own?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "period": "annual", "limit": 100})],
+)
+@pytest.mark.integration
+def test_stocks_fa_metrics(params, headers):
+    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/stocks/fa/metrics?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_mgmt(params, headers):
+    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/stocks/fa/mgmt?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_overview(params, headers):
+    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/stocks/fa/overview?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "date": "2023-01-01", "page": 1})],
+)
+@pytest.mark.integration
+def test_stocks_fa_own(params, headers):
+    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/stocks/fa/own?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_pt(params, headers):
+    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/stocks/fa/pt?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL"}), ({"with_grade": True, "provider": "fmp", "symbol": "AAPL"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_pta(params, headers):
+    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/stocks/fa/pta?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "period": "annual", "limit": 12})],
+)
+@pytest.mark.integration
+def test_stocks_fa_ratios(params, headers):
+    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/stocks/fa/ratios?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "period": "annual", "structure": "flat"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_revgeo(params, headers):
+    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/stocks/fa/revgeo?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "period": "annual", "structure": "flat"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_revseg(params, headers):
+    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/stocks/fa/revseg?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "type": "1", "page": 1, "limit": 100})],
+)
+@pytest.mark.integration
+def test_stocks_fa_sec(params, headers):
+    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/stocks/fa/sec?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_shrs(params, headers):
+    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/stocks/fa/shrs?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL"})],
+)
+@pytest.mark.integration
+def test_stocks_fa_split(params, headers):
+    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/stocks/fa/split?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "year": 2023, "quarter": 1})],
+)
+@pytest.mark.integration
+def test_stocks_fa_transcript(params, headers):
+    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/stocks/fa/transcript?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL"})],
+)
+@pytest.mark.integration
+def test_stocks_ca_peers(params, headers):
+    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/stocks/ca/peers?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+        ({"date": "2023-01-01", "provider": "intrinio", "symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_options_chains(params, headers):
+    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/stocks/options/chains?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "start_date": "2023-01-01", "end_date": "2023-06-06"}),
+        (
+            {
+                "period": "daily",
+                "interval": "60min",
+                "adjusted": True,
+                "extended_hours": True,
+                "month": "2023-03",
+                "outputsize": "full",
+                "provider": "alpha_vantage",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "provider": "cboe",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "cboe",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1min",
+                "provider": "fmp",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1day",
+                "provider": "fmp",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "timezone": "UTC",
+                "interval_size": "30m",
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "timezone": "UTC",
+                "source": "realtime",
+                "interval_size": "60m",
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "minute",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "day",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "period": "max",
+                "prepost": True,
+                "actions": True,
+                "auto_adjust": True,
+                "back_adjust": True,
+                "progress": True,
+                "ignore_tz": True,
+                "rounding": True,
+                "repair": True,
+                "keepna": True,
+                "group_by": "column",
+                "provider": "yfinance",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "period": "max",
+                "prepost": True,
+                "actions": True,
+                "auto_adjust": True,
+                "back_adjust": True,
+                "progress": True,
+                "ignore_tz": True,
+                "rounding": True,
+                "repair": True,
+                "keepna": True,
+                "group_by": "column",
+                "provider": "yfinance",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_load(params, headers):
+    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/stocks/load?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbols": "AAPL,MSFT", "limit": 20}),
+        (
+            {
+                "display": "full",
+                "date": "2023-01-01",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "updated_since": 1,
+                "published_since": 1,
+                "sort": "created",
+                "order": "desc",
+                "isin": "US0378331005",
+                "cusip": "037833100",
+                "channels": "General",
+                "topics": "AAPL",
+                "authors": "Benzinga Insights",
+                "content_types": "headline",
+                "provider": "benzinga",
+                "symbols": "AAPL,MSFT",
+                "limit": 20,
+            }
+        ),
+        (
+            {
+                "published_utc": "2023-01-01",
+                "order": "desc",
+                "provider": "polygon",
+                "symbols": "AAPL",
+                "limit": 20,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_news(params, headers):
+    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/stocks/news?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL", "limit": 100})],
+)
+@pytest.mark.integration
+def test_stocks_multiples(params, headers):
+    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/stocks/multiples?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"query": "AAPl", "ticker": True})],
+)
+@pytest.mark.integration
+def test_stocks_search(params, headers):
+    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/stocks/search?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+        ({"source": "iex", "provider": "intrinio", "symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_quote(params, headers):
+    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/stocks/quote?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"symbol": "AAPL"})],
+)
+@pytest.mark.integration
+def test_stocks_info(params, headers):
+    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/stocks/info?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_sdk/extensions/stocks/integration/test_stocks_python.py

@@ -0,0 +1,779 @@
+"""Test stocks extension."""
+import pytest
+from openbb import obb
+from openbb_core.app.model.obbject import OBBject
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "period": "annual", "limit": 12}),
+        (
+            {
+                "type": "reported",
+                "year": 2023,
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+        (
+            {
+                "company_name": "Apple Inc",
+                "company_name_search": "AAPL",
+                "sic": "35719904",
+                "include_sources": True,
+                "order": "asc",
+                "sort": "filing_date",
+                "provider": "polygon",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_balance(params):
+    result = obb.stocks.fa.balance(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "limit": 10}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_balance_growth(params):
+    result = obb.stocks.fa.balance_growth(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_cal(params):
+    result = obb.stocks.fa.cal(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "period": "annual", "limit": 12}),
+        (
+            {
+                "type": "reported",
+                "year": 2023,
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+        (
+            {
+                "company_name": "Apple Inc",
+                "company_name_search": "AAPL",
+                "sic": "35719904",
+                "include_sources": True,
+                "order": "asc",
+                "sort": "filing_date",
+                "provider": "polygon",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_cash(params):
+    result = obb.stocks.fa.cash(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "limit": 10}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_cash_growth(params):
+    result = obb.stocks.fa.cash_growth(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_comp(params):
+    result = obb.stocks.fa.comp(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_comsplit(params):
+    result = obb.stocks.fa.comsplit(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_divs(params):
+    result = obb.stocks.fa.divs(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "limit": 50}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_earning(params):
+    result = obb.stocks.fa.earning(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_emp(params):
+    result = obb.stocks.fa.emp(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "period": "annual", "limit": 30}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_est(params):
+    result = obb.stocks.fa.est(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "period": "annual", "limit": 12}),
+        (
+            {
+                "type": "reported",
+                "year": 2023,
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+        (
+            {
+                "company_name": "Apple Inc",
+                "company_name_search": "AAPL",
+                "sic": "35719904",
+                "include_sources": True,
+                "order": "asc",
+                "sort": "filing_date",
+                "provider": "polygon",
+                "symbol": "AAPL",
+                "period": "annual",
+                "limit": 12,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_income(params):
+    result = obb.stocks.fa.income(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "limit": 10, "period": "annual"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_income_growth(params):
+    result = obb.stocks.fa.income_growth(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "AAPL",
+                "transactionType": ["P-Purchase"],
+                "reportingCik": 1,
+                "companyCik": 1,
+                "page": 1,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_ins(params):
+    result = obb.stocks.fa.ins(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "AAPL",
+                "include_current_quarter": True,
+                "date": "2023-01-01",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_ins_own(params):
+    result = obb.stocks.fa.ins_own(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "period": "annual", "limit": 100}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_metrics(params):
+    result = obb.stocks.fa.metrics(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_mgmt(params):
+    result = obb.stocks.fa.mgmt(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_overview(params):
+    result = obb.stocks.fa.overview(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "date": "2023-01-01", "page": 1}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_own(params):
+    result = obb.stocks.fa.own(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_pt(params):
+    result = obb.stocks.fa.pt(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+        ({"with_grade": True, "provider": "fmp", "symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_pta(params):
+    result = obb.stocks.fa.pta(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "period": "annual", "limit": 12}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_ratios(params):
+    result = obb.stocks.fa.ratios(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "period": "annual", "structure": "flat"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_revgeo(params):
+    result = obb.stocks.fa.revgeo(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "period": "annual", "structure": "flat"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_revseg(params):
+    result = obb.stocks.fa.revseg(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "type": "1", "page": 1, "limit": 100}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_sec(params):
+    result = obb.stocks.fa.sec(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_shrs(params):
+    result = obb.stocks.fa.shrs(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_split(params):
+    result = obb.stocks.fa.split(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "year": 2023, "quarter": 1}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_fa_transcript(params):
+    result = obb.stocks.fa.transcript(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_ca_peers(params):
+    result = obb.stocks.ca.peers(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+        ({"date": "2023-01-01", "provider": "intrinio", "symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_options_chains(params):
+    result = obb.stocks.options.chains(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "period": "daily",
+                "interval": "60min",
+                "adjusted": True,
+                "extended_hours": True,
+                "month": "2023-03",
+                "outputsize": "full",
+                "provider": "alpha_vantage",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "provider": "cboe",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "provider": "cboe",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1min",
+                "provider": "fmp",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1day",
+                "provider": "fmp",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "timezone": "UTC",
+                "interval_size": "30m",
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "timezone": "UTC",
+                "source": "realtime",
+                "interval_size": "60m",
+                "provider": "intrinio",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "minute",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "multiplier": 1,
+                "timespan": "day",
+                "sort": "desc",
+                "limit": 49999,
+                "adjusted": True,
+                "provider": "polygon",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+        (
+            {
+                "interval": "1m",
+                "period": "max",
+                "prepost": True,
+                "actions": True,
+                "auto_adjust": True,
+                "back_adjust": True,
+                "progress": True,
+                "ignore_tz": True,
+                "rounding": True,
+                "repair": True,
+                "keepna": True,
+                "group_by": "column",
+                "provider": "yfinance",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-02",
+            }
+        ),
+        (
+            {
+                "interval": "1d",
+                "period": "max",
+                "prepost": True,
+                "actions": True,
+                "auto_adjust": True,
+                "back_adjust": True,
+                "progress": True,
+                "ignore_tz": True,
+                "rounding": True,
+                "repair": True,
+                "keepna": True,
+                "group_by": "column",
+                "provider": "yfinance",
+                "symbol": "AAPL",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_load(params):
+    result = obb.stocks.load(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbols": "AAPL,MSFT", "limit": 20}),
+        (
+            {
+                "display": "full",
+                "date": "2023-01-01",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "updated_since": 1,
+                "published_since": 1,
+                "sort": "created",
+                "order": "desc",
+                "isin": "US0378331005",
+                "cusip": "037833100",
+                "channels": "General",
+                "topics": "AAPL",
+                "authors": "Benzinga Insights",
+                "content_types": "headline",
+                "provider": "benzinga",
+                "symbols": "AAPL,MSFT",
+                "limit": 20,
+            }
+        ),
+        (
+            {
+                "published_utc": "2023-01-01",
+                "order": "desc",
+                "provider": "polygon",
+                "symbols": "AAPL",
+                "limit": 20,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_news(params):
+    result = obb.stocks.news(**params)
+    assert result
+    assert isinstance(result, OBBject)
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL", "limit": 100}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_multiples(params):
+    result = obb.stocks.multiples(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"query": "AAPL", "ticker": True}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_search(params):
+    result = obb.stocks.search(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+        ({"source": "iex", "provider": "intrinio", "symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_quote(params):
+    result = obb.stocks.quote(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        ({"symbol": "AAPL"}),
+    ],
+)
+@pytest.mark.integration
+def test_stocks_info(params):
+    result = obb.stocks.info(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0

openbb_sdk/extensions/ta/integration/test_ta_api.py

@@ -0,0 +1,507 @@
+import pytest
+import requests
+from openbb_provider.utils.helpers import get_querystring
+
+
+def get_token():
+    return requests.post(
+        "http://0.0.0.0:8000/api/v1/account/token",
+        data={"username": "openbb", "password": "openbb"},
+        timeout=5,
+    )
+
+
+@pytest.fixture(scope="session")
+def headers():
+    access_token = get_token().json()["access_token"]
+    return {"Authorization": f"Bearer {access_token}"}
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "index": "",
+                "length": "",
+                "mamode": "",
+                "drift": "",
+                "offset": "",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_ta_atr(params, headers):
+    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/ta/atr?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "index": "",
+                "close_column": "",
+                "period": "",
+                "start_date": "",
+                "end_date": "",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_ta_fib(params, headers):
+    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/ta/fib?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "index": "", "offset": ""})],
+)
+@pytest.mark.integration
+def test_ta_obv(params, headers):
+    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/ta/obv?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "index": "", "length": "", "signal": ""})],
+)
+@pytest.mark.integration
+def test_ta_fisher(params, headers):
+    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/ta/fisher?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "index": "", "fast": "", "slow": "", "offset": ""})],
+)
+@pytest.mark.integration
+def test_ta_adosc(params, headers):
+    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/ta/adosc?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "target": "",
+                "index": "",
+                "length": "",
+                "std": "",
+                "mamode": "",
+                "offset": "",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_ta_bbands(params, headers):
+    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/ta/bbands?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "index": "", "length": "", "offset": ""})],
+)
+@pytest.mark.integration
+def test_ta_zlma(params, headers):
+    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/ta/zlma?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "index": "", "length": "", "scalar": ""})],
+)
+@pytest.mark.integration
+def test_ta_aroon(params, headers):
+    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/ta/aroon?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "index": "", "length": "", "offset": ""})],
+)
+@pytest.mark.integration
+def test_ta_sma(params, headers):
+    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/ta/sma?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "index": "",
+                "target": "",
+                "show_all": "",
+                "asint": "",
+                "offset": "",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_ta_demark(params, headers):
+    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/ta/demark?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "index": "", "anchor": "", "offset": ""})],
+)
+@pytest.mark.integration
+def test_ta_vwap(params, headers):
+    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/ta/vwap?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "index": "", "fast": "", "slow": "", "signal": ""})],
+)
+@pytest.mark.integration
+def test_ta_macd(params, headers):
+    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/ta/macd?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "index": "", "length": "", "offset": ""})],
+)
+@pytest.mark.integration
+def test_ta_hma(params, headers):
+    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/ta/hma?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "index": "", "lower_length": "", "upper_length": "", "offset": ""})],
+)
+@pytest.mark.integration
+def test_ta_donchian(params, headers):
+    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/ta/donchian?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "index": "",
+                "conversion": "",
+                "base": "",
+                "lagging": "",
+                "offset": "",
+                "lookahead": "",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_ta_ichimoku(params, headers):
+    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/ta/ichimoku?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "index": "", "target": "", "period": ""})],
+)
+@pytest.mark.integration
+def test_ta_clenow(params, headers):
+    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/ta/clenow?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "index": "", "offset": ""})],
+)
+@pytest.mark.integration
+def test_ta_ad(params, headers):
+    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/ta/ad?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "index": "", "length": "", "scalar": "", "drift": ""})],
+)
+@pytest.mark.integration
+def test_ta_adx(params, headers):
+    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/ta/adx?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "index": "", "length": "", "offset": ""})],
+)
+@pytest.mark.integration
+def test_ta_wma(params, headers):
+    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/ta/wma?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "index": "", "length": "", "scalar": ""})],
+)
+@pytest.mark.integration
+def test_ta_cci(params, headers):
+    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/ta/cci?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "target": "",
+                "index": "",
+                "length": "",
+                "scalar": "",
+                "drift": "",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_ta_rsi(params, headers):
+    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/ta/rsi?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "index": "",
+                "fast_k_period": "",
+                "slow_d_period": "",
+                "slow_k_period": "",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_ta_stoch(params, headers):
+    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/ta/stoch?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "index": "",
+                "length": "",
+                "scalar": "",
+                "mamode": "",
+                "offset": "",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_ta_kc(params, headers):
+    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/ta/kc?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "index": "", "length": ""})],
+)
+@pytest.mark.integration
+def test_ta_cg(params, headers):
+    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/ta/cg?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "index": "",
+                "lower_q": "",
+                "upper_q": "",
+                "model": "",
+                "is_crypto": "",
+            }
+        )
+    ],
+)
+@pytest.mark.integration
+def test_ta_cones(params, headers):
+    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/ta/cones?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "params",
+    [({"data": "", "target": "", "index": "", "length": "", "offset": ""})],
+)
+@pytest.mark.integration
+def test_ta_ema(params, headers):
+    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/ta/ema?{query_str}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200

openbb_sdk/extensions/tests/utils/integration_test_generator.py

@@ -0,0 +1,184 @@
+"""Integration test generator."""
+from pathlib import Path, PosixPath
+from typing import Any, Dict, List, Literal, get_origin
+
+from pydantic.fields import ModelField
+from sdk.core.openbb_core.app.provider_interface import ProviderInterface
+from sdk.core.openbb_core.app.router import CommandMap
+
+cm = CommandMap(coverage_sep=".")
+
+
+def find_extensions():
+    """Find extensions."""
+    filter_ext = ["tests", "ta", "qa", "econometrics", "charting"]
+    extensions = [x for x in Path("openbb_sdk/extensions").iterdir() if x.is_dir()]
+    extensions = [x for x in extensions if x.name not in filter_ext]
+    return extensions
+
+
+def create_integration_test_files(extensions: List[PosixPath]) -> None:
+    """Create integration test files for the python interface."""
+    for extension in extensions:
+        extension_name = extension.name
+        test_file_name = f"test_{extension_name}_python.py"
+        test_file = extension / "integration" / test_file_name
+        if not test_file.exists():
+            with open(test_file, "w") as f:
+                f.write(
+                    f'''"""Test {extension_name} extension."""
+import pytest
+from openbb import obb
+from openbb_core.app.model.obbject import OBBject
+    '''
+                )
+
+
+def get_model_params(param_fields: Dict[str, ModelField]) -> Dict[str, Any]:
+    """Get the test params for the fetcher based on the required standard params."""
+    test_params: Dict[str, Any] = {}
+    for field_name, field in param_fields.items():
+        if field.default:
+            test_params[field_name] = field.default
+        elif not field.default:
+            example_dict = {
+                "symbol": "AAPL",
+                "symbols": "AAPL,MSFT",
+                "start_date": "2023-01-01",
+                "end_date": "2023-06-06",
+                "country": "Portugal",
+                "date": "2023-01-01",
+                "countries": ["portugal", "spain"],
+            }
+            if field_name in example_dict:
+                test_params[field_name] = example_dict[field_name]
+            elif field.type_ == str:
+                test_params[field_name] = "TEST_STRING"
+            elif field.type_ == int:
+                test_params[field_name] = 1
+            elif field.type_ == float:
+                test_params[field_name] = 1.0
+            elif field.type_ == bool:
+                test_params[field_name] = True
+            elif get_origin(field.type_) is Literal:
+                test_params[field_name] = field.type_.__args__[0]
+
+    return test_params
+
+
+def get_test_params(
+    model_name: str, provider_interface_map: Dict[str, Any]
+) -> List[Dict[str, Any]]:
+    """Get the test params for the integration test."""
+    test_params_list: List[Dict[str, Any]] = []
+    available_providers = provider_interface_map[model_name].keys()
+    standard_params = get_model_params(
+        param_fields=provider_interface_map[model_name]["openbb"]["QueryParams"][
+            "fields"
+        ]
+    )
+
+    test_params_list.append(standard_params)
+
+    for provider in available_providers:
+        if provider != "openbb":
+            test_params: Dict[str, Any] = get_model_params(
+                param_fields=provider_interface_map[model_name][provider][
+                    "QueryParams"
+                ]["fields"]
+            )
+            if test_params:
+                test_params["provider"] = provider
+                test_params.update(standard_params)
+                test_params_list.append(test_params)
+
+    return test_params_list
+
+
+def add_test_commands_to_file(  # pylint: disable=W0102
+    extensions: List[PosixPath],
+    commands_model: Dict[str, str] = cm.commands_model,
+) -> None:
+    """Add test commands to file."""
+    provider_interface = ProviderInterface()
+    provider_interface_map = provider_interface.map
+
+    template = """\n\n@pytest.mark.parametrize(
+    "params",
+    [
+        {params}
+    ],
+)
+@pytest.mark.integration
+def test_{test_name}(**params):
+    result = obb.{command_name}(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+"""
+    for extension in extensions:
+        extension_name = extension.name
+        test_file_name = f"test_{extension_name}_python.py"
+        test_file = extension / "integration" / test_file_name
+        with open(test_file, "a") as f:
+            for command in commands_model:
+                if extension_name in command and command.startswith(
+                    f".{extension_name}."
+                ):
+                    extension_name = command.split(".")[1]
+
+                    if len(command.split(".")) > 3:
+                        test_name = (
+                            extension_name
+                            + "_"
+                            + command.split(".")[2]
+                            + "_"
+                            + command.split(".")[3]
+                        )
+                    elif len(command.split(".")) == 3:
+                        test_name = extension_name + "_" + command.split(".")[2]
+
+                    command_name = command.split(".")[-1]
+                    if "_" in command_name:
+                        full_command_name = test_name.replace("_", ".", 2)
+                        # The code below double checks if the full command name is correct.
+                        # This eliminates edge cases.
+                        fix_full_command_name = full_command_name.split(".")
+                        for i, part in enumerate(fix_full_command_name):
+                            if part == command_name.split("_")[0]:
+                                fix_full_command_name[i] = command_name
+                                fix_full_command_name.pop()
+
+                        full_command_name = ".".join(fix_full_command_name)
+
+                    else:
+                        full_command_name = test_name.replace("_", ".")
+
+                    test_params_list = get_test_params(
+                        model_name=commands_model[command],
+                        provider_interface_map=provider_interface_map,
+                    )
+
+                    params = ""
+                    for test_params in test_params_list:
+                        params += f"({test_params}),\n"
+
+                    read_file = open(test_file)  # noqa
+                    if full_command_name not in read_file.read():
+                        f.write(
+                            template.format(
+                                test_name=test_name,
+                                command_name=full_command_name,
+                                params=params,
+                            )
+                        )
+
+
+def write_integration_test() -> None:
+    """Write integration test."""
+    extensions = find_extensions()
+    create_integration_test_files(extensions)
+    add_test_commands_to_file(extensions)
+
+
+write_integration_test()

openbb_sdk/extensions/tests/utils/integration_tests_api_generator.py

@@ -0,0 +1,135 @@
+import os
+from typing import Dict, List, Type, get_type_hints
+
+import requests
+from extensions.tests.utils.integration_test_generator import get_test_params
+from openbb_core.app.provider_interface import ProviderInterface
+from openbb_core.app.router import CommandMap
+
+
+def get_http_method(api_paths: Dict[str, dict], route: str):
+    route_info = api_paths.get(route, None)
+    if not route_info:
+        return route_info
+    return list(route_info.keys())[0]
+
+
+def get_post_flat_params(hints: Dict[str, Type]):
+    return list(hints.keys())
+
+
+def write_init_test_template(path: str):
+    template = """
+import pytest
+import requests
+from openbb_provider.utils.helpers import get_querystring
+
+
+def get_token():
+    return requests.post(
+        "http://0.0.0.0:8000/api/v1/account/token",
+        data={"username": "openbb", "password": "openbb"},
+        timeout=5,
+    )
+
+
+@pytest.fixture(scope="session")
+def headers():
+    access_token = get_token().json()["access_token"]
+    return {"Authorization": f"Bearer {access_token}"}
+"""
+
+    with open(path, "w") as f:
+        f.write(template)
+
+
+def write_test_w_template(params_list: List[Dict[str, str]], route: str, path: str):
+    params_str = ",\n".join([f"({params})" for params in params_list])
+
+    template = f"""
+@pytest.mark.parametrize(
+    "params",
+    [{params_str}],
+)
+@pytest.mark.integration
+def test_{route.replace("/", "_")[1:]}(params, headers):
+    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{route}?{{query_str}}"
+    result = requests.get(url, headers=headers, timeout=5)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+"""
+
+    with open(path, "a") as f:
+        f.write(template)
+
+
+def test_exists(route: str, path: str):
+    with open(path) as f:
+        return route.replace("/", "_")[1:] in f.read()
+
+
+def write_integration_tests(
+    command_map: CommandMap,
+    provider_interface: ProviderInterface,
+    api_paths: Dict[str, dict],
+) -> List[str]:
+    commands_not_found = []
+
+    commandmap_map = command_map.map
+    commandmap_models = command_map.commands_model
+    provider_interface_map = provider_interface.map
+
+    for route in commandmap_map:
+        http_method = get_http_method(api_paths, f"/api/v1{route}")
+
+        menu = route.split("/")[1]
+        path = os.path.join(
+            "openbb_sdk", "extensions", menu, "integration", f"test_{menu}_api.py"
+        )
+        if not os.path.exists(path):
+            write_init_test_template(path=path)
+
+        if not http_method:
+            commands_not_found.append(route)
+        else:
+            hints = get_type_hints(commandmap_map[route])
+            hints.pop("cc", None)
+            hints.pop("return", None)
+
+            params_list = (
+                [{k: "" for k in get_post_flat_params(hints)}]
+                if http_method == "post"
+                else get_test_params(
+                    model_name=commandmap_models[route],
+                    provider_interface_map=provider_interface_map,
+                )
+            )
+
+            if not test_exists(route=route, path=path):
+                write_test_w_template(params_list=params_list, route=route, path=path)
+
+    return commands_not_found
+
+
+if __name__ == "__main__":
+    r = requests.get("http://0.0.0.0:8000/openapi.json", timeout=5).json()
+
+    if not r:
+        raise Exception("Could not get openapi.json")
+
+    command_map = CommandMap()
+    provider_interface = ProviderInterface()
+
+    commands_not_found_in_openapi = write_integration_tests(
+        command_map=command_map,
+        provider_interface=provider_interface,
+        api_paths=r["paths"],
+    )
+
+    if commands_not_found_in_openapi:
+        print(  # noqa
+            f"Commands not found in openapi.json: {commands_not_found_in_openapi}"
+        )

openbb_sdk/openbb/package/__extensions__.py

@@ -9,25 +9,38 @@ class Extensions(Container):
     """
 Routers:
     /crypto
+    /econometrics
     /economy
     /fixedincome
     /forex
+    /futures
     /news
+    /qa
     /stocks
+    /ta
 
 Extensions:
     - crypto@0.1.0a2
+    - econometrics@0.1.0a2
     - economy@0.1.0a2
     - fixedincome@0.1.0a2
     - forex@0.1.0a2
+    - futures@0.1.0a2
     - news@0.1.0a2
+    - openbb_charting@0.1.0a2
+    - qa@0.1.0a2
     - stocks@0.1.0a2
+    - ta@0.1.0a2
 
+    - alpha_vantage@0.1.0a2
     - benzinga@0.1.0a2
+    - cboe@0.1.0a2
     - fmp@0.1.0a2
     - fred@0.1.0a2
     - intrinio@0.1.0a2
-    - polygon@0.1.0a2    """
+    - polygon@0.1.0a2
+    - quandl@0.1.0a2
+    - yfinance@0.1.0a2    """
     # fmt: on
     def __repr__(self) -> str:
         return self.__doc__ or ""
@@ -38,6 +51,12 @@ Extensions:
 
         return crypto.ROUTER_crypto(command_runner=self._command_runner)
 
+    @property
+    def econometrics(self):  # route = "/econometrics"
+        from . import econometrics
+
+        return econometrics.ROUTER_econometrics(command_runner=self._command_runner)
+
     @property
     def economy(self):  # route = "/economy"
         from . import economy
@@ -56,14 +75,32 @@ Extensions:
 
         return forex.ROUTER_forex(command_runner=self._command_runner)
 
+    @property
+    def futures(self):  # route = "/futures"
+        from . import futures
+
+        return futures.ROUTER_futures(command_runner=self._command_runner)
+
     @property
     def news(self):  # route = "/news"
         from . import news
 
         return news.ROUTER_news(command_runner=self._command_runner)
 
+    @property
+    def qa(self):  # route = "/qa"
+        from . import qa
+
+        return qa.ROUTER_qa(command_runner=self._command_runner)
+
     @property
     def stocks(self):  # route = "/stocks"
         from . import stocks
 
         return stocks.ROUTER_stocks(command_runner=self._command_runner)
+
+    @property
+    def ta(self):  # route = "/ta"
+        from . import ta
+
+        return ta.ROUTER_ta(command_runner=self._command_runner)

openbb_sdk/openbb/package/crypto.py

@@ -38,7 +38,7 @@ class ROUTER_crypto(Container):
                 description="End date of the data, in YYYY-MM-DD format."
             ),
         ] = None,
-        provider: Union[Literal["fmp", "polygon"], None] = None,
+        provider: Union[Literal["fmp", "polygon", "yfinance"], None] = None,
         **kwargs
     ) -> OBBject[List]:
         """Crypto Historical Price.
@@ -51,14 +51,14 @@ class ROUTER_crypto(Container):
             Start date of the data, in YYYY-MM-DD format.
         end_date : Union[datetime.date, None, str]
             End date of the data, in YYYY-MM-DD format.
-        provider : Union[Literal['fmp', 'polygon'], None]
+        provider : Union[Literal['fmp', 'polygon', 'yfinance'], None]
             The provider to use for the query, by default None.
             If None, the provider specified in defaults is selected or 'fmp' if there is
             no default.
         timeseries : Union[pydantic.types.NonNegativeInt, None]
             Number of days to look back. (provider: fmp)
-        interval : Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day']
-            Data granularity. (provider: fmp)
+        interval : Union[Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'], Literal['1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo']]
+            Data granularity. (provider: fmp, yfinance)
         multiplier : PositiveInt
             Multiplier of the timespan. (provider: polygon)
         timespan : Literal['minute', 'hour', 'day', 'week', 'month', 'quarter', 'year']
@@ -69,13 +69,15 @@ class ROUTER_crypto(Container):
             The number of data entries to return. (provider: polygon)
         adjusted : bool
             Whether the data is adjusted. (provider: polygon)
+        period : Literal['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']
+            Period of the data to return. (provider: yfinance)
 
         Returns
         -------
         OBBject
             results : List[CryptoHistorical]
                 Serializable results.
-            provider : Union[Literal['fmp', 'polygon'], None]
+            provider : Union[Literal['fmp', 'polygon', 'yfinance'], None]
                 Provider name.
             warnings : Optional[List[Warning_]]
                 List of warnings.

openbb_sdk/openbb/package/econometrics.py

@@ -0,0 +1,519 @@
+### THIS FILE IS AUTO-GENERATED. DO NOT EDIT. ###
+
+from typing import Dict, List, Literal, Union
+
+import openbb_provider
+import openbb_provider.abstract.data
+import pandas
+import pydantic
+import pydantic.types
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.app.static.container import Container
+from openbb_core.app.static.filters import filter_inputs
+from pydantic import validate_arguments
+
+
+class ROUTER_econometrics(Container):
+    """/econometrics
+    bgot
+    coint
+    corr
+    dwat
+    granger
+    ols
+    ols_summary
+    panelbols
+    panelfd
+    panelfmac
+    panelols
+    panelpols
+    panelre
+    unitroot
+    """
+
+    def __repr__(self) -> str:
+        return self.__doc__ or ""
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def bgot(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        y_column: str,
+        x_columns: List[str],
+        lags: pydantic.types.PositiveInt = 1,
+    ) -> OBBject[openbb_provider.abstract.data.Data]:
+        """Perform Breusch-Godfrey Lagrange Multiplier tests for residual autocorrelation.
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        y_column: str
+            Target column.
+        x_columns: str
+            List of columns to use as exogenous variables.
+        lags: PositiveInt
+            Number of lags to use in the test.
+        Returns
+        -------
+        OBBject[Data]
+            OBBject with the results being the score from the test.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            y_column=y_column,
+            x_columns=x_columns,
+            lags=lags,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/bgot",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def coint(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        columns: List[str],
+    ) -> OBBject[openbb_provider.abstract.data.Data]:
+        """Show co-integration between two timeseries using the two step Engle-Granger test.
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        columns: List[str]
+            Data columns to check cointegration
+        maxlag: PositiveInt
+            Number of lags to use in the test.
+        Returns
+        -------
+        OBBject[Data]
+            OBBject with the results being the score from the test.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            columns=columns,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/coint",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def corr(
+        self, data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame]
+    ) -> OBBject[List]:
+        """Get the corrlelation matrix of an input dataset.
+
+        Parameters
+        ----------
+        data : List[Data]
+            Input dataset.
+
+        Returns
+        -------
+        OBBject[List[Data]]
+            Correlation matrix.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/corr",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def dwat(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        y_column: str,
+        x_columns: List[str],
+    ) -> OBBject[Dict]:
+        """Perform Durbin-Watson test for autocorrelation
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        y_column: str
+            Target column.
+        x_columns: str
+            List of columns to use as exogenous variables.
+
+        Returns
+        -------
+        OBBject[Data]
+            OBBject with the results being the score from the test.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            y_column=y_column,
+            x_columns=x_columns,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/dwat",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def granger(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        y_column: str,
+        x_column: str,
+        lag: pydantic.types.PositiveInt = 3,
+    ) -> OBBject[openbb_provider.abstract.data.Data]:
+        """Perform Granger causality test to determine if X "causes" y.
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        y_column: str
+            Target column.
+        x_column: str
+            Columns to use as exogenous variables.
+        lag: PositiveInt
+            Number of lags to use in the test.
+        Returns
+        -------
+        OBBject[Data]
+            OBBject with the results being the score from the test.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            y_column=y_column,
+            x_column=x_column,
+            lag=lag,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/granger",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def ols(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        y_column: str,
+        x_columns: List[str],
+    ) -> OBBject[Dict]:
+        """Perform OLS regression.  This returns the model and results objects from statsmodels.
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        y_column: str
+            Target column.
+        x_columns: str
+            List of columns to use as exogenous variables.
+
+        Returns
+        -------
+        OBBject[Dict]
+            OBBject with the results being model and results objects.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            y_column=y_column,
+            x_columns=x_columns,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/ols",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def ols_summary(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        y_column: str,
+        x_columns: List[str],
+    ) -> OBBject[openbb_provider.abstract.data.Data]:
+        """Perform OLS regression.  This returns the summary object from statsmodels.
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        y_column: str
+            Target column.
+        x_columns: str
+            List of columns to use as exogenous variables.
+
+        Returns
+        -------
+        OBBject[Dict]
+            OBBject with the results being summary object.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            y_column=y_column,
+            x_columns=x_columns,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/ols_summary",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def panelbols(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        y_column: str,
+        x_columns: List[str],
+    ) -> OBBject[Dict]:
+        """Perform a Between estimator regression on panel data
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        y_column: str
+            Target column.
+        x_columns: str
+            List of columns to use as exogenous variables.
+
+        Returns
+        -------
+        OBBject[Dict]
+            OBBject with the fit model returned
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            y_column=y_column,
+            x_columns=x_columns,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/panelbols",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def panelfd(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        y_column: str,
+        x_columns: List[str],
+    ) -> OBBject[Dict]:
+        """Perform a first-difference estimate for panel data
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        y_column: str
+            Target column.
+        x_columns: str
+            List of columns to use as exogenous variables.
+
+        Returns
+        -------
+        OBBject[Dict]
+            OBBject with the fit model returned
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            y_column=y_column,
+            x_columns=x_columns,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/panelfd",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def panelfmac(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        y_column: str,
+        x_columns: List[str],
+    ) -> OBBject[Dict]:
+        """Fama-MacBeth estimator for panel data
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        y_column: str
+            Target column.
+        x_columns: str
+            List of columns to use as exogenous variables.
+
+        Returns
+        -------
+        OBBject[Dict]
+            OBBject with the fit model returned
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            y_column=y_column,
+            x_columns=x_columns,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/panelfmac",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def panelols(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        y_column: str,
+        x_columns: List[str],
+    ) -> OBBject[Dict]:
+        """One- and two-way fixed effects estimator for panel data
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        y_column: str
+            Target column.
+        x_columns: str
+            List of columns to use as exogenous variables.
+
+        Returns
+        -------
+        OBBject[Dict]
+            OBBject with the fit model returned
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            y_column=y_column,
+            x_columns=x_columns,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/panelols",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def panelpols(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        y_column: str,
+        x_columns: List[str],
+    ) -> OBBject[Dict]:
+        """Perform a Pooled coefficvient estimator regression on panel data
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        y_column: str
+            Target column.
+        x_columns: str
+            List of columns to use as exogenous variables.
+
+        Returns
+        -------
+        OBBject[Dict]
+            OBBject with the fit model returned
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            y_column=y_column,
+            x_columns=x_columns,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/panelpols",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def panelre(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        y_column: str,
+        x_columns: List[str],
+    ) -> OBBject[Dict]:
+        """Perform One-way Random Effects model for panel data
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        y_column: str
+            Target column.
+        x_columns: str
+            List of columns to use as exogenous variables.
+
+        Returns
+        -------
+        OBBject[Dict]
+            OBBject with the fit model returned
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            y_column=y_column,
+            x_columns=x_columns,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/panelre",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def unitroot(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        column: str,
+        regression: Literal["c", "ct", "ctt"] = "c",
+    ) -> OBBject[openbb_provider.abstract.data.Data]:
+        """Perform Augmented Dickey-Fuller unit root test.
+
+        Parameters
+        ----------
+        data: List[Data]
+            Input dataset.
+        column: str
+            Data columns to check unit root
+        regression: str
+            Regression type to use in the test.  Either "c" for constant only, "ct" for constant and trend, or "ctt" for
+            constant, trend, and trend-squared.
+        Returns
+        -------
+        OBBject[Data]
+            OBBject with the results being the score from the test.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            column=column,
+            regression=regression,
+        )
+
+        return self._command_runner.run(
+            "/econometrics/unitroot",
+            **inputs,
+        )

openbb_sdk/openbb/package/economy.py

@@ -15,9 +15,16 @@ class ROUTER_economy(Container):
     """/economy
     available_indices
     const
+    cot
+    cot_search
     cpi
+    european_index
+    european_index_constituents
     index
+    index_search
+    index_snapshots
     risk
+    sp500_multiples
     """
 
     def __repr__(self) -> str:
@@ -25,23 +32,25 @@ class ROUTER_economy(Container):
 
     @validate_arguments
     def available_indices(
-        self, provider: Union[Literal["fmp"], None] = None, **kwargs
+        self, provider: Union[Literal["cboe", "fmp", "yfinance"], None] = None, **kwargs
     ) -> OBBject[List]:
         """Lists of available indices from a provider.
 
         Parameters
         ----------
-        provider : Union[Literal['fmp'], None]
+        provider : Union[Literal['cboe', 'fmp', 'yfinance'], None]
             The provider to use for the query, by default None.
-            If None, the provider specified in defaults is selected or 'fmp' if there is
+            If None, the provider specified in defaults is selected or 'cboe' if there is
             no default.
+        europe : bool
+            Filter for European indices. False for US indices. (provider: cboe)
 
         Returns
         -------
         OBBject
             results : List[AvailableIndices]
                 Serializable results.
-            provider : Union[Literal['fmp'], None]
+            provider : Union[Literal['cboe', 'fmp', 'yfinance'], None]
                 Provider name.
             warnings : Optional[List[Warning_]]
                 List of warnings.
@@ -56,11 +65,34 @@ class ROUTER_economy(Container):
             Name of the index.
         currency : Optional[str]
             Currency the index is traded in.
+        isin : Optional[str]
+            ISIN code for the index. Valid only for European indices. (provider: cboe)
+        region : Optional[str]
+            Region for the index. Valid only for European indices (provider: cboe)
+        symbol : Optional[str]
+            Symbol for the index. (provider: cboe, yfinance)
+        description : Optional[str]
+            Description for the index. Valid only for US indices. (provider: cboe)
+        data_delay : Optional[int]
+            Data delay for the index. Valid only for US indices. (provider: cboe)
+        open_time : Optional[time]
+            Opening time for the index. Valid only for US indices. (provider: cboe)
+        close_time : Optional[time]
+            Closing time for the index. Valid only for US indices. (provider: cboe)
+        time_zone : Optional[str]
+            Time zone for the index. Valid only for US indices. (provider: cboe)
+        tick_days : Optional[str]
+            The trading days for the index. Valid only for US indices. (provider: cboe)
+        tick_frequency : Optional[str]
+            The frequency of the index ticks. Valid only for US indices. (provider: cboe)
+        tick_period : Optional[str]
+            The period of the index ticks. Valid only for US indices. (provider: cboe)
         stock_exchange : Optional[str]
             Stock exchange where the index is listed. (provider: fmp)
         exchange_short_name : Optional[str]
             Short name of the stock exchange where the index is listed. (provider: fmp)
-        """  # noqa: E501
+        code : Optional[str]
+            ID code for keying the index in the OpenBB Terminal. (provider: yfinance)"""  # noqa: E501
 
         inputs = filter_inputs(
             provider_choices={
@@ -146,6 +178,162 @@ class ROUTER_economy(Container):
             **inputs,
         )
 
+    @validate_arguments
+    def cot(
+        self, provider: Union[Literal["quandl"], None] = None, **kwargs
+    ) -> OBBject[List]:
+        """Lookup Commitment of Traders Reports by series ID.
+
+        Parameters
+        ----------
+        provider : Union[Literal['quandl'], None]
+            The provider to use for the query, by default None.
+            If None, the provider specified in defaults is selected or 'quandl' if there is
+            no default.
+        code : str
+
+                    CFTC series code.  Use search_cot() to find the code.
+                    Codes not listed in the curated list, but are published by on the Nasdaq Data Link website, are valid.
+                    Certain symbols, such as "ES=F", or exact names are also valid.
+                    Default report is: S&P 500 Consolidated (CME))
+                     (provider: quandl)
+        data_type : Union[Literal['F', 'FO', 'CITS'], None]
+
+                    The type of data to reuturn. Default is "FO".
+
+                    F = Futures only
+
+                    FO = Futures and Options
+
+                    CITS = Commodity Index Trader Supplemental. Only valid for commodities.
+                 (provider: quandl)
+        legacy_format : Union[bool, None]
+            Returns the legacy format of report. Default is False. (provider: quandl)
+        report_type : Union[Literal['ALL', 'CHG', 'OLD', 'OTR'], None]
+
+                    The type of report to return. Default is "ALL".
+
+                        ALL = All
+
+                        CHG = Change in Positions
+
+                        OLD = Old Crop Years
+
+                        OTR = Other Crop Years
+                 (provider: quandl)
+        measure : Union[Literal['CR', 'NT', 'OI', 'CHG'], None]
+
+                    The measure to return. Default is None.
+
+                    CR = Concentration Ratios
+
+                    NT = Number of Traders
+
+                    OI = Percent of Open Interest
+
+                    CHG = Change in Positions. Only valid when data_type is "CITS".
+                 (provider: quandl)
+        start_date : Union[datetime.date, None]
+            The start date of the time series. Defaults to all. (provider: quandl)
+        end_date : Union[datetime.date, None]
+            The end date of the time series. Defaults to the most recent data. (provider: quandl)
+        transform : Union[Literal['diff', 'rdiff', 'cumul', 'normalize'], None]
+            Transform the data as w/w difference, percent change, cumulative, or normalize. (provider: quandl)
+
+        Returns
+        -------
+        OBBject
+            results : List[COT]
+                Serializable results.
+            provider : Union[Literal['quandl'], None]
+                Provider name.
+            warnings : Optional[List[Warning_]]
+                List of warnings.
+            chart : Optional[Chart]
+                Chart object.
+            metadata: Optional[Metadata]
+                Metadata info about the command execution.
+
+        COT
+        ---"""  # noqa: E501
+
+        inputs = filter_inputs(
+            provider_choices={
+                "provider": provider,
+            },
+            standard_params={},
+            extra_params=kwargs,
+        )
+
+        return self._command_runner.run(
+            "/economy/cot",
+            **inputs,
+        )
+
+    @validate_arguments
+    def cot_search(
+        self,
+        query: typing_extensions.Annotated[
+            str, OpenBBCustomParameter(description="Search query.")
+        ] = "",
+        provider: Union[Literal["quandl"], None] = None,
+        **kwargs
+    ) -> OBBject[List]:
+        """Fuzzy search and list of curated Commitment of Traders Reports series information.
+
+        Parameters
+        ----------
+        query : str
+            Search query.
+        provider : Union[Literal['quandl'], None]
+            The provider to use for the query, by default None.
+            If None, the provider specified in defaults is selected or 'quandl' if there is
+            no default.
+
+        Returns
+        -------
+        OBBject
+            results : List[COTSearch]
+                Serializable results.
+            provider : Union[Literal['quandl'], None]
+                Provider name.
+            warnings : Optional[List[Warning_]]
+                List of warnings.
+            chart : Optional[Chart]
+                Chart object.
+            metadata: Optional[Metadata]
+                Metadata info about the command execution.
+
+        COTSearch
+        ---------
+        code : Optional[str]
+            CFTC Code of the report.
+        name : Optional[str]
+            Name of the underlying asset.
+        category : Optional[str]
+            Category of the underlying asset.
+        subcategory : Optional[str]
+            Subcategory of the underlying asset.
+        units : Optional[str]
+            The units for one contract.
+        symbol : Optional[str]
+            Trading symbol representing the underlying asset."""  # noqa: E501
+
+        inputs = filter_inputs(
+            provider_choices={
+                "provider": provider,
+            },
+            standard_params={
+                "query": query,
+            },
+            extra_params=kwargs,
+        )
+
+        return self._command_runner.run(
+            "/economy/cot_search",
+            **inputs,
+        )
+
     @validate_arguments
     def cpi(
         self,
@@ -296,6 +484,174 @@ class ROUTER_economy(Container):
             **inputs,
         )
 
+    @validate_arguments
+    def european_index(
+        self,
+        symbol: typing_extensions.Annotated[
+            Union[str, List[str]],
+            OpenBBCustomParameter(description="Symbol to get data for."),
+        ],
+        start_date: typing_extensions.Annotated[
+            Union[datetime.date, None, str],
+            OpenBBCustomParameter(
+                description="Start date of the data, in YYYY-MM-DD format."
+            ),
+        ] = None,
+        end_date: typing_extensions.Annotated[
+            Union[datetime.date, None, str],
+            OpenBBCustomParameter(
+                description="End date of the data, in YYYY-MM-DD format."
+            ),
+        ] = None,
+        provider: Union[Literal["cboe"], None] = None,
+        **kwargs
+    ) -> OBBject[List]:
+        """Get historical close values for select European indices.
+
+        Parameters
+        ----------
+        symbol : Union[str, List[str]]
+            Symbol to get data for.
+        start_date : Union[datetime.date, None, str]
+            Start date of the data, in YYYY-MM-DD format.
+        end_date : Union[datetime.date, None, str]
+            End date of the data, in YYYY-MM-DD format.
+        provider : Union[Literal['cboe'], None]
+            The provider to use for the query, by default None.
+            If None, the provider specified in defaults is selected or 'cboe' if there is
+            no default.
+        interval : Union[Literal['1d', '1m'], None]
+            Data granularity. (provider: cboe)
+
+        Returns
+        -------
+        OBBject
+            results : List[EuropeanIndexHistorical]
+                Serializable results.
+            provider : Union[Literal['cboe'], None]
+                Provider name.
+            warnings : Optional[List[Warning_]]
+                List of warnings.
+            chart : Optional[Chart]
+                Chart object.
+            metadata: Optional[Metadata]
+                Metadata info about the command execution.
+
+        EuropeanIndexHistorical
+        -----------------------
+        date : Optional[datetime]
+            The date of the data.
+        close : Optional[float]
+            The close price of the symbol.
+        open : Optional[float]
+            Opening price for the interval. Only valid when interval is 1m. (provider: cboe)
+        high : Optional[float]
+            High price for the interval. Only valid when interval is 1m. (provider: cboe)
+        low : Optional[float]
+            Low price for the interval. Only valid when interval is 1m. (provider: cboe)
+        utc_datetime : Optional[datetime]
+            UTC datetime. Only valid when interval is 1m. (provider: cboe)"""  # noqa: E501
+
+        inputs = filter_inputs(
+            provider_choices={
+                "provider": provider,
+            },
+            standard_params={
+                "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol,
+                "start_date": start_date,
+                "end_date": end_date,
+            },
+            extra_params=kwargs,
+        )
+
+        return self._command_runner.run(
+            "/economy/european_index",
+            **inputs,
+        )
+
+    @validate_arguments
+    def european_index_constituents(
+        self,
+        symbol: typing_extensions.Annotated[
+            Union[str, List[str]],
+            OpenBBCustomParameter(description="Symbol to get data for."),
+        ],
+        provider: Union[Literal["cboe"], None] = None,
+        **kwargs
+    ) -> OBBject[List]:
+        """Get  current levels for constituents of select European indices.
+
+        Parameters
+        ----------
+        symbol : Union[str, List[str]]
+            Symbol to get data for.
+        provider : Union[Literal['cboe'], None]
+            The provider to use for the query, by default None.
+            If None, the provider specified in defaults is selected or 'cboe' if there is
+            no default.
+
+        Returns
+        -------
+        OBBject
+            results : List[EuropeanIndexConstituents]
+                Serializable results.
+            provider : Union[Literal['cboe'], None]
+                Provider name.
+            warnings : Optional[List[Warning_]]
+                List of warnings.
+            chart : Optional[Chart]
+                Chart object.
+            metadata: Optional[Metadata]
+                Metadata info about the command execution.
+
+        EuropeanIndexConstituents
+        -------------------------
+        symbol : Optional[str]
+            Symbol of the constituent company in the index.
+        price : Optional[float]
+            Current price of the constituent company in the index.
+        open : Optional[float]
+            The open price of the symbol.
+        high : Optional[float]
+            The high price of the symbol.
+        low : Optional[float]
+            The low price of the symbol.
+        close : Optional[float]
+            The close price of the symbol.
+        volume : Optional[float]
+            The volume of the symbol.
+        prev_close : Optional[float]
+            Previous closing  price. (provider: cboe)
+        change : Optional[float]
+            Change in price. (provider: cboe)
+        change_percent : Optional[float]
+            Change in price as a percentage. (provider: cboe)
+        tick : Optional[str]
+            Whether the last sale was an up or down tick. (provider: cboe)
+        last_trade_timestamp : Optional[datetime]
+            Last trade timestamp for the symbol. (provider: cboe)
+        exchange_id : Optional[int]
+            The Exchange ID number. (provider: cboe)
+        seqno : Optional[int]
+            Sequence number of the last trade on the tape. (provider: cboe)
+        asset_type : Optional[str]
+            Type of asset. (provider: cboe)"""  # noqa: E501
+
+        inputs = filter_inputs(
+            provider_choices={
+                "provider": provider,
+            },
+            standard_params={
+                "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol,
+            },
+            extra_params=kwargs,
+        )
+
+        return self._command_runner.run(
+            "/economy/european_index_constituents",
+            **inputs,
+        )
+
     @validate_arguments
     def index(
         self,
@@ -315,7 +671,7 @@ class ROUTER_economy(Container):
                 description="End date of the data, in YYYY-MM-DD format."
             ),
         ] = None,
-        provider: Union[Literal["fmp", "polygon"], None] = None,
+        provider: Union[Literal["cboe", "fmp", "polygon", "yfinance"], None] = None,
         **kwargs
     ) -> OBBject[List]:
         """Get historical  levels for an index.
@@ -328,14 +684,14 @@ class ROUTER_economy(Container):
             Start date of the data, in YYYY-MM-DD format.
         end_date : Union[datetime.date, None, str]
             End date of the data, in YYYY-MM-DD format.
-        provider : Union[Literal['fmp', 'polygon'], None]
+        provider : Union[Literal['cboe', 'fmp', 'polygon', 'yfinance'], None]
             The provider to use for the query, by default None.
-            If None, the provider specified in defaults is selected or 'fmp' if there is
+            If None, the provider specified in defaults is selected or 'cboe' if there is
             no default.
+        interval : Union[Literal['1d', '1m'], None, Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'], Literal['1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo']]
+            Use interval, 1m, for intraday prices during the most recent trading period. (provider: cboe); Data granularity. (provider: fmp); Data granularity. (provider: yfinance)
         timeseries : Union[pydantic.types.NonNegativeInt, None]
             Number of days to look back. (provider: fmp)
-        interval : Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day']
-            Data granularity. (provider: fmp)
         timespan : Literal['minute', 'hour', 'day', 'week', 'month', 'quarter', 'year']
             Timespan of the data. (provider: polygon)
         sort : Literal['asc', 'desc']
@@ -346,13 +702,19 @@ class ROUTER_economy(Container):
             Whether the data is adjusted. (provider: polygon)
         multiplier : PositiveInt
             Multiplier of the timespan. (provider: polygon)
+        period : Literal['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']
+            Period of the data to return. (provider: yfinance)
+        prepost : bool
+            Include Pre and Post market data. (provider: yfinance)
+        rounding : bool
+            Round prices to two decimals? (provider: yfinance)
 
         Returns
         -------
         OBBject
             results : List[MajorIndicesHistorical]
                 Serializable results.
-            provider : Union[Literal['fmp', 'polygon'], None]
+            provider : Union[Literal['cboe', 'fmp', 'polygon', 'yfinance'], None]
                 Provider name.
             warnings : Optional[List[Warning_]]
                 List of warnings.
@@ -375,6 +737,12 @@ class ROUTER_economy(Container):
             The close price of the symbol.
         volume : Optional[NonNegativeInt]
             The volume of the symbol.
+        calls_volume : Optional[float]
+            Number of calls traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe)
+        puts_volume : Optional[float]
+            Number of puts traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe)
+        total_options_volume : Optional[float]
+            Total number of options traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe)
         adj_close : Optional[float]
             Adjusted Close Price of the symbol. (provider: fmp)
         unadjusted_volume : Optional[float]
@@ -408,6 +776,174 @@ class ROUTER_economy(Container):
             **inputs,
         )
 
+    @validate_arguments
+    def index_search(
+        self,
+        query: typing_extensions.Annotated[
+            str, OpenBBCustomParameter(description="Search query.")
+        ] = "",
+        symbol: typing_extensions.Annotated[
+            Union[bool, List[str]],
+            OpenBBCustomParameter(description="Whether to search by ticker symbol."),
+        ] = False,
+        provider: Union[Literal["cboe"], None] = None,
+        **kwargs
+    ) -> OBBject[List]:
+        """Search for indices.
+
+        Parameters
+        ----------
+        query : str
+            Search query.
+        symbol : Union[bool, List[str]]
+            Whether to search by ticker symbol.
+        provider : Union[Literal['cboe'], None]
+            The provider to use for the query, by default None.
+            If None, the provider specified in defaults is selected or 'cboe' if there is
+            no default.
+        europe : bool
+            Filter for European indices. False for US indices. (provider: cboe)
+
+        Returns
+        -------
+        OBBject
+            results : List[IndexSearch]
+                Serializable results.
+            provider : Union[Literal['cboe'], None]
+                Provider name.
+            warnings : Optional[List[Warning_]]
+                List of warnings.
+            chart : Optional[Chart]
+                Chart object.
+            metadata: Optional[Metadata]
+                Metadata info about the command execution.
+
+        IndexSearch
+        -----------
+        symbol : Optional[str]
+            Symbol of the index.
+        name : Optional[str]
+            Name of the index.
+        isin : Optional[str]
+            ISIN code for the index. Valid only for European indices. (provider: cboe)
+        region : Optional[str]
+            Region for the index. Valid only for European indices (provider: cboe)
+        description : Optional[str]
+            Description for the index. (provider: cboe)
+        data_delay : Optional[int]
+            Data delay for the index. Valid only for US indices. (provider: cboe)
+        currency : Optional[str]
+            Currency for the index. (provider: cboe)
+        time_zone : Optional[str]
+            Time zone for the index. Valid only for US indices. (provider: cboe)
+        open_time : Optional[time]
+            Opening time for the index. Valid only for US indices. (provider: cboe)
+        close_time : Optional[time]
+            Closing time for the index. Valid only for US indices. (provider: cboe)
+        tick_days : Optional[str]
+            The trading days for the index. Valid only for US indices. (provider: cboe)
+        tick_frequency : Optional[str]
+            Tick frequency for the index. Valid only for US indices. (provider: cboe)
+        tick_period : Optional[str]
+            Tick period for the index. Valid only for US indices. (provider: cboe)"""  # noqa: E501
+
+        inputs = filter_inputs(
+            provider_choices={
+                "provider": provider,
+            },
+            standard_params={
+                "query": query,
+                "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol,
+            },
+            extra_params=kwargs,
+        )
+
+        return self._command_runner.run(
+            "/economy/index_search",
+            **inputs,
+        )
+
+    @validate_arguments
+    def index_snapshots(
+        self,
+        region: typing_extensions.Annotated[
+            Union[Literal["US", "EU"], None],
+            OpenBBCustomParameter(
+                description="The region to return. Currently supports US and EU."
+            ),
+        ] = "US",
+        provider: Union[Literal["cboe"], None] = None,
+        **kwargs
+    ) -> OBBject[List]:
+        """Get current  levels for all indices from a provider.
+
+        Parameters
+        ----------
+        region : Union[Literal['US', 'EU'], None]
+            The region to return. Currently supports US and EU.
+        provider : Union[Literal['cboe'], None]
+            The provider to use for the query, by default None.
+            If None, the provider specified in defaults is selected or 'cboe' if there is
+            no default.
+
+        Returns
+        -------
+        OBBject
+            results : List[IndexSnapshots]
+                Serializable results.
+            provider : Union[Literal['cboe'], None]
+                Provider name.
+            warnings : Optional[List[Warning_]]
+                List of warnings.
+            chart : Optional[Chart]
+                Chart object.
+            metadata: Optional[Metadata]
+                Metadata info about the command execution.
+
+        IndexSnapshots
+        --------------
+        symbol : Optional[str]
+            Symbol of the index.
+        name : Optional[str]
+            Name of the index.
+        currency : Optional[str]
+            Currency of the index.
+        price : Optional[float]
+            Current price of the index.
+        open : Optional[float]
+            Opening price of the index.
+        high : Optional[float]
+            Highest price of the index.
+        low : Optional[float]
+            Lowest price of the index.
+        close : Optional[float]
+            Closing price of the index.
+        prev_close : Optional[float]
+            Previous closing price of the index.
+        change : Optional[float]
+            Change of the index.
+        change_percent : Optional[float]
+            Change percent of the index.
+        isin : Optional[str]
+            ISIN code for the index. Valid only for European indices. (provider: cboe)
+        last_trade_timestamp : Optional[datetime]
+            Last trade timestamp for the index. (provider: cboe)"""  # noqa: E501
+
+        inputs = filter_inputs(
+            provider_choices={
+                "provider": provider,
+            },
+            standard_params={
+                "region": region,
+            },
+            extra_params=kwargs,
+        )
+
+        return self._command_runner.run(
+            "/economy/index_snapshots",
+            **inputs,
+        )
+
     @validate_arguments
     def risk(
         self, provider: Union[Literal["fmp"], None] = None, **kwargs
@@ -458,3 +994,133 @@ class ROUTER_economy(Container):
             "/economy/risk",
             **inputs,
         )
+
+    @validate_arguments
+    def sp500_multiples(
+        self,
+        series_name: typing_extensions.Annotated[
+            Literal[
+                "Shiller PE Ratio by Month",
+                "Shiller PE Ratio by Year",
+                "PE Ratio by Year",
+                "PE Ratio by Month",
+                "Dividend by Year",
+                "Dividend by Month",
+                "Dividend Growth by Quarter",
+                "Dividend Growth by Year",
+                "Dividend Yield by Year",
+                "Dividend Yield by Month",
+                "Earnings by Year",
+                "Earnings by Month",
+                "Earnings Growth by Year",
+                "Earnings Growth by Quarter",
+                "Real Earnings Growth by Year",
+                "Real Earnings Growth by Quarter",
+                "Earnings Yield by Year",
+                "Earnings Yield by Month",
+                "Real Price by Year",
+                "Real Price by Month",
+                "Inflation Adjusted Price by Year",
+                "Inflation Adjusted Price by Month",
+                "Sales by Year",
+                "Sales by Quarter",
+                "Sales Growth by Year",
+                "Sales Growth by Quarter",
+                "Real Sales by Year",
+                "Real Sales by Quarter",
+                "Real Sales Growth by Year",
+                "Real Sales Growth by Quarter",
+                "Price to Sales Ratio by Year",
+                "Price to Sales Ratio by Quarter",
+                "Price to Book Value Ratio by Year",
+                "Price to Book Value Ratio by Quarter",
+                "Book Value per Share by Year",
+                "Book Value per Share by Quarter",
+            ],
+            OpenBBCustomParameter(
+                description="The name of the series. Defaults to 'PE Ratio by Month'."
+            ),
+        ] = "PE Ratio by Month",
+        start_date: typing_extensions.Annotated[
+            Union[str, None],
+            OpenBBCustomParameter(
+                description="The start date of the time series. Format: YYYY-MM-DD"
+            ),
+        ] = "",
+        end_date: typing_extensions.Annotated[
+            Union[str, None],
+            OpenBBCustomParameter(
+                description="The end date of the time series. Format: YYYY-MM-DD"
+            ),
+        ] = "",
+        collapse: typing_extensions.Annotated[
+            Union[Literal["daily", "weekly", "monthly", "quarterly", "annual"], None],
+            OpenBBCustomParameter(
+                description="Collapse the frequency of the time series."
+            ),
+        ] = "monthly",
+        transform: typing_extensions.Annotated[
+            Union[Literal["diff", "rdiff", "cumul", "normalize"], None],
+            OpenBBCustomParameter(description="The transformation of the time series."),
+        ] = None,
+        provider: Union[Literal["quandl"], None] = None,
+        **kwargs
+    ) -> OBBject[List]:
+        """Historical S&P 500 multiples and Shiller PE ratios.
+
+        Parameters
+        ----------
+        series_name : Literal['Shiller PE Ratio by Month', 'Shiller PE Ratio by Year', 'PE Rat...
+            The name of the series. Defaults to 'PE Ratio by Month'.
+        start_date : Union[str, None]
+            The start date of the time series. Format: YYYY-MM-DD
+        end_date : Union[str, None]
+            The end date of the time series. Format: YYYY-MM-DD
+        collapse : Union[Literal['daily', 'weekly', 'monthly', 'quarterly', 'annual'...
+            Collapse the frequency of the time series.
+        transform : Union[Literal['diff', 'rdiff', 'cumul', 'normalize'], None]
+            The transformation of the time series.
+        provider : Union[Literal['quandl'], None]
+            The provider to use for the query, by default None.
+            If None, the provider specified in defaults is selected or 'quandl' if there is
+            no default.
+
+        Returns
+        -------
+        OBBject
+            results : List[SP500Multiples]
+                Serializable results.
+            provider : Union[Literal['quandl'], None]
+                Provider name.
+            warnings : Optional[List[Warning_]]
+                List of warnings.
+            chart : Optional[Chart]
+                Chart object.
+            metadata: Optional[Metadata]
+                Metadata info about the command execution.
+
+        SP500Multiples
+        --------------
+        date : Optional[str]
+            The date data for the time series.
+        value : Optional[float]
+            The data value for the time series."""  # noqa: E501
+
+        inputs = filter_inputs(
+            provider_choices={
+                "provider": provider,
+            },
+            standard_params={
+                "series_name": series_name,
+                "start_date": start_date,
+                "end_date": end_date,
+                "collapse": collapse,
+                "transform": transform,
+            },
+            extra_params=kwargs,
+        )
+
+        return self._command_runner.run(
+            "/economy/sp500_multiples",
+            **inputs,
+        )

openbb_sdk/openbb/package/extension_map.json

@@ -1,17 +1,26 @@
 {
     "openbb_core_extension": [
         "crypto@0.1.0a2",
+        "econometrics@0.1.0a2",
         "economy@0.1.0a2",
         "fixedincome@0.1.0a2",
         "forex@0.1.0a2",
+        "futures@0.1.0a2",
         "news@0.1.0a2",
-        "stocks@0.1.0a2"
+        "openbb_charting@0.1.0a2",
+        "qa@0.1.0a2",
+        "stocks@0.1.0a2",
+        "ta@0.1.0a2"
     ],
     "openbb_provider_extension": [
+        "alpha_vantage@0.1.0a2",
         "benzinga@0.1.0a2",
+        "cboe@0.1.0a2",
         "fmp@0.1.0a2",
         "fred@0.1.0a2",
         "intrinio@0.1.0a2",
-        "polygon@0.1.0a2"
+        "polygon@0.1.0a2",
+        "quandl@0.1.0a2",
+        "yfinance@0.1.0a2"
     ]
 }

openbb_sdk/openbb/package/forex.py

@@ -39,7 +39,7 @@ class ROUTER_forex(Container):
                 description="End date of the data, in YYYY-MM-DD format."
             ),
         ] = None,
-        provider: Union[Literal["fmp", "polygon"], None] = None,
+        provider: Union[Literal["fmp", "polygon", "yfinance"], None] = None,
         **kwargs
     ) -> OBBject[List]:
         """Forex Intraday Price.
@@ -52,12 +52,12 @@ class ROUTER_forex(Container):
             Start date of the data, in YYYY-MM-DD format.
         end_date : Union[datetime.date, None, str]
             End date of the data, in YYYY-MM-DD format.
-        provider : Union[Literal['fmp', 'polygon'], None]
+        provider : Union[Literal['fmp', 'polygon', 'yfinance'], None]
             The provider to use for the query, by default None.
             If None, the provider specified in defaults is selected or 'fmp' if there is
             no default.
-        interval : Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day']
-            Data granularity. (provider: fmp)
+        interval : Union[Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'], Literal['1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo']]
+            Data granularity. (provider: fmp, yfinance)
         multiplier : PositiveInt
             Multiplier of the timespan. (provider: polygon)
         timespan : Literal['minute', 'hour', 'day', 'week', 'month', 'quarter', 'year']
@@ -68,13 +68,15 @@ class ROUTER_forex(Container):
             The number of data entries to return. (provider: polygon)
         adjusted : bool
             Whether the data is adjusted. (provider: polygon)
+        period : Literal['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']
+            Period of the data to return. (provider: yfinance)
 
         Returns
         -------
         OBBject
             results : List[ForexHistorical]
                 Serializable results.
-            provider : Union[Literal['fmp', 'polygon'], None]
+            provider : Union[Literal['fmp', 'polygon', 'yfinance'], None]
                 Provider name.
             warnings : Optional[List[Warning_]]
                 List of warnings.

openbb_sdk/openbb/package/futures.py

@@ -0,0 +1,187 @@
+### THIS FILE IS AUTO-GENERATED. DO NOT EDIT. ###
+
+import datetime
+from typing import List, Literal, Union
+
+import typing_extensions
+from openbb_core.app.model.custom_parameter import OpenBBCustomParameter
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.app.static.container import Container
+from openbb_core.app.static.filters import filter_inputs
+from pydantic import validate_arguments
+
+
+class ROUTER_futures(Container):
+    """/futures
+    curve
+    load
+    """
+
+    def __repr__(self) -> str:
+        return self.__doc__ or ""
+
+    @validate_arguments
+    def curve(
+        self,
+        symbol: typing_extensions.Annotated[
+            Union[str, List[str]],
+            OpenBBCustomParameter(description="Symbol to get data for."),
+        ],
+        date: typing_extensions.Annotated[
+            Union[datetime.date, None],
+            OpenBBCustomParameter(description="Historical date to search curve for."),
+        ] = None,
+        provider: Union[Literal["cboe", "yfinance"], None] = None,
+        **kwargs
+    ) -> OBBject[List]:
+        """Futures Historical Price.
+
+        Parameters
+        ----------
+        symbol : Union[str, List[str]]
+            Symbol to get data for.
+        date : Union[datetime.date, None]
+            Historical date to search curve for.
+        provider : Union[Literal['cboe', 'yfinance'], None]
+            The provider to use for the query, by default None.
+            If None, the provider specified in defaults is selected or 'cboe' if there is
+            no default.
+
+        Returns
+        -------
+        OBBject
+            results : List[FuturesCurve]
+                Serializable results.
+            provider : Union[Literal['cboe', 'yfinance'], None]
+                Provider name.
+            warnings : Optional[List[Warning_]]
+                List of warnings.
+            chart : Optional[Chart]
+                Chart object.
+            metadata: Optional[Metadata]
+                Metadata info about the command execution.
+
+        FuturesCurve
+        ------------
+        expiration : Optional[str]
+            Futures expiration month.
+        price : Optional[float]
+            The close price of the symbol.
+        symbol : Optional[str]
+            The trading symbol for the tenor of future. (provider: cboe)"""  # noqa: E501
+
+        inputs = filter_inputs(
+            provider_choices={
+                "provider": provider,
+            },
+            standard_params={
+                "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol,
+                "date": date,
+            },
+            extra_params=kwargs,
+        )
+
+        return self._command_runner.run(
+            "/futures/curve",
+            **inputs,
+        )
+
+    @validate_arguments
+    def load(
+        self,
+        symbol: typing_extensions.Annotated[
+            Union[str, List[str]],
+            OpenBBCustomParameter(description="Symbol to get data for."),
+        ],
+        start_date: typing_extensions.Annotated[
+            Union[datetime.date, None, str],
+            OpenBBCustomParameter(
+                description="Start date of the data, in YYYY-MM-DD format."
+            ),
+        ] = None,
+        end_date: typing_extensions.Annotated[
+            Union[datetime.date, None, str],
+            OpenBBCustomParameter(
+                description="End date of the data, in YYYY-MM-DD format."
+            ),
+        ] = None,
+        expiration: typing_extensions.Annotated[
+            Union[str, None],
+            OpenBBCustomParameter(description="Future expiry date with format YYYY-MM"),
+        ] = None,
+        provider: Union[Literal["yfinance"], None] = None,
+        **kwargs
+    ) -> OBBject[List]:
+        """Futures Historical Price.
+
+        Parameters
+        ----------
+        symbol : Union[str, List[str]]
+            Symbol to get data for.
+        start_date : Union[datetime.date, None, str]
+            Start date of the data, in YYYY-MM-DD format.
+        end_date : Union[datetime.date, None, str]
+            End date of the data, in YYYY-MM-DD format.
+        expiration : Union[str, None]
+            Future expiry date with format YYYY-MM
+        provider : Union[Literal['yfinance'], None]
+            The provider to use for the query, by default None.
+            If None, the provider specified in defaults is selected or 'yfinance' if there is
+            no default.
+        interval : Union[Literal['1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo'], None]
+            Data granularity. (provider: yfinance)
+        period : Union[Literal['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max'], None]
+            Period of the data to return. (provider: yfinance)
+        prepost : bool
+            Include Pre and Post market data. (provider: yfinance)
+        adjust : bool
+            Adjust all the data automatically. (provider: yfinance)
+        back_adjust : bool
+            Back-adjusted data to mimic true historical prices. (provider: yfinance)
+
+        Returns
+        -------
+        OBBject
+            results : List[FuturesHistorical]
+                Serializable results.
+            provider : Union[Literal['yfinance'], None]
+                Provider name.
+            warnings : Optional[List[Warning_]]
+                List of warnings.
+            chart : Optional[Chart]
+                Chart object.
+            metadata: Optional[Metadata]
+                Metadata info about the command execution.
+
+        FuturesHistorical
+        -----------------
+        date : Optional[datetime]
+            The date of the data.
+        open : Optional[float]
+            The open price of the symbol.
+        high : Optional[float]
+            The high price of the symbol.
+        low : Optional[float]
+            The low price of the symbol.
+        close : Optional[float]
+            The close price of the symbol.
+        volume : Optional[float]
+            The volume of the symbol."""  # noqa: E501
+
+        inputs = filter_inputs(
+            provider_choices={
+                "provider": provider,
+            },
+            standard_params={
+                "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol,
+                "start_date": start_date,
+                "end_date": end_date,
+                "expiration": expiration,
+            },
+            extra_params=kwargs,
+        )
+
+        return self._command_runner.run(
+            "/futures/load",
+            **inputs,
+        )

openbb_sdk/openbb/package/module_map.json

@@ -2,12 +2,34 @@
     "__extensions__": "",
     "crypto": "/crypto",
     "crypto_load": "/crypto/load",
+    "econometrics": "/econometrics",
+    "econometrics_bgot": "/econometrics/bgot",
+    "econometrics_coint": "/econometrics/coint",
+    "econometrics_corr": "/econometrics/corr",
+    "econometrics_dwat": "/econometrics/dwat",
+    "econometrics_granger": "/econometrics/granger",
+    "econometrics_ols": "/econometrics/ols",
+    "econometrics_ols_summary": "/econometrics/ols_summary",
+    "econometrics_panelbols": "/econometrics/panelbols",
+    "econometrics_panelfd": "/econometrics/panelfd",
+    "econometrics_panelfmac": "/econometrics/panelfmac",
+    "econometrics_panelols": "/econometrics/panelols",
+    "econometrics_panelpols": "/econometrics/panelpols",
+    "econometrics_panelre": "/econometrics/panelre",
+    "econometrics_unitroot": "/econometrics/unitroot",
     "economy": "/economy",
     "economy_available_indices": "/economy/available_indices",
     "economy_const": "/economy/const",
+    "economy_cot": "/economy/cot",
+    "economy_cot_search": "/economy/cot_search",
     "economy_cpi": "/economy/cpi",
+    "economy_european_index": "/economy/european_index",
+    "economy_european_index_constituents": "/economy/european_index_constituents",
     "economy_index": "/economy/index",
+    "economy_index_search": "/economy/index_search",
+    "economy_index_snapshots": "/economy/index_snapshots",
     "economy_risk": "/economy/risk",
+    "economy_sp500_multiples": "/economy/sp500_multiples",
     "fixedincome": "/fixedincome",
     "fixedincome_ameribor": "/fixedincome/ameribor",
     "fixedincome_estr": "/fixedincome/estr",
@@ -21,8 +43,22 @@
     "forex": "/forex",
     "forex_load": "/forex/load",
     "forex_pairs": "/forex/pairs",
+    "futures": "/futures",
+    "futures_curve": "/futures/curve",
+    "futures_load": "/futures/load",
     "news": "/news",
     "news_globalnews": "/news/globalnews",
+    "qa": "/qa",
+    "qa_capm": "/qa/capm",
+    "qa_kurtosis": "/qa/kurtosis",
+    "qa_normality": "/qa/normality",
+    "qa_om": "/qa/om",
+    "qa_quantile": "/qa/quantile",
+    "qa_sh": "/qa/sh",
+    "qa_skew": "/qa/skew",
+    "qa_so": "/qa/so",
+    "qa_summary": "/qa/summary",
+    "qa_unitroot": "/qa/unitroot",
     "stocks": "/stocks",
     "stocks_ca": "/stocks/ca",
     "stocks_ca_peers": "/stocks/ca/peers",
@@ -55,10 +91,39 @@
     "stocks_fa_shrs": "/stocks/fa/shrs",
     "stocks_fa_split": "/stocks/fa/split",
     "stocks_fa_transcript": "/stocks/fa/transcript",
+    "stocks_info": "/stocks/info",
     "stocks_load": "/stocks/load",
     "stocks_multiples": "/stocks/multiples",
     "stocks_news": "/stocks/news",
     "stocks_options": "/stocks/options",
     "stocks_options_chains": "/stocks/options/chains",
-    "stocks_quote": "/stocks/quote"
+    "stocks_quote": "/stocks/quote",
+    "stocks_search": "/stocks/search",
+    "ta": "/ta",
+    "ta_ad": "/ta/ad",
+    "ta_adosc": "/ta/adosc",
+    "ta_adx": "/ta/adx",
+    "ta_aroon": "/ta/aroon",
+    "ta_atr": "/ta/atr",
+    "ta_bbands": "/ta/bbands",
+    "ta_cci": "/ta/cci",
+    "ta_cg": "/ta/cg",
+    "ta_clenow": "/ta/clenow",
+    "ta_cones": "/ta/cones",
+    "ta_demark": "/ta/demark",
+    "ta_donchian": "/ta/donchian",
+    "ta_ema": "/ta/ema",
+    "ta_fib": "/ta/fib",
+    "ta_fisher": "/ta/fisher",
+    "ta_hma": "/ta/hma",
+    "ta_ichimoku": "/ta/ichimoku",
+    "ta_kc": "/ta/kc",
+    "ta_macd": "/ta/macd",
+    "ta_obv": "/ta/obv",
+    "ta_rsi": "/ta/rsi",
+    "ta_sma": "/ta/sma",
+    "ta_stoch": "/ta/stoch",
+    "ta_vwap": "/ta/vwap",
+    "ta_wma": "/ta/wma",
+    "ta_zlma": "/ta/zlma"
 }

openbb_sdk/openbb/package/qa.py

@@ -0,0 +1,375 @@
+### THIS FILE IS AUTO-GENERATED. DO NOT EDIT. ###
+
+from typing import List, Literal, Union
+
+import openbb_provider
+import openbb_qa.qa_models
+import pandas
+import pydantic
+import pydantic.types
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.app.static.container import Container
+from openbb_core.app.static.filters import filter_inputs
+from pydantic import validate_arguments
+
+
+class ROUTER_qa(Container):
+    """/qa
+    capm
+    kurtosis
+    normality
+    om
+    quantile
+    sh
+    skew
+    so
+    summary
+    unitroot
+    """
+
+    def __repr__(self) -> str:
+        return self.__doc__ or ""
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def capm(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        target: str,
+    ) -> OBBject[openbb_qa.qa_models.CAPMModel]:
+        """Capital Asset Pricing Model."""  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            target=target,
+        )
+
+        return self._command_runner.run(
+            "/qa/capm",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def kurtosis(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        target: str,
+        window: pydantic.types.PositiveInt,
+    ) -> OBBject[List]:
+        """Kurtosis.
+
+        Parameters
+        ----------
+        data : List[Data]
+            Time series data.
+        target : str
+            Target column name.
+        window : PositiveInt
+            Window size.
+
+        Returns
+        -------
+        OBBject[List[Data]]
+            Kurtosis.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            target=target,
+            window=window,
+        )
+
+        return self._command_runner.run(
+            "/qa/kurtosis",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def normality(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        target: str,
+    ) -> OBBject[openbb_qa.qa_models.NormalityModel]:
+        """
+        Normality Statistics.
+
+        - **Kurtosis**: whether the kurtosis of a sample differs from the normal distribution.
+        - **Skewness**: whether the skewness of a sample differs from the normal distribution.
+        - **Jarque-Bera**: whether the sample data has the skewness and kurtosis matching a normal distribution.
+        - **Shapiro-Wilk**: whether a random sample comes from a normal distribution.
+        - **Kolmogorov-Smirnov**: whether two underlying one-dimensional probability distributions differ.
+
+        Parameters
+        ----------
+        data : List[Data]
+            Time series data.
+        target : str
+            Target column name.
+
+        Returns
+        -------
+        OBBject[NormalityModel]
+            Normality tests summary. See qa_models.NormalityModel for details.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            target=target,
+        )
+
+        return self._command_runner.run(
+            "/qa/normality",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def om(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        target: str,
+        threshold_start: float = 0.0,
+        threshold_end: float = 1.5,
+    ) -> OBBject[List]:
+        """Omega Ratio.
+
+        Parameters
+        ----------
+        data : List[Data]
+            Time series data.
+        target : str
+            Target column name.
+        threshold_start : float, optional
+            Start threshold, by default 0.0
+        threshold_end : float, optional
+            End threshold, by default 1.5
+
+        Returns
+        -------
+        OBBject[List[OmegaModel]]
+            Omega ratios.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            target=target,
+            threshold_start=threshold_start,
+            threshold_end=threshold_end,
+        )
+
+        return self._command_runner.run(
+            "/qa/om",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def quantile(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        target: str,
+        window: pydantic.types.PositiveInt,
+        quantile_pct: pydantic.types.NonNegativeFloat = 0.5,
+    ) -> OBBject[List]:
+        """Quantile."""  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            target=target,
+            window=window,
+            quantile_pct=quantile_pct,
+        )
+
+        return self._command_runner.run(
+            "/qa/quantile",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def sh(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        target: str,
+        rfr: float = 0.0,
+        window: pydantic.types.PositiveInt = 252,
+    ) -> OBBject[List]:
+        """Sharpe Ratio.
+
+        Parameters
+        ----------
+        data : List[Data]
+            Time series data.
+        target : str
+            Target column name.
+        rfr : float, optional
+            Risk-free rate, by default 0.0
+        window : PositiveInt, optional
+            Window size, by default 252
+
+        Returns
+        -------
+        OBBject[List[Data]]
+            Sharpe ratio.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            target=target,
+            rfr=rfr,
+            window=window,
+        )
+
+        return self._command_runner.run(
+            "/qa/sh",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def skew(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        target: str,
+        window: pydantic.types.PositiveInt,
+    ) -> OBBject[List]:
+        """Skewness.
+
+        Parameters
+        ----------
+        data : List[Data]
+            Time series data.
+        target : str
+            Target column name.
+        window : PositiveInt
+            Window size.
+
+        Returns
+        -------
+        OBBject[List[Data]]
+            Skewness.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            target=target,
+            window=window,
+        )
+
+        return self._command_runner.run(
+            "/qa/skew",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def so(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        target: str,
+        target_return: float = 0.0,
+        window: pydantic.types.PositiveInt = 252,
+        adjusted: bool = False,
+    ) -> OBBject[List]:
+        """Sortino Ratio.
+
+        For method & terminology see: http://www.redrockcapital.com/Sortino__A__Sharper__Ratio_Red_Rock_Capital.pdf
+
+        Parameters
+        ----------
+        data : List[Data]
+            Time series data.
+        target : str
+            Target column name.
+        target_return : float, optional
+            Target return, by default 0.0
+        window : PositiveInt, optional
+            Window size, by default 252
+        adjusted : bool, optional
+            Adjust sortino ratio to compare it to sharpe ratio, by default False
+
+        Returns
+        -------
+        OBBject[List[Data]]
+            Sortino ratio.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            target=target,
+            target_return=target_return,
+            window=window,
+            adjusted=adjusted,
+        )
+
+        return self._command_runner.run(
+            "/qa/so",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def summary(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        target: str,
+    ) -> OBBject[openbb_qa.qa_models.SummaryModel]:
+        """Summary.
+
+        Parameters
+        ----------
+        data : List[Data]
+            Time series data.
+        target : str
+            Target column name.
+
+        Returns
+        -------
+        OBBject[SummaryModel]
+            Summary table.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            target=target,
+        )
+
+        return self._command_runner.run(
+            "/qa/summary",
+            **inputs,
+        )
+
+    @validate_arguments(config=dict(arbitrary_types_allowed=True))
+    def unitroot(
+        self,
+        data: Union[List[openbb_provider.abstract.data.Data], pandas.DataFrame],
+        target: str,
+        fuller_reg: Literal["c", "ct", "ctt", "nc", "c"] = "c",
+        kpss_reg: Literal["c", "ct"] = "c",
+    ) -> OBBject[openbb_qa.qa_models.UnitRootModel]:
+        """Unit Root Test.
+
+        Augmented Dickey-Fuller test for unit root.
+        Kwiatkowski-Phillips-Schmidt-Shin test for unit root.
+
+        Parameters
+        ----------
+        data : List[Data]
+            Time series data.
+        target : str
+            Target column name.
+        fuller_reg : Literal["c", "ct", "ctt", "nc", "c"]
+            Regression type for ADF test.
+        kpss_reg : Literal["c", "ct"]
+            Regression type for KPSS test.
+
+        Returns
+        -------
+        OBBject[UnitRootModel]
+            Unit root tests summary.
+        """  # noqa: E501
+
+        inputs = filter_inputs(
+            data=data,
+            target=target,
+            fuller_reg=fuller_reg,
+            kpss_reg=kpss_reg,
+        )
+
+        return self._command_runner.run(
+            "/qa/unitroot",
+            **inputs,
+        )

openbb_sdk/openbb/package/stocks.py

@@ -17,11 +17,13 @@ class ROUTER_stocks(Container):
     """/stocks
     /ca
     /fa
+    info
     load
     multiples
     news
     /options
     quote
+    search
     """
 
     def __repr__(self) -> str:
@@ -39,6 +41,121 @@ class ROUTER_stocks(Container):
 
         return stocks_fa.ROUTER_stocks_fa(command_runner=self._command_runner)
 
+    @validate_arguments
+    def info(
+        self,
+        symbol: typing_extensions.Annotated[
+            Union[str, List[str]],
+            OpenBBCustomParameter(description="Symbol to get data for."),
+        ],
+        provider: Union[Literal["cboe"], None] = None,
+        **kwargs
+    ) -> OBBject[List]:
+        """Get general price and performance metrics of a stock.
+
+        Parameters
+        ----------
+        symbol : Union[str, List[str]]
+            Symbol to get data for.
+        provider : Union[Literal['cboe'], None]
+            The provider to use for the query, by default None.
+            If None, the provider specified in defaults is selected or 'cboe' if there is
+            no default.
+
+        Returns
+        -------
+        OBBject
+            results : List[StockInfo]
+                Serializable results.
+            provider : Union[Literal['cboe'], None]
+                Provider name.
+            warnings : Optional[List[Warning_]]
+                List of warnings.
+            chart : Optional[Chart]
+                Chart object.
+            metadata: Optional[Metadata]
+                Metadata info about the command execution.
+
+        StockInfo
+        ---------
+        symbol : Optional[str]
+            Symbol to get data for.
+        name : Optional[str]
+            Name associated with the ticker symbol.
+        price : Optional[float]
+            Last transaction price.
+        open : Optional[float]
+            Opening price of the stock.
+        high : Optional[float]
+            High price of the current trading day.
+        low : Optional[float]
+            Low price of the current trading day.
+        close : Optional[float]
+            Closing price of the most recent trading day.
+        change : Optional[float]
+            Change in price over the current trading period.
+        change_percent : Optional[float]
+            Percent change in price over the current trading period.
+        prev_close : Optional[float]
+            Previous closing price.
+        type : Optional[str]
+            Type of asset. (provider: cboe)
+        exchange_id : Optional[int]
+            The Exchange ID number. (provider: cboe)
+        tick : Optional[str]
+            Whether the last sale was an up or down tick. (provider: cboe)
+        bid : Optional[float]
+            Current bid price. (provider: cboe)
+        bid_size : Optional[float]
+            Bid lot size. (provider: cboe)
+        ask : Optional[float]
+            Current ask price. (provider: cboe)
+        ask_size : Optional[float]
+            Ask lot size. (provider: cboe)
+        volume : Optional[float]
+            Stock volume for the current trading day. (provider: cboe)
+        iv30 : Optional[float]
+            The 30-day implied volatility of the stock. (provider: cboe)
+        iv30_change : Optional[float]
+            Change in 30-day implied volatility of the stock. (provider: cboe)
+        last_trade_timestamp : Optional[datetime]
+            Last trade timestamp for the stock. (provider: cboe)
+        iv30_annual_high : Optional[float]
+            The 1-year high of implied volatility. (provider: cboe)
+        hv30_annual_high : Optional[float]
+            The 1-year high of realized volatility. (provider: cboe)
+        iv30_annual_low : Optional[float]
+            The 1-year low of implied volatility. (provider: cboe)
+        hv30_annual_low : Optional[float]
+            The 1-year low of realized volatility. (provider: cboe)
+        iv60_annual_high : Optional[float]
+            The 60-day high of implied volatility. (provider: cboe)
+        hv60_annual_high : Optional[float]
+            The 60-day high of realized volatility. (provider: cboe)
+        iv60_annual_low : Optional[float]
+            The 60-day low of implied volatility. (provider: cboe)
+        hv60_annual_low : Optional[float]
+            The 60-day low of realized volatility. (provider: cboe)
+        iv90_annual_high : Optional[float]
+            The 90-day high of implied volatility. (provider: cboe)
+        hv90_annual_high : Optional[float]
+            The 90-day high of realized volatility. (provider: cboe)"""  # noqa: E501
+
+        inputs = filter_inputs(
+            provider_choices={
+                "provider": provider,
+            },
+            standard_params={
+                "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol,
+            },
+            extra_params=kwargs,
+        )
+
+        return self._command_runner.run(
+            "/stocks/info",
+            **inputs,
+        )
+
     @validate_arguments
     def load(
         self,
@@ -58,7 +175,11 @@ class ROUTER_stocks(Container):
                 description="End date of the data, in YYYY-MM-DD format."
             ),
         ] = None,
-        provider: Union[Literal["fmp", "intrinio", "polygon"], None] = None,
+        chart: bool = False,
+        provider: Union[
+            Literal["alpha_vantage", "cboe", "fmp", "intrinio", "polygon", "yfinance"],
+            None,
+        ] = None,
         **kwargs
     ) -> OBBject[List]:
         """Load stock data for a specific ticker.
@@ -71,14 +192,26 @@ class ROUTER_stocks(Container):
             Start date of the data, in YYYY-MM-DD format.
         end_date : Union[datetime.date, None, str]
             End date of the data, in YYYY-MM-DD format.
-        provider : Union[Literal['fmp', 'intrinio', 'polygon'], None]
+        chart : bool
+            Whether to create a chart or not, by default False.
+        provider : Union[Literal['alpha_vantage', 'cboe', 'fmp', 'intrinio', 'polygo...
             The provider to use for the query, by default None.
-            If None, the provider specified in defaults is selected or 'fmp' if there is
+            If None, the provider specified in defaults is selected or 'alpha_vantage' if there is
             no default.
+        period : Union[Literal['intraday', 'daily', 'weekly', 'monthly'], Literal['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']]
+            Period of the data to return. (provider: alpha_vantage, yfinance)
+        interval : Union[Literal['1min', '5min', '15min', '30min', '60min'], None, Literal['1d', '1m'], Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'], Literal['1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo']]
+            Data granularity. (provider: alpha_vantage, cboe, fmp, yfinance)
+        adjusted : Union[bool, None]
+            Output time series is adjusted by historical split and dividend events. (provider: alpha_vantage, polygon)
+        extended_hours : Union[bool, None]
+            Extended trading hours during pre-market and after-hours. (provider: alpha_vantage)
+        month : Union[str, None]
+            Query a specific month in history (in YYYY-MM format). (provider: alpha_vantage)
+        outputsize : Union[Literal['compact', 'full'], None]
+            Compact returns only the latest 100 data points in the intraday time series; full returns trailing 30 days of the most recent intraday data if the month parameter (see above) is not specified, or the full intraday data for a specific month in history if the month parameter is specified. (provider: alpha_vantage)
         timeseries : Union[pydantic.types.NonNegativeInt, None]
             Number of days to look back. (provider: fmp)
-        interval : Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day']
-            Data granularity. (provider: fmp)
         timezone : Union[Literal['Africa/Algiers', 'Africa/Cairo', 'Africa/Casablanca', 'Africa/Harare', 'Africa/Johannesburg', 'Africa/Monrovia', 'Africa/Nairobi', 'America/Argentina/Buenos_Aires', 'America/Bogota', 'America/Caracas', 'America/Chicago', 'America/Chihuahua', 'America/Denver', 'America/Godthab', 'America/Guatemala', 'America/Guyana', 'America/Halifax', 'America/Indiana/Indianapolis', 'America/Juneau', 'America/La_Paz', 'America/Lima', 'America/Lima', 'America/Los_Angeles', 'America/Mazatlan', 'America/Mexico_City', 'America/Mexico_City', 'America/Monterrey', 'America/Montevideo', 'America/New_York', 'America/Phoenix', 'America/Regina', 'America/Santiago', 'America/Sao_Paulo', 'America/St_Johns', 'America/Tijuana', 'Asia/Almaty', 'Asia/Baghdad', 'Asia/Baku', 'Asia/Bangkok', 'Asia/Bangkok', 'Asia/Chongqing', 'Asia/Colombo', 'Asia/Dhaka', 'Asia/Dhaka', 'Asia/Hong_Kong', 'Asia/Irkutsk', 'Asia/Jakarta', 'Asia/Jerusalem', 'Asia/Kabul', 'Asia/Kamchatka', 'Asia/Karachi', 'Asia/Karachi', 'Asia/Kathmandu', 'Asia/Kolkata', 'Asia/Kolkata', 'Asia/Kolkata', 'Asia/Kolkata', 'Asia/Krasnoyarsk', 'Asia/Kuala_Lumpur', 'Asia/Kuwait', 'Asia/Magadan', 'Asia/Muscat', 'Asia/Muscat', 'Asia/Novosibirsk', 'Asia/Rangoon', 'Asia/Riyadh', 'Asia/Seoul', 'Asia/Shanghai', 'Asia/Singapore', 'Asia/Srednekolymsk', 'Asia/Taipei', 'Asia/Tashkent', 'Asia/Tbilisi', 'Asia/Tehran', 'Asia/Tokyo', 'Asia/Tokyo', 'Asia/Tokyo', 'Asia/Ulaanbaatar', 'Asia/Urumqi', 'Asia/Vladivostok', 'Asia/Yakutsk', 'Asia/Yekaterinburg', 'Asia/Yerevan', 'Atlantic/Azores', 'Atlantic/Cape_Verde', 'Atlantic/South_Georgia', 'Australia/Adelaide', 'Australia/Brisbane', 'Australia/Darwin', 'Australia/Hobart', 'Australia/Melbourne', 'Australia/Melbourne', 'Australia/Perth', 'Australia/Sydney', 'Etc/UTC', 'UTC', 'Europe/Amsterdam', 'Europe/Athens', 'Europe/Belgrade', 'Europe/Berlin', 'Europe/Berlin', 'Europe/Bratislava', 'Europe/Brussels', 'Europe/Bucharest', 'Europe/Budapest', 'Europe/Copenhagen', 'Europe/Dublin', 'Europe/Helsinki', 'Europe/Istanbul', 'Europe/Kaliningrad', 'Europe/Kiev', 'Europe/Lisbon', 'Europe/Ljubljana', 'Europe/London', 'Europe/London', 'Europe/Madrid', 'Europe/Minsk', 'Europe/Moscow', 'Europe/Moscow', 'Europe/Paris', 'Europe/Prague', 'Europe/Riga', 'Europe/Rome', 'Europe/Samara', 'Europe/Sarajevo', 'Europe/Skopje', 'Europe/Sofia', 'Europe/Stockholm', 'Europe/Tallinn', 'Europe/Vienna', 'Europe/Vilnius', 'Europe/Volgograd', 'Europe/Warsaw', 'Europe/Zagreb', 'Pacific/Apia', 'Pacific/Auckland', 'Pacific/Auckland', 'Pacific/Chatham', 'Pacific/Fakaofo', 'Pacific/Fiji', 'Pacific/Guadalcanal', 'Pacific/Guam', 'Pacific/Honolulu', 'Pacific/Majuro', 'Pacific/Midway', 'Pacific/Midway', 'Pacific/Noumea', 'Pacific/Pago_Pago', 'Pacific/Port_Moresby', 'Pacific/Tongatapu'], None]
             Returns trading times in this timezone. (provider: intrinio)
         source : Union[Literal['realtime', 'delayed', 'nasdaq_basic'], None]
@@ -97,15 +230,33 @@ class ROUTER_stocks(Container):
             Sort order of the data. (provider: polygon)
         limit : PositiveInt
             The number of data entries to return. (provider: polygon)
-        adjusted : bool
-            Output time series is adjusted by historical split and dividend events. (provider: polygon)
+        prepost : bool
+            Include Pre and Post market data. (provider: yfinance)
+        actions : bool
+            Include actions. (provider: yfinance)
+        auto_adjust : bool
+            Adjust all OHLC data automatically. (provider: yfinance)
+        back_adjust : bool
+            Attempt to adjust all the data automatically. (provider: yfinance)
+        progress : bool
+            Show progress bar. (provider: yfinance)
+        ignore_tz : bool
+            When combining from different timezones, ignore that part of datetime. (provider: yfinance)
+        rounding : bool
+            Round to two decimal places? (provider: yfinance)
+        repair : bool
+            Detect currency unit 100x mixups and attempt repair. (provider: yfinance)
+        keepna : bool
+            Keep NaN rows returned by Yahoo? (provider: yfinance)
+        group_by : Literal['ticker', 'column']
+            Group by ticker or column. (provider: yfinance)
 
         Returns
         -------
         OBBject
             results : List[StockHistorical]
                 Serializable results.
-            provider : Union[Literal['fmp', 'intrinio', 'polygon'], None]
+            provider : Union[Literal['alpha_vantage', 'cboe', 'fmp', 'intrinio', 'polygon', 'yfinance'], None]
                 Provider name.
             warnings : Optional[List[Warning_]]
                 List of warnings.
@@ -130,6 +281,18 @@ class ROUTER_stocks(Container):
             The volume of the symbol.
         vwap : Optional[PositiveFloat]
             Volume Weighted Average Price of the symbol.
+        adjusted_close : Optional[PositiveFloat]
+            The adjusted close price of the symbol. (provider: alpha_vantage)
+        dividend_amount : Optional[NonNegativeFloat]
+            Dividend amount paid for the corresponding date. (provider: alpha_vantage)
+        split_coefficient : Optional[NonNegativeFloat]
+            Split coefficient for the corresponding date. (provider: alpha_vantage)
+        calls_volume : Optional[float]
+            Number of calls traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe)
+        puts_volume : Optional[float]
+            Number of puts traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe)
+        total_options_volume : Optional[float]
+            Total number of options traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe)
         adj_close : Optional[float]
             Adjusted Close Price of the symbol. (provider: fmp)
         unadjusted_volume : Optional[float]
@@ -162,6 +325,7 @@ class ROUTER_stocks(Container):
                 "end_date": end_date,
             },
             extra_params=kwargs,
+            chart=chart,
         )
 
         return self._command_runner.run(
@@ -180,6 +344,7 @@ class ROUTER_stocks(Container):
             Union[int, None],
             OpenBBCustomParameter(description="The number of data entries to return."),
         ] = 100,
+        chart: bool = False,
         provider: Union[Literal["fmp"], None] = None,
         **kwargs
     ) -> OBBject[List]:
@@ -191,6 +356,8 @@ class ROUTER_stocks(Container):
             Symbol to get data for.
         limit : Union[int, None]
             The number of data entries to return.
+        chart : bool
+            Whether to create a chart or not, by default False.
         provider : Union[Literal['fmp'], None]
             The provider to use for the query, by default None.
             If None, the provider specified in defaults is selected or 'fmp' if there is
@@ -342,6 +509,7 @@ class ROUTER_stocks(Container):
                 "limit": limit,
             },
             extra_params=kwargs,
+            chart=chart,
         )
 
         return self._command_runner.run(
@@ -359,7 +527,10 @@ class ROUTER_stocks(Container):
             Union[pydantic.types.NonNegativeInt, None],
             OpenBBCustomParameter(description="Number of results to return per page."),
         ] = 20,
-        provider: Union[Literal["benzinga", "fmp", "intrinio", "polygon"], None] = None,
+        chart: bool = False,
+        provider: Union[
+            Literal["benzinga", "fmp", "intrinio", "polygon", "yfinance"], None
+        ] = None,
         **kwargs
     ) -> OBBject[List]:
         """Get news for one or more stock tickers.
@@ -370,7 +541,9 @@ class ROUTER_stocks(Container):
             Comma separated list of symbols.
         limit : Union[pydantic.types.NonNegativeInt, None]
             Number of results to return per page.
-        provider : Union[Literal['benzinga', 'fmp', 'intrinio', 'polygon'], None]
+        chart : bool
+            Whether to create a chart or not, by default False.
+        provider : Union[Literal['benzinga', 'fmp', 'intrinio', 'polygon', 'yfinance...
             The provider to use for the query, by default None.
             If None, the provider specified in defaults is selected or 'benzinga' if there is
             no default.
@@ -410,7 +583,7 @@ class ROUTER_stocks(Container):
         OBBject
             results : List[StockNews]
                 Serializable results.
-            provider : Union[Literal['benzinga', 'fmp', 'intrinio', 'polygon'], None]
+            provider : Union[Literal['benzinga', 'fmp', 'intrinio', 'polygon', 'yfinance'], None]
                 Provider name.
             warnings : Optional[List[Warning_]]
                 List of warnings.
@@ -455,10 +628,18 @@ class ROUTER_stocks(Container):
             Image URL. (provider: polygon)
         keywords : Optional[List[str]]
             Keywords in the article (provider: polygon)
-        publisher : Optional[PolygonPublisher]
-            Publisher of the article. (provider: polygon)
+        publisher : Union[PolygonPublisher, NoneType, str]
+            Publisher of the article. (provider: polygon, yfinance)
         tickers : Optional[List[str]]
-            Tickers covered in the article. (provider: polygon)"""  # noqa: E501
+            Tickers covered in the article. (provider: polygon)
+        uuid : Optional[str]
+            Unique identifier for the news article (provider: yfinance)
+        type : Optional[str]
+            Type of the news article (provider: yfinance)
+        thumbnail : Optional[List[T]]
+            Thumbnail related data to the ticker news article. (provider: yfinance)
+        related_tickers : Optional[str]
+            Tickers related to the news article. (provider: yfinance)"""  # noqa: E501
 
         inputs = filter_inputs(
             provider_choices={
@@ -469,6 +650,7 @@ class ROUTER_stocks(Container):
                 "limit": limit,
             },
             extra_params=kwargs,
+            chart=chart,
         )
 
         return self._command_runner.run(
@@ -624,3 +806,70 @@ class ROUTER_stocks(Container):
             "/stocks/quote",
             **inputs,
         )
+
+    @validate_arguments
+    def search(
+        self,
+        query: typing_extensions.Annotated[
+            str, OpenBBCustomParameter(description="Search query.")
+        ] = "",
+        ticker: typing_extensions.Annotated[
+            bool,
+            OpenBBCustomParameter(description="Whether to search by ticker symbol."),
+        ] = False,
+        provider: Union[Literal["cboe"], None] = None,
+        **kwargs
+    ) -> OBBject[List]:
+        """Search for a company or stock ticker.
+
+        Parameters
+        ----------
+        query : str
+            Search query.
+        ticker : bool
+            Whether to search by ticker symbol.
+        provider : Union[Literal['cboe'], None]
+            The provider to use for the query, by default None.
+            If None, the provider specified in defaults is selected or 'cboe' if there is
+            no default.
+
+        Returns
+        -------
+        OBBject
+            results : List[StockSearch]
+                Serializable results.
+            provider : Union[Literal['cboe'], None]
+                Provider name.
+            warnings : Optional[List[Warning_]]
+                List of warnings.
+            chart : Optional[Chart]
+                Chart object.
+            metadata: Optional[Metadata]
+                Metadata info about the command execution.
+
+        StockSearch
+        -----------
+        symbol : Optional[str]
+            Symbol to get data for.
+        name : Optional[str]
+            Name of the company.
+        dpm_name : Optional[str]
+            Name of the primary market maker. (provider: cboe)
+        post_station : Optional[str]
+            Post and station location on the CBOE trading floor. (provider: cboe)"""  # noqa: E501
+
+        inputs = filter_inputs(
+            provider_choices={
+                "provider": provider,
+            },
+            standard_params={
+                "query": query,
+                "ticker": ticker,
+            },
+            extra_params=kwargs,
+        )
+
+        return self._command_runner.run(
+            "/stocks/search",
+            **inputs,
+        )

openbb_sdk/openbb/package/stocks_fa.py

@@ -63,7 +63,7 @@ class ROUTER_stocks_fa(Container):
             pydantic.types.NonNegativeInt,
             OpenBBCustomParameter(description="The number of data entries to return."),
         ] = 12,
-        provider: Union[Literal["fmp", "intrinio", "polygon"], None] = None,
+        provider: Union[Literal["fmp", "intrinio", "polygon", "yfinance"], None] = None,
         **kwargs
     ) -> OBBject[List]:
         """Balance Sheet.
@@ -76,7 +76,7 @@ class ROUTER_stocks_fa(Container):
             Period of the data to return.
         limit : NonNegativeInt
             The number of data entries to return.
-        provider : Union[Literal['fmp', 'intrinio', 'polygon'], None]
+        provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None]
             The provider to use for the query, by default None.
             If None, the provider specified in defaults is selected or 'fmp' if there is
             no default.
@@ -122,7 +122,7 @@ class ROUTER_stocks_fa(Container):
         OBBject
             results : List[BalanceSheet]
                 Serializable results.
-            provider : Union[Literal['fmp', 'intrinio', 'polygon'], None]
+            provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None]
                 Provider name.
             warnings : Optional[List[Warning_]]
                 List of warnings.
@@ -498,7 +498,7 @@ class ROUTER_stocks_fa(Container):
             pydantic.types.NonNegativeInt,
             OpenBBCustomParameter(description="The number of data entries to return."),
         ] = 12,
-        provider: Union[Literal["fmp", "intrinio", "polygon"], None] = None,
+        provider: Union[Literal["fmp", "intrinio", "polygon", "yfinance"], None] = None,
         **kwargs
     ) -> OBBject[List]:
         """Cash Flow Statement.
@@ -511,7 +511,7 @@ class ROUTER_stocks_fa(Container):
             Period of the data to return.
         limit : NonNegativeInt
             The number of data entries to return.
-        provider : Union[Literal['fmp', 'intrinio', 'polygon'], None]
+        provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None]
             The provider to use for the query, by default None.
             If None, the provider specified in defaults is selected or 'fmp' if there is
             no default.
@@ -557,7 +557,7 @@ class ROUTER_stocks_fa(Container):
         OBBject
             results : List[CashFlowStatement]
                 Serializable results.
-            provider : Union[Literal['fmp', 'intrinio', 'polygon'], None]
+            provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None]
                 Provider name.
             warnings : Optional[List[Warning_]]
                 List of warnings.
@@ -1301,7 +1301,7 @@ class ROUTER_stocks_fa(Container):
             pydantic.types.NonNegativeInt,
             OpenBBCustomParameter(description="The number of data entries to return."),
         ] = 12,
-        provider: Union[Literal["fmp", "intrinio", "polygon"], None] = None,
+        provider: Union[Literal["fmp", "intrinio", "polygon", "yfinance"], None] = None,
         **kwargs
     ) -> OBBject[List]:
         """Income Statement.
@@ -1314,7 +1314,7 @@ class ROUTER_stocks_fa(Container):
             Period of the data to return.
         limit : NonNegativeInt
             The number of data entries to return.
-        provider : Union[Literal['fmp', 'intrinio', 'polygon'], None]
+        provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None]
             The provider to use for the query, by default None.
             If None, the provider specified in defaults is selected or 'fmp' if there is
             no default.
@@ -1360,7 +1360,7 @@ class ROUTER_stocks_fa(Container):
         OBBject
             results : List[IncomeStatement]
                 Serializable results.
-            provider : Union[Literal['fmp', 'intrinio', 'polygon'], None]
+            provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None]
                 Provider name.
             warnings : Optional[List[Warning_]]
                 List of warnings.

openbb_sdk/openbb/package/stocks_options.py

@@ -25,7 +25,7 @@ class ROUTER_stocks_options(Container):
             Union[str, List[str]],
             OpenBBCustomParameter(description="Symbol to get data for."),
         ],
-        provider: Union[Literal["intrinio"], None] = None,
+        provider: Union[Literal["cboe", "intrinio"], None] = None,
         **kwargs
     ) -> OBBject[List]:
         """Get the complete options chain for a ticker.
@@ -34,9 +34,9 @@ class ROUTER_stocks_options(Container):
         ----------
         symbol : Union[str, List[str]]
             Symbol to get data for.
-        provider : Union[Literal['intrinio'], None]
+        provider : Union[Literal['cboe', 'intrinio'], None]
             The provider to use for the query, by default None.
-            If None, the provider specified in defaults is selected or 'intrinio' if there is
+            If None, the provider specified in defaults is selected or 'cboe' if there is
             no default.
         date : Union[str, None]
             Date for which the options chains are returned. (provider: intrinio)
@@ -46,7 +46,7 @@ class ROUTER_stocks_options(Container):
         OBBject
             results : List[OptionsChains]
                 Serializable results.
-            provider : Union[Literal['intrinio'], None]
+            provider : Union[Literal['cboe', 'intrinio'], None]
                 Provider name.
             warnings : Optional[List[Warning_]]
                 List of warnings.
@@ -108,7 +108,29 @@ class ROUTER_stocks_options(Container):
         theta : Optional[float]
             Theta of the option.
         vega : Optional[float]
-            Vega of the option."""  # noqa: E501
+            Vega of the option.
+        bid_size : Optional[int]
+            Bid size for the option. (provider: cboe)
+        ask_size : Optional[int]
+            Ask size for the option. (provider: cboe)
+        theoretical : Optional[float]
+            Theoretical value of the option. (provider: cboe)
+        last_trade_price : Optional[float]
+            Last trade price of the option. (provider: cboe)
+        tick : Optional[str]
+            Whether the last tick was up or down in price. (provider: cboe)
+        prev_close : Optional[float]
+            Previous closing price of the option. (provider: cboe)
+        change : Optional[float]
+            Change in  price of the option. (provider: cboe)
+        change_percent : Optional[float]
+            Change, in percent, of the option. (provider: cboe)
+        rho : Optional[float]
+            Rho of the option. (provider: cboe)
+        last_trade_timestamp : Optional[datetime]
+            Last trade timestamp of the option. (provider: cboe)
+        dte : Optional[int]
+            Days to expiration for the option. (provider: cboe)"""  # noqa: E501
 
         inputs = filter_inputs(
             provider_choices={

openbb_sdk/providers/yfinance/openbb_yfinance/models/futures_historical.py

@@ -122,8 +122,7 @@ class YFinanceFuturesHistoricalFetcher(
             else 0
         )
         if query.start_date:
-            data.set_index("date", inplace=True)
-            data.index = to_datetime(data.index)
+            data.index = to_datetime(data.index).tz_convert(None)
 
             start_date_dt = datetime.combine(query.start_date, datetime.min.time())
             end_date_dt = datetime.combine(query.end_date, datetime.min.time())
@@ -134,7 +133,7 @@ class YFinanceFuturesHistoricalFetcher(
             ]
 
         data.reset_index(inplace=True)
-        data.rename(columns={"index": "date"}, inplace=True)
+        data.rename(columns={"index": "Date"}, inplace=True)
 
         return data.to_dict("records")
 

openbb_sdk/providers/yfinance/tests/record/http/test_yfinance_fetchers/test_y_finance_balance_sheet_fetcher.yaml

@@ -5,7 +5,7 @@ interactions:
       Accept:
       - '*/*'
       Accept-Encoding:
-      - gzip, deflate
+      - gzip, deflate, br
       Connection:
       - keep-alive
     method: GET
@@ -13,93 +13,93 @@ interactions:
   response:
     body:
       string: !!binary |
-        H4sIAAAAAAAAAM1dW1PcyJL+LzwbRV2lkt+wwXPY8IUwzNmHjXmQuwvQTrfEqtXYPhP+75vqC1Sp
-        ckASWT28jIEYsj6qv8rKe/111JZLu7JNaVdHb/86auxqvWiP3v7PX0dL2xbdj1Y/l9/qBfzo6OTk
-        4uPRH2+O2p93tvu+qKp1sXhfrG5Pqnn3z9n/rcv7YmGrdnX0x683W9ltsbyD/5vrNDeMp4y9gf9w
-        JRTbfClFDj/bfJkqtfkalnhSdIduXrTF+fzorZBMMvj/V1+uT4sWYB0JxvNjlh9LdvTm6A7+snp+
-        tQF8xMUn+NFs3TS2mv18X8+7H/5+eQo/bOxd3bR2/u9isbabjSi+H71ViTFKnXFY4HoJu3KkTGLU
-        u6Nfv948jUAwIgQy6fbMQSBNwsQQBJwMgcrdLZAqyQdtgSACIBKZKncLhExS3SH4o8MwlKaf6+r9
-        ZtH21F5b+GL+sSy+lYuy7aj/x68xsi7bevbnbb2Y22bVEbP9SUJ3RKxPdcF1LKrnCVPGOLucM/jg
-        g885REBG9TTRUuYOglQnMmQagoCK6mkimQdAJmzQFlBRXScszYSDQLMkzUZT/WSxqL8X1cx+qJvT
-        ev2tvV4vTmazeg3K86udWVCk3xZ2JOc/FbPbsrLNzw/rpirbdWM7it4t4UCRkP8p+f4pkDyPdQrS
-        JM/yzKVADgo4oECIgOwUZIkWOXcQZDoRIQkRBFSnIEtMqt1jkJkkTYcgoDoGJuHMVfiGw7kYfQou
-        mhpg7LT7y/npiOvRUfNYdGTJwx7Alyz4CIKVyWg4fmUq+o1fmYp24cqj+PZbXc+/l4sFGKxf2lvb
-        nFdtUd2UoGlPVivbjrUxzqt74Gun/lYg8WR+3yl0Gir/jWif1pxHozUcZy0VKDm+32/O0Ls+xEBG
-        cMDAjMk8DCwxoaZFMFBRnSciM5mHQYD2NUMwUJEeMDDDtIcB9oGPVrfv6+WyrjYmLKFJHErtWcQm
-        mvM31CIOEBzcIg4RHNgiDgG8Mos4dP6uih92Nd0DPLkvykVnRYOJfVks7KWFP6okMzaeEN8Lfoho
-        /B+spUMMh9fSCIaDa2kEw6vT0h8LuPCr+fnyrqnv7ZIsUofJ7XttIh5TM2a0oyR4hqmpEAEhT7Nc
-        Cx9BrocgoGKpgJOiXL8R+MHCs4ogoIvTCS68OJ1IuBxvR2z19Mls1qzt/OzHna1Wo9Xzo4VbVh/K
-        CuzbEpTq3gyntKBD+T7tFVf/uIIOMRxeQSMYDq6gEQyvTkH3zJSv9t5Wa0tjS+OiewZFGs3t04kW
-        4ix/sOTg2/AODZYntKZTJR+X774dsjxdWC3lzl/ffTtkeSqCwn3kL5+P5+ZV3XY5ubsS/in/U7Rl
-        XZEQE5PbMx6yiFrUCJF7J9cINOQaYCDUoilsU+piSFXCQoIgGOi0aCZ47mHIYB+Q4HeIgU6LAjOk
-        d6OpPEknGBFbMm3iBkSZaEdg3wXL4uWfNc+8/LNOeIY4Hn0EZMwE/zvLct//zjDXJ0BAxUudZDJ1
-        jXudJXLQHlCxMk2UUV4URCVmfAJ6FxR+CL2S8DIQ6nNTq38+PBBiOLz1iWA4uPWJYHh11ieaJSYI
-        Z4ViezqURbM6u7u875bmMtQfAQLK2517sYE04YjlGwKgiw2kwFF3C9JEIEo8REAXGzDcuBeZMAk3
-        o+l5eVs09ny1Wts5TcGNI6+nOGXMaFWWidyrK+MZ/DDUGAEISk7mWZql0udljqitEASd6kyVSDOT
-        +iBUeDoREHS6U+dKKuHFD/Wuxm1cwUHxs1Ntm5xqEL0iKED4e/G9zG2axjNIUyHdj0uBJkHytgEC
-        MuKqBLw1D4FIZOikIAjoDFLlnxutkiysj0EQEBqknGvfIOUT3fnHzJiTDPts209lVTdl+/O8am0D
-        vKVz9Aev2Mv0phFNWSV6XieQKvS+QwiE+lhLrj0rUsuEh7RCMBCqY6H8fUgFpo0RDIQRAMOZ/1l0
-        5WDTvK0dz97VTVN/L6sbQp8rFN2LWMU0IJhn0HKWCKQ+L57xYMBYcSKpBrNdkOWpeJqDPe0sn2OR
-        VGR5OopyLlxrmvNJea5idfuQOiLrlniU2A9SmXh0FIJ5xiwaNgwRUGZfO0I+Z04jCAiDp5L1MtCI
-        VYIgoGOl0V6XBDeJHh+k+lhXN1e2WZ7ab+2m82YT9vxoi5X98m1R3tAF/Yet1LNsRbQ0QA7+KHMr
-        v3O+C6C8eRoBGYvzxKSph8DsSp2eQ0DHYpZzPw3B8p1l+RwGKh7DLuRe9TnsQj6++HtzR1/ewgId
-        x6JEXVHpfU9Mxkum8ox7XgjoIOSTChAQpgZELly+ajSwhiCgi2tlae5yRYDex3zBAAFdXEul2ous
-        qV2vxGhboNfkCCoxGn1HLNdvtYzG5y6Ur3U/lK9DuzbEQKiBWa7cM5UzvNcxGqNTsOT9il+BlimE
-        CKgYrRIjWa/lVY53vx4j/TSUdeX1dKyJ1g2mEm1YL/2KdIOFCAjbfzOlXLtSZokK6woRBHTRLq69
-        Ziy4ZzRyz4QI6KJdLJdu/iRlu3tmSvr1xT05VVs3NL0Nj9J6jGbRfDW16ax7cJ0VatwFyxMGb1nK
-        3eUZEjcNl6fTrnBXOwVgGum0CVen06y58vY+H++encxm6+V6Adjmp/auseDpkzlkfye7n6mNRs5j
-        0K7aKzY51gb7kEIMZAw9TsHnctXdcZpi0X0EAhVLj7OECeOaIccZw/O10bgKGIRUHgSxq+2YUs3q
-        99mQVbK6YnssVdFqsrq6l4ybXt1LhiT0AwyUdS9a5qJfe4O0xYQYCOtetDJepF7oRCE0DTEQ5m5l
-        bkQva5KPLyz4bNuLizMSbu5E9a50Gc1IBRNResUdYCJK5GILEBAaqaAyvRk1KRZ+RRDQzajxyylk
-        nigkKx0CoLvbBeeZn5Xe1viMz8h2AVG6bOtGWi81ZaLVB4BiAo/J9+INKKswPxNgIFSOXCjpRTG5
-        wPiAYCBUjirjuaccFXZJIBgoiwJZmveKAtn45tmrncv0rq7/3C5Bws5Aap+l0WJNAzu7QwSH7uxG
-        EBy2sxsB8Mo6uzcJI6Ie1q2ofttqTBpm2s1jMySNHixPaUT6bgZHvQwEAZ2W5ExIP5OODLdDEBDm
-        8kXGfQRiPAk3saXHuibCRlNccr/UJKJxKXLfuBRYjWiIgLLer+sa9CwrpG8QQUDF0s0QyNyPiBvE
-        oolnXYJbpbyKE612ZVmTOqvp2PkUK5mK2LKXCuNbV6lIDOaCR2zZU3KTgHUK1SSWgUUw0OlPqYxv
-        6UqFDigNMdBp0K6xxWs9kcDX8dWoPU1HHTJ6Qny/1TSaNgWTRzPpmzwaa7CMpk07TZL3FAnW6Rox
-        nSSlV2qvJfxkCALCMDwwxlXnecLHRzbdItAoXH2WqDze3EFQZJ5pLjPMdw0BUN76qdcvBLd+igS1
-        4o0hBG9d5e5ZVRl2VBAEhHlP4+V+U7bT7S8ZKBEpFI+J79kDOlriaNBgiWD5ww6WCJc/6GCJcPnX
-        NFjiv+vmz7K62dWAkvCyJ7IfW4o2R1uDDchcj1Jnu/aFN08joBwZL4WLQJpEYpHHaHO0c7AJvcCG
-        RNoTwuXJkpddLXTmRuOP+T6PPD4cf6i2qHHNUDqakSoSZZhw85sCHF6GdAEFGMgoDC6+0cp18ITe
-        l7M/h4GuuNRknWZzMJi9cnsOAxWTZQJ7alwnUzIBZsF4JjfF3Ba7wcT7RtJHb4iGxc+s0ZuLlkXr
-        jxJJrj3DSeQYd0IEhPw1Xjaw63YPY7sIADryqtR4ldEqSZGhbCECurhAmmp3D3g6pTJ6P1R7ZKHe
-        g1Uau4tl0EL9wFjE9GsqlL/nSHd2CIAwKiaz1OUdl2gnVoiALiamU68vgmvUIA4R0PUEcO4N4uRT
-        mrO/wv9XVnZ+VjQVWedqILRnVbBoIduulDp3Q9hKJ3loFocIKAO2uVelwlWSh9REENDFvnTqu6lI
-        e3e4PJlZDNZE6tS/dt+PT3U5A9mpB7wHzSYRy6CHzVULEBx8rlqI4NBz1UIEr2yu2m+g0lYf69Wq
-        szbbk+trO2tBuUVRoEPX6tdMR/PWupppdWacgmmVMPYpLBWO5qsdd1X8DgLF0oEICOdWyEcAvKtk
-        GbQ+YbyBc6+Y5phPuvM3cYDtMxe/NUCyeMGGpxbpj12JlmUY+sBGzJHAwx7YiDcVeOADG/HmAhOV
-        YbkpK+ryl6drXyK+UiSkP9NfJBKr+4g4OJCL1PPnOD7pJeILRcp3ZjjaMoYgIPSmhFcjJrp5I5Nn
-        s5FOYgu6/aNlFQbPXYuWVRg8dy1aVmHw3LVoiQWiuWv7aag7GpFOWN3L7Bug0WanDWRmiODQzEQQ
-        HJiZCIJXxszOGbdNNz7qogBAZA6+K7NnXsastsqNG21B6lbD1QlZmeepuzxDol3x6qzAB3MrEoYt
-        TjfDp2vKc/K/Ezry3PFQ5POmgrFSEWv8B46VijjUZOBYqYhl/oPHSkUr9CcaK7UdjWPnlJUqfZk9
-        BamiGZUczqWWXuku7IpGMv0BBtrRfZmHIcuwSCiCgY6fJjPMKyc3GXZKEQx06dKMZf5rChlLsheU
-        +xGpTVdeP48ZkZnD8pgRaTkwjxmRlAPzmNEoSZPH/Gzbq/7IHZIm+57UXnUJ+6ebR0MEh45aIggO
-        G7VEALyyqOUmFk5IS1de7xqP906vTKTR3DWvpDRYCXSIgbDmVEhj3KJBKST2EA+CgW4IhOaMuQV7
-        UnPU84n3Ti9gEJnWHgaRZBMei2rmZVU0PzcvlKw+r5ffiNxxVHAvpp5HnPI49O2TEMQ/8PYJAuLw
-        b58gIF7f2yebRA310MdAaI+nKmIJqTD+i0kCe9IrREBYQsr9Rjkwv7Aq/hABXQ2pFl7XsdCg5Ycg
-        oNOmIlO97vMJurQ36pZshK4rsz9tP2JHfuqlBCXebhQAICQmE96QXMFQ5yxEQDhsP5W9YfvD9oDO
-        /ORuaHfC8ySb0gv0tb1RztVDdX34XvRoNFQD0B6E9aeaRrOAc7jGvFrzXO+Ce2+eRkA5SwUMPT/E
-        KbFQGoKBMsyaCdkLs2J9u/HyUDzhSvlTvLlK1PhAa++lKGof7ZmJKkJELNHPALS3Q5nGptaHGAjZ
-        CpvmB10N273H+BwGOuuCpzx1T4zo3sVECrJDDIQRrsyLf4vu2ZbxBsZnSxdv3cvqP0cZrcwJVKXw
-        h1Lk2PM9IQIyOmbdeBsHQAYaI9RaCAAqLpok94uxTY6lIBAEdOkp8Aa9lwfS3R6M15oXRdNWtlnd
-        lnePaarxSa7u/YeLpoa/azcrYFS5VbOzRzaF/dtq06ktXFtBV8UPu/KHF4xKJ5eV/XL9HgSV7chf
-        fXhiu5vVPn7lq8YWq3UQyRn3gczqpYUdeKwYmrCTn+vWrqZJcF4EKSu4MetuNrhdFe37ejV2O3uf
-        66Q5/I/0mr6pPkVH/vLuAdZ9zfRkA97tlR27j2iv4Wh2dhpjMrMezaiOXH74Z4ycf9nF/Kr+VLTr
-        rhL90s66fycc8rqopjtTj4R4WP/LGgg/t9OV2Gl5D79fzSeeu82RnfwHwRHrmlIubLUCZryzFXw/
-        9rTCptwV5bRT+m5dLuZdO8xJNT9f3jX1vd2/YTTqrM1BZ8Mf0N1sJRy5aZfa6dq29Ve7ed6guyHL
-        Xv/7+GL3LYwp2sNRp+fVRti/4es1aJLfq7lttkz7ZNvbek5waU767HaCwAC4L1cT9Mp20e5cf6ib
-        y2Jhp+30w3OWW3mndlXeVN1HWKw+FGWzMaKubpt6fXMLUIHeddN1Z2202uilfuxvo6/2HgRv9OlX
-        u7LN/WhVsj1yD8MQ6u6KaMtmw//dQbxYgLKativ/svMbOFdbsNNEdONxzivYs5ldjf1sw6jTJIrB
-        1rZNOesqn7ye0smGyX/VZdXuT9Ik22RfIziZ9nsBfztxYKTKum7qJZHS6sZzAGkmX67vYTfaZj3r
-        /pANc26a8dTZHIetfnOa2kb9GZ1Km3wlgj4pV7d23o2VmGzIT+Lp9o+dZgY4u3Yy/9/141OAo45b
-        8R0MLPBSi8XYX/29gj99Uf4H9q0oq07BTtYYO8P57McdqMgJBt72eO0ZtD/8L7tVKI7lCwyJyU72
-        b3CRNAT+fqjPp9sNcNtbuKLf70IfoHSq1WKj/KYz11Pyl+tvYJKXReeJT9Lxn0AFLNfL3RX9kojC
-        w292Zs711syZrJ5P4WTew0bdW+DDHNTsdGTeaaNKML3EEUBs72mb9LFcljsZL2K8Y3oUq9tppjHJ
-        FY90eI/59bPl3aL+ae3OpJz6nCF8Hs7pPFks6u+gH0fzzvH/KcQ53Nue1RPHnG5Qc7pbAeSADqub
-        o7fVerH49ev/AUdHCenisAAA
+        H4sIAAAAAAAAAM1dW1fcuJb+LzwHL11tOW8kkD7MyoUV6DMPs/rBqRLg6SqbcblIcnrlv892XUCy
+        doNttqp5SYpaIH2WP23tu/46asulXdmmtKujt38dNXa1XrRHb//nr6OlbYvuq9XP5bd6AV8dnZxc
+        fDz6481R+/POdj8XVbUuFu+L1e1JNe/+O/u/dXlfLGzVro7++PVmO3ZbLO/gt7lOc8N4ytgb+Icr
+        odjmoxQ5fLf5mCq1+QxTPDl0h25etMX5/OitkEwy+P3Vl+vTogVYR4Lx/Jjlx5IdvTm6gyer51cb
+        wEdcfIKvZuumsdXs5/t63n35++UpfNnYu7pp7fzfxWJtNwtRfD96qxJjlDrjMMH1ElblSJnEqHdH
+        v369eRqBYEQIZNKtmYNAmoSJIQg4GQKVu0sgVZIPWgJBBEAkMlXuEgiZpLpD8EeHYShNP9fV+82k
+        7am9tvBh/rEsvpWLsu2o/8evMWNdtvXsz9t6MbfNqiNm+5OE7siwPtUF17GonidMGeOscs7gxQfv
+        OURARvU00VLmDoJUJzJkGoKAiuppIpkHQCZs0BJQUV0nLM2Eg0CzJM1GU/1ksai/F9XMfqib03r9
+        rb1eL05ms3oNwvOrnVkQpN8WdiTnPxWz27Kyzc8P66Yq23VjO4reLWFDkZD/qfH9XSB5HmsXpEme
+        5ZlLgRwEcECBEAHZLsgSLXLuIMh0IkISIgiodkGWmFS72yAzSZoOQUC1DUzCmSvwDYd9MXoXXDQ1
+        wNhJ95fz0xmuR0fNY9GRJQ9rAB9Z8AqCmcloOH5mKvqNn5mKduHMo/j2W13Pv5eLBSisX9pb25xX
+        bVHdlCBpT1Yr247VMd7Xy2VdbVQCQhUjHLWnYZhoyvRQDSNAcHANI0RwYA0jBPDKNIzz6h5o2J3N
+        K6D7yfy+0zZo5OzfDO3TlPNoMhfOGi0VnMB8v0ScoTQJMZARFTAwYzIPA0tMyBQEAxVVeSIyk3kY
+        BKgGZggGKrYCBmaY9jDAOnAC4++q+GFX0y3Ak/uiXHRaNKjYl8XCXlp4rJJM2Xhi+J7zQ0ST14M3
+        Qojh8BsBwXDwjYBgeHUb4WMBMrWany/vmvreLsk8ddi4fatNxGNqxox2DjWeYcdqiICQp1muhY8g
+        10MQULFUwE5Rrt0I/GDhXkUQ0PnpBBeen04kXI5m6E5On8xmzdrOz37c2Wo1Wjw/KhFl9aGsQIUo
+        Qaju1XBKJSUc36e94uofF9AhhsMLaATDwQU0guHVCeiemvLV3ttqbWlsP3zonkKRRtOsdaKFOMsf
+        LA/4MTxDg+kJrb9Uycfpux+HTE/nVku58/Tdj0OmpyIonEf+9Pl4bl7VbReTuyvhv/I/RVvWFQkx
+        sXF7ykMWUYoaIXJv5xqBulwDDIRSNIVlSl0MqUpYSBAEA50UzQTPPQwZrAPi/A4x0ElRYIb0TjSV
+        J+kEJWJLpo2fiygS7QzYN8GyePFnzTMv/qwTniGGRx8BGTN1wrIs9/1FGWb6BAioeKmTTKaucq+z
+        RA5aAypWpokyyvPaqcSMD0DvnMIP3i0SXgaD+tzU6p93D4QYDq99IhgOrn0iGF6d9olGiQncWeGw
+        PRnKommd3VneN0tzGcqPAAHl6c4930CacETzDQHQ+QZS4Ki7BGkiECEeIqDzDRhu3INMmISb0fS8
+        vC0ae75are2cJuHGGa8nOGVMb1WWidzLK+MZfBlKjAAEJSfzLM1S6fMyR8RWCIJOdKZKpJlJfRAq
+        3J0ICDrZqXMllfD8h3qX4zYu4aD42Ym2Tdgq8F4RJCD8/fC94FiaxlNIUyHd16VAkiChsQABGXFV
+        Ataah0AkMjRSEAR0Cqny941WSRbmxyAICBVSzrWvkPKJ5vxjZMwJhn227aeyqpuy/XletbYB3tIZ
+        +oNn7GUmpBFVWSV6VieQKrS+QwiE8lhLrj0tUsuEh7RCMBCKY6H8dUgFJo0RDIQeAMOZ/y66dLBp
+        1taOZ+/qpqm/l9UNoc0VDt3zWMVUIJin0HKWCCQ/L57yYEBZcTypBtNdkOmpeJqDPu1Mn2OeVGR6
+        OopyLlxtmvNJca5idfsQOiKrlngcse+kMvHoKATzlFnUbRgioIy+doR8Tp1GEBA6TyXrRaARrQRB
+        QMdKo70qCW4SPd5J9bGubq5sszy139pN5c3G7fnRFiv75duivKFz+g+bqafZimhhgBzsUeZmfud8
+        50B58zQCMhbniUlTD4HZpeY9h4COxSznfhiC5TvN8jkMVDyGVci97HNYhXx88vfmjL68hQk6jkXx
+        uqKj9y0xGS+YyjPuWSEgg5A3FSAgDA2IXLh81ahjDUFA59fK0tzligC5j9mCAQI6v5ZKtedZU7ta
+        idG6QK/IEURiNPqOmK5fahmNz50rX+u+K1+Hem2IgVACs1y5eypneK1jNEanoMn7GeoCTVMIEVAx
+        WiVGsl7Jqxxvfj16+mko647Xk7EmWjWYSrRhvfArUg0WIiAs/82UcvVKmSUqzCtEENB5u7j2irHg
+        nNHIORMioPN2sVy68ZOU7c6ZKeHXF9XkdJKxauuGphbncbQeo1k0W01tKuseTGeFKnfB9ITOW5Zy
+        d3qG+E3D6emkK5zVTgKYRooZwtnpJGuuvLXPx5tnJ7PZerleALb5qb1rLFj6ZAbZ343dj9RGI+cx
+        SFftJZsca4O9pBADGUOPU7C5XHF3nKaYdx+BQMXS4yxhwrhqyHHG8HhtNK4CBiGVB0HscjumZLP6
+        dTZkmazusD2Wqmg5WV3eS8ZNL+8lQwL6AQbKvBctc9HPvUHKYkIMhHkvWhnPUy90ohCahhgIY7cy
+        N6IXNcnHJxZsAlOdJ4ouzLUZrRcTMNECs8AIUFV988kAS0LHeICBkJVcKOm5jzgYyEgRSoiBkJUq
+        47nHSoXtTgQDZTYWS/NeNhYbX2X72bYXF2cklNwN1VM0ZTTTCQwX6aUcgeEiEXUrQEBoOsFB7nVO
+        SrGgAIKArnOSn+Qjc2wzIADoNE7BeebnSmwzz8YJx53J9K6u/9xOQCIkg1H7wjKar2lgJ4IQwaE7
+        ESAIDtuJAAHwyjoRbAJGRDWs26H6ZasxaZhpN47NkDB6MD2lEumbGRy1MhAEdIc1Z0L6kXSkuR2C
+        gDCWLzLuIxDjSbjxLT3mNREWmuIj91NNIh7jIvePcYHliIYIKPP9uqpB7wxD6gYRBFQs3TSBzH2P
+        uEEU63jnOJhVyss40WqXljWpspqOnU+xkqmIJXupML6Sn4rEYCZ4xJI9JTcBWCdRTWIRWAQDnfyU
+        yvgGl1Rog9IQA50E7QpbvNITCXwdn43ak3TULqMnhu+XmkaTpqDyaCZ9lUdjBZbRpGknSfKeIMEq
+        XSOGk6T0Uu21hG+GICB0wwNjXHGeJ3y8Z9NNAo3C1WeJyuP1HQRB5qnmYLwjLpQQAOWpn3r1QnDq
+        p4j7IF4bQpVkKnf3qsqwrYIgIIx7Gi/2m7KdbH9JQ4lIrnhs+J4+oKMFjgY1lgimP2xjiXD6gzaW
+        CKd/TY0l/rtu/iyrm10OKAkve0P2fUvR+mhr0AGZa1HqbFe+8OZpBJQt46VwEUiTSMwBHq2Pdg46
+        oefYkEh5Qjg9WfCyy4XOXL/nMd/HkcdHhQ5VFjWuGEpHU1JFogwTbnxTgMHLkCqgAAMZhcHEN1q5
+        Bp7Q+3T25zDQJZearJNsDgazF27PYaBiskxgTY1rZEomQC0Yz+SmmNti15h4X0j6aA3RsPiZOXp9
+        0bJo9VEiybWnOIkc406IgJC/xou7dNXuoW8XAUBHXpUaLzNaJSnSlC1EQOcXSFPtrgFPp2RG75tq
+        j22evddKY1exDJqo7xiLmAWQCuWvOVKdHQIg9IrJLHV5xyVaiRUioPOJ6dSri+AaVYhDBHQ1AZx7
+        jTj5lOLsr/B7ZWXnZ0VTkVWuBoP2tAoWzWXbpVLnrgtb6SQP1eIQAaXDNvfyAbhK8pCaCAI635dO
+        fTMVKe8OpydTi0GbSJ381+7n8aEu5wIB6gsJgmKTiGnQw/qqBQgO3lctRHDovmohglfWV+03EGmr
+        j/Vq1Wmb7cn1tZ21INyiCNChc/VzpqNZa13OtDozTsK0Shj7FKYKR7PVjrssfgeBYulABIR9K+Qj
+        AN5lsgyan9DfwLmXTHPMJ535Gz/A9lqW3xogWTxnw1OT9NuuRIsyDL0QJmZL4GEXwsTrCjzwQph4
+        fYGJ0rDckBV1+svTuS8RL4IR0u/pLxKJ5X1EbBzIRerZcxzv9BLxEhjlGzMcLRlDEBBaU8LLERNd
+        v5HJvdlIO7EF1f7RogqD+65FiyoM7rsWLaowuO9atMACUd+1fTfUHY1IO6zux+wroNF6pw1kZojg
+        0MxEEByYmQiCV8bMzhi3Tdc+6qIAQGQGvjtmT72MmW2VG9fbguSthrMTsjLPU3d6hni74uVZgQ3m
+        ZiQMm5yuh09XlOfEfydU5Lntocj7TQVtpSLm+A9sKxWxqcnAtlIR0/wHt5WKluhP1FZq2xrHzikz
+        Vfpj9gSkiqZUctiXWnqpu7AqGon0BxhoW/dlHoYswzyhCAY6fprMMC+d3GTYLkUw0IVLM5b5tylk
+        LMlekO5HJDbd8fpxzIjMHBbHjEjLgXHMiKQcGMeMRkmaOOZn2171W+6QlDP3Ru1ll7B/ung0RHBo
+        ryWC4LBeSwTAK/NabnzhhLR0x+sd4/Hu6ZWJNJq76pWUBkuBDjEQ5pwKaYybNCiFxC7iQTDQldtr
+        zpibsCc1Ry2fePf0AgaRae1hEEk24bKoZl5WRfNzc0PJ6vN6+Y3IHEcH7vnU84hdHofefRKC+Afu
+        PkFAHP7uEwTE67v7ZBOooW76GAza46mKmEIqjH9jksCu9AoREKaQcr9QDtQvLIs/RECXQ6qFV3Us
+        NEj5IQjopKnIVK/6fIIs7bW6JWuh647Z77YfsSI/9UKCEi83CgAQEpMJr0muYKhxFiIgbLafyl6z
+        /WFrQKd+cte1O+F6kk3qBXrb3ijj6iG7PrwvejQaqlZTD4P1u5pG04BzOMa8XPNc75x7b55GQNlL
+        BRQ938UpMVcagoHSzZoJ2XOzYnW78eJQPOFK+V28uUrUeEdr76YoahvtmY4qQkRM0c8AtLdCmca6
+        1ocYCNkKi+Y7XQ3b3cf4HAY67YKnPHV3jOjuxUQSskMMhB6uzPN/i+7alvEKxmdL52/dj9W/jjJa
+        mhOISuE3pcix63tCBGR0zLr2Ng6ADCRGKLUQAFRcNEnuJ2ObHAtBIAjowlNgDXo3D6S7NZji/P/b
+        eqdRAdjHetR/2cX8um4uQdf1agbHDPeh/GHnW2ELOgo8/AbTV7uyzf1YdWWH4HPdWieJZrS5etHU
+        8NZ2nRBG//W+e/v4P/+Xnd+U1c12Maat5se6qKarjW6F5mSN88JWK3iDJ/uCz3rVNrYtG9tdHPLO
+        Vva6bC8WAHP0o23j9NsU5ce7SCa06t9dYlJWl+tvq3JeFt3LKtr39WrsaI4T4mT+v+vdwCeLRf29
+        qGajGRDq7ZOuI3hfV7Do61m3k84roPNNY1djB7lodhB6rsZpY3R1PNs3N3qF4VHKWRcH9yqMxsmY
+        3eV329U8tavypgJZPS9WH4qy2Yjcq9umXt/cwmIBP+umq+XYaIQjp3q3LhfzrtQD+H++vGvqe7u/
+        n2eU4QX7pOkyo5oWPqxuy7vHzIJpbJ8s1Pb7jujwWJaw7i9+rm3+9/ZPpzDiqoHHWAdu9MmCBIhV
+        d/ciTBQje9EJdCk74Tl6w6PvZuwo293RHeoftof6tDPIsaFe6sfY155MO5NO17atv9rNzRUd44D7
+        057IOdIppPyGvPtj7KGCZ1Iyx1a6XhU/ANmUk2J3Yfgexss0h+0jOSs0/n1dN/WS4o2BxC9Xt3be
+        tQkYC6N3WoxW4hbzq/pT0a674qlLO+v+Hy91N2cPvNdpzMf44Tf4GjPa7xVIy0X5H1jOoqy6k3Gs
+        GrBVCQtHJfyKqoTTt+eDJP6vuqzaf8PndTNZp3vQOIrV7cg/7tpLbVSu2XiN6xRMxXuQ3PcW/n4O
+        6tv0V7Y/tCefKOfVrF7ayQR8PAM6Y8yP/72AyJN2ZNd/BjSyyVsRlNi7opw4d7eNX6ztwON3VcS7
+        bbTbMGMl/XxedkpBB6cEgT8NyUaSEIYlpp9coKJY0OLf73wp8JKr1WKj9kw/gHxzZazYKL6D1Ict
+        XCymXB+3Q3xebUTkXoD9Xs335+on297W86l67oQHQtSnyV6ej8DfL9fvYWlHExcpdh71FOV9ObfV
+        fKJD6Gx5t6h/WrvbdCQqzeRV3Di2CHbfTus7+3EHEuUFToqXSEZ4reVyvdzJtOkn3eOefZDvX9ag
+        CMxtz+cAfwm/VzdHb6v1YvHr1/8DlgscHeKwAAA=
     headers:
       Age:
-      - '1'
+      - '0'
       Connection:
       - keep-alive
       Expect-CT:
@@ -123,21 +123,21 @@ interactions:
       content-type:
       - application/json;charset=utf-8
       date:
-      - Tue, 19 Sep 2023 20:25:11 GMT
+      - Tue, 26 Sep 2023 12:12:59 GMT
       server:
       - ATS
       vary:
       - Origin,Accept-Encoding
       x-envoy-decorator-operation:
-      - finance-company-fundamentals-api--mtls-production-sg3.finance-k8s.svc.yahoo.local:4080/*
+      - finance-company-fundamentals-api--mtls-production-ir2.finance-k8s.svc.yahoo.local:4080/*
       x-envoy-upstream-service-time:
-      - '59'
+      - '42'
       x-request-id:
-      - cde03e0f-cfde-4090-a6a2-99515fca03fa
+      - bfacfa9b-fd6e-4698-bd06-46960e9b0726
       x-yahoo-request-id:
-      - 2bl3j0higk0t8
+      - 0c9mhqpih5imb
       y-rid:
-      - 2bl3j0higk0t8
+      - 0c9mhqpih5imb
     status:
       code: 200
       message: OK

openbb_sdk/providers/yfinance/tests/record/http/test_yfinance_fetchers/test_y_finance_cash_flow_statement_fetcher.yaml

@@ -5,7 +5,7 @@ interactions:
       Accept:
       - '*/*'
       Accept-Encoding:
-      - gzip, deflate
+      - gzip, deflate, br
       Connection:
       - keep-alive
     method: GET
@@ -13,82 +13,82 @@ interactions:
   response:
     body:
       string: !!binary |
-        H4sIAAAAAAAAANVdWXPbRhL+L3yWUDgGx/hNl12qciKVnWwetvIAkyMZGxLgAqBjJeX/vj0gQc7R
-        lACoh9G+uARamvk4+NB3N/6etcVKNKIuRDN79/esFs1m2c7e/fvv2Uq0ufyoeVp9qZbw0ezi4v7j
-        7PezWfu0FvI6L8tNvrxtmk1ezsXdw7X40s5+/3G2XbPNV2v4rSBOeOYHie+fwT8BC5nf/RiFHD7r
-        fkwY636GpdElJZpF3ua3i9m7MAmyEH6vgf/LW4AxC/2An/v8PPJnZ7M1fJNq8UsHcBaEP8FH801d
-        i3L+dFUt5Ie/fr6GD2uxrupWLP6VLzei++L5n7N3iceT6IafzR5WsOtMXl7Ofvw4e3770CfaPvAS
-        nwc3gd8DCBLP50MQBEQIQs+PeKQgCH0vGoQgJELAPRYe7oC8krv/LvcfSsj7TT3/mjfAnstNU5Si
-        aUhIiSxrEDOIXRHzPPFCdpP1x3KehMzz/Z+s+2IhIOPmeeDFAGF/Z7prmxg2ACpqnkdedJPut4+i
-        gQdARUzY30+UWxD5yQ7BKHJefc3LR3Fb3pbfRNlW9RMJN+1VdWr6EXNGzdDLuHIuYcaxO2MjoKRm
-        mCoIgjAdiICMm6GXqGKru7YeDgQAFTkDj2XKwykvR4vNa7GuxbzI26IqL8rFxQr2Kf7qLkk4+tz6
-        BlsT3xVbgSoxS1UVG3pxbN8qCwGhkg/8OFERBCBYhiCgYisgCIEtGoIwG4KAjq5B4BsIAn80Yz/n
-        S9DGUuY17QrkHglNrUUNJR86U/Lcy9JQPRWeeSmiYy0EhNwMfZaB/RccHg9/J0tewkDHTj8xMICm
-        HYaBip+Jl0aJagYnqRclo/n5s2jv2q+ifl+U4M0U5SOo6fpR0JijRxc3+Jq41Pw81LUeR+hqAaBT
-        /JGXJsr+8nLI/mRqP/GSLFYAyOshAMhs0sSLskgDEI1X/LdlK8Dvb+/zYvF5s14vhZR7oLDhK9C4
-        889tYDr3zlR/BL6kclbRzrU8e357MrJKfyVUt/f9IdvTefZJlh62h0vMrXem8cFJSGJ1+ywdr+7b
-        av7HJXjgi6tqtRZlQ2ebHlna4GbqMPDkJ5kaePJT++5Y25NxM/GykKvbZ9GQ7am4mXrcV+Q4XAZD
-        tqcLOflRpsacfDaam70D3qnkq27v9qJpREuj7J9Z3uAoS1xxFIzR6OBlZykegLH2p9P23Isz5T7J
-        a0SG2QDI1H0GzFDtnWzHlJcAEKp7xrmm7uPxXhMYjrflvFqJ93W1uqrKtig3YD7eAbZO6pGZpy/s
-        Yvj87hR/7MWh5nHHsRciHrc73R97KQvUwH6cesyWcQgCKu5yj4GCUVxLhpmqCAA6IQsUUl0qDu7u
-        JPJ+/grL/yLqlcwN9ZkiKs7iixtUTd3F+WOPp4qZJq+R22QBoBSyiSLlz3mCinkEAaH/rzqV8nLI
-        AVDxNPJ4HKtmOh/v91/l6wLcm5vvYEkuinZT09ATWdYgpu+OmHAfGI+V5/c88EEb2bfGwkDHzdSL
-        fFX9wTUiRG0AZAaAjFJm+iEEWIYWwUBmA8CGqZ8ZNyINxpO0Wq2qsnN8rotvxQI4Jf1zGqYeWduw
-        VWN3oakA9GvAtVNiXoA4/BYGyrQU87PAwOAjASIbAyFjGUtSAwNDnEsbAyFjWcbMc8jG+1g727F8
-        vMqbr++X1Z8kXLVXNYRq4Iyliccjrd4j4Vi1hY2AjKPgwSSpmnLIfC+x2YEgIFT3TLrfarifYX4V
-        goEuHRWGQRxoaY/QC+IJKdQHAbsufsm/E6VMD+sZrIxTZ7Iz8tRSk4j5qAVoAaATnPLs1YqCIB6I
-        gExsMi9N1WIXeW0z0gZAxcgMrFAl1sLj15SaXMzn1aZs7/On/MuSyBTFlzY4GjqLl4JO4Wowv7u2
-        b5AFgI6jIKOSUGMIlsS3AdDJzTAKE72QIbKjtggCwko9poVN2XiBueVRsyfSJzEXxTfJJcq4Kb6+
-        YYxGzgRqCCdzeJhDhkoze3/C6D4PUq2qFbGD7e0JbVA/CE3XEbPFbQyENmhmyItsfGFpr463gU1q
-        JX9Y1VT1zkL6Q1W9u5j+UFXvLqg/UNU7C+qTqPqPVfnoJCSKLmzwk/N/sh7f3v7U9fgIghPX4yMI
-        qOgZe0xN3MvLKUF7ZwQ9trYZso8cmqKZlhUMdrGNs+cBEBaWsEQrLGHIQ2JvT1hNmrBIr+XEip9t
-        BGTKHWzvNNNt8fFVUDJhuSMPuDOyQKkh7Gg6vrpJVHc+U+plgR4+z7DUijOfKdSz1+Euef3S9oQe
-        U5LEuseUYI+KM49JNipEWqNCNEXZd6n1FhybQvoxfVvSRbmQpcvA1jFrfRLrfVvTLr/Uhe1JSH90
-        cbPmz10eQFZkci3+nYAVgVXeucsDpHDXYy1jk4a7cuKXMBCWrsQ81WLwmUw1D8FAxn6wdJkfahi4
-        x8bXAPSBer2yZFuxDz9czNviW9EWVCGEwbuZyVhnZjHz4oyrsR8WY5y2EVCGv8KMayo3xNKgzgxj
-        mVSKWWwklWLE7rAxkBE6lA+2mj05D+HBnhoF21X3/VbVf3TZqE5e0lcPGuub5YOZyxbWWGthxeNg
-        FgJC+0OmYxX7A8vF2tvT2R+J2q0QoL0C9vZUbGUe2Mj742dp9pqUgps4rb6uIU6Zs9qWyAvUGwOX
-        SMmVtT1hDpYp0dkMy84ju1MKUj/MzCoFJJNgYyATpNyLWKRV9kbTS7AdCtBnZacfu4sxgFOvlT5H
-        aOmVBYCwgDXhahAIaR5BdieM0fIg0KwNpEMAAUBYIKAK7nC8zboP7jtssnpuB7OTxZltKsdCaK2T
-        AVpsbSMg4yr3Yj9Q85JImAHZni5kG0dajSDYOdgIFRsBHVt5nGq3AM5gfLuV1q+vNOvD50vhZioA
-        uos5GyD4x2cDmAhOPxvAQnDy2QAWgjc2G6Bvj9476rtSANLea2txs/faaT22FvMOUG/GAkAZ1eKB
-        4s6lPEDdORsB4UCgOFSz13E4EAFhPNe4B+mE7uv9rLNXxV+R2WnPhlydSVGZZTjclTTDaWHtT+hO
-        KW5ulqEVDcj2hALUj1VjcZrs6keM2dF9Eul1bHlzoJm7ypOhA83clZ4MHGjmrvJk2EAzd92kNAPN
-        DmPxlKTUyCzUYY37+xviYX1yRZPWLutSh7VJ2RhO3CaFADh5mxSC4c21SR3G61A2ndirmk0n7ijK
-        4VakqpNxzn20y9QhRTMvyfRMYIIWIzgkKfeiKI60Y4h2yZuXMBCSNPBTxpXGE3hSgKavTCHtBkR8
-        LPIvxZIwE/rCHmYqyV2HCvNSvWITifBY2xNamDxI1Ig9Vk9tb0/F3NhLuRaMzQZ9e7qCQCCJFguO
-        XtN7OrkYEGs2PVqh6iyrOcjbsfc/qbeDbP+WvJ33tRC0ylVd0PR7nUVk4DnUizLiDC80chaSATsv
-        0grc0ggvM3IWkuFeyDWdykOP2yoVQUAZPWRMmx4ZyB7oyQp119rWyIm183m9EYtu/kJD20d3fBcz
-        C+4sbjOwpc4CcOqWOhvAqVvqbARvqaWuqw7th9c6Ch8d38D0tJ0pXmn2aJ0RIG5RF9OZ6o2lA6Ea
-        QghXkO0Jw0d+Gms1AVgGwAZAWLURJ1rRRjxhVM7BeOvr4qknkOzXNQeOuSx1G1Z1bGM4fdUxguHk
-        VccIhv+TquP99JCTVB1ju5mBI2dj9AZPK3E2Rm/wtBKHo/MHTytxODyfaFrJJ7HeikbCPidzTdP9
-        clciB56w6op214jn4axEDuzlKOaaoAkidEKpjYFQ4Kb6GaSY9+WuEw9sAKOQMx7veqkZJdJXO6AL
-        mxarM/nZ+TORpg2Zv4uenT2PgZKkIDpYpkec4530eAkF5UQIHsc6Cr+3H19CQUbW1Eukx6taSP1s
-        jFF8HTiQFJk6PmDYaOA78zYpRl1eiseiLHeJrPuqKcgKA/GVTWvHWTgvBNEdRHoZJ1Z07O6Na7Ec
-        hKpaO7EPmn8IAqrnFBiRZuoQxYh7KWbxOZzGCipVQwB3YXy+QXvQjvuZe2riT+gxR5K7C4kdncY7
-        2nXp53A2dEM+rVXNBkh3CcCh4z1tDKcf74lgOPl4TwTDmxvveSimpUwG2auaKsSZSzK0TddCcOo2
-        XRvA6dt0bQxvrk33plyQWznmmiY5nRVgDrYunBVgDrYunFVgHrcuXkJA91okJuf9K1Ym25ViEcQm
-        90VmJ4lNYruZBoG7iPvgojYLw+mL2mwIpy9qszG8waI2dbAXaXYIXdi06t0FggaFKm0ApC9MTkLd
-        fA6xSBSC4aShSmT/txWq/Fm0FLVsR9LsAyrbUnf1IIknuw+MJCbmY1kYKJOYAUv1JGaAvQsWwUBI
-        VJYl2jlkbPf6wpcwvLkkJpDq/v7GUVUIsrIZXHfWdj6i8cLdUKSBjRcuhyINbbxwNxSJ7P00emmc
-        i3I7q7jOncofWFznTuUPLK5zmDkfWFzn8A10hPPqpQ9EO6G+W9F8gYLLmfSR9kZCcDyxl2lZCCiN
-        UJ9FlsRGQkM2BsIaukx/gXiGvcTBZezU53FonAEfz8uuJefnqiPRbStWNG6Svao538Blf7DW3J8c
-        a+53+brZVGnP5enA/SlDp6k6LJYNRUBZS38AIOvoJ+Se1Pe/Xb2/G9kY3CtsZbhRbw2MSy1sX0C/
-        HS8nJgDZ9rzBc3Cx+M9mWzlyt2kb+GpbiEWvEcYs+mtZi3xZ/CUWH/Ki/Fg1zV15qEz5LOBe9VG7
-        McvCMYnmk3jY7N/oN+mb9oGRh7pa4WWOY5bt3lZ9u1rnRS1XhVOrH8fexu3Zw2mJ6rHO11+fPotH
-        udj1dobWuIip+S7NT7tnYORC0u+pd2/wMIMAo7qgqloUj6X0msYerTqQadSd7m+qZF8j6Td66y4U
-        DPy4Lpr5NhIsFq/nSi8zpj+uV8tcfpvqQQLslllTEVl59ZXeDTSu9PIA6UP1TdSl5PGHOt9GOKcc
-        VnM4rdux4xfq6lvRAIHycvEbiBxx9/BQPexfXz+q0gL4209xmHKqB3UxRc7DF5kLsWgkJbuH8W4t
-        n4ub76KeF83oZ1tjkRKAHn8g/byVqbKYlsKIMrstX6nLdCFovFF2+kITT73/s6q8FF/zJbD5ZrVe
-        Vk9ivN5SZtLdPUzWyT2/J5swOo7po1ZAX+1UzdXOErz5Pu/A9TbIxKNuq27oZCHq5qGqP1TVogFx
-        8lnU34r5aJS2wTZWph0sqqkiidQm67/QRDNYybgiqna05u/X6+TJBgRjUSJS5bqoxbwlsAjw0fxT
-        2a+UB43iKahpOWOyXPSi4FKU4qFop2nwLaumP4cmwycdtqX7J61y8/AAf3T30AuCT+BJHqYlvvbm
-        41UI05zA/hmaIkBv8lpWE+/sXIny5r+bon06PNzTVLvSC1tX8BBN+IKqdr8ChQyubj12DVPeTbQ4
-        tILOaZxUBrpOvNFgAoCfuJhkgF5XMuZVzKc4UrqQfv+Kv550ciR+JNbjMpmYIBGAQmCz7ETl3q6+
-        hB0WV9VKSs4pd9oIUUw6Lr0Pff8VkfchwZ/CuVb17F25WS5//Pgfi6bmjfWgAAA=
+        H4sIAAAAAAAAANVdS3PbRhL+LzxLKDwGj/FNlmSXqpxIZTubw5YPMDmUsSEBLgA6VlL+79sDgeQ8
+        mhIA9TDaS0pgzJmPmA/97sbfs7ZYi0bUhWhmb/6e1aLZrtrZm3//PVuLNpcfNQ/rr9UKPppdXNx9
+        mH05m7UPGyGv87Lc5qubptnm5VzcLq/E13b25efZ45ptvt7AvwrihGd+kPj+GfwnYCHzuz+jkMNn
+        3Z8JY93fsDS6pESzyNv8ZjF7EyZBFsK/a+D/5S3AmIV+wM99fh75s7PZBn5JtfjcAZwF4S/w0Xxb
+        16KcP1xWC/nhb5+u4MNabKq6FYt/5aut6H54/ufsTeLxJLrmZ7PlGnadycu3s58/z57ePvSJtg+8
+        xOfBdeDvAASJ5/MhCAIiBKHnRzxSEIS+Fw1CEBIh4B4LDycgr+TuX+T+Qwl5t63n3/IG2PN22xSl
+        aBoSUiLLGsQMYlfEPE+8kF1nu9tynoTM8/1frHOxEJBx8zzwYoCwP5nu2iaGDYCKmueRF12n++2j
+        aOANoCIm7O8nyhFEftIjGEXOy295eS9uypvyuyjbqn4g4aa9qk5NP2LOqBl6GVfuS5hx7GRsBJTU
+        DFMFQRCmAxGQcTP0ElVsddfWw4EAoCJn4LFMeTjl5WixeSU2tZgXeVtU5UW5uFjDPsVf3SUJR59a
+        32Br4rtiK1AlZqmqYkMvju2jshAQKvnAjxMVQQCCZQgCKrYCghDYoiEIsyEI6OgaBL6BIPBHM/ZT
+        vgJtLGVe065B7pHQ1FrUUPKhMyXPvSwN1bvCMy9FdKyFgJCboc8ysP+Cw+Ph97LkOQx07PQTAwNo
+        2mEYqPiZeGmUqGZwknpRMpqfv4r2tv0m6ndFCd5MUd6Dmq7vBY05enRxg6+JS83PQ13rcYSuFgA6
+        xR95aaLsLy+H7E+m9hMvyWIFgLweAoDMJk28KIs0ANF4xX9TtgL8/vYuLxaftpvNSki5BwobfgKN
+        O//UBqZz70z1R+BLKvcq6l3Ls6e3JyOr9FdCdXvfH7I9nWefZOlhe7jE3HpnGh+chCRWt8/S8eq+
+        reZ/vAUPfHFZrTeibOhs0yNLG9xMHQae/CRTA09+ap+OtT0ZNxMvC7m6fRYN2Z6Km6nHfUWOw2Uw
+        ZHu6kJMfZWrMyWejublzwDuVfNnt3V40jWhplP0TyxscZYkrjoIxGh287CzFAzDW/nTanntxppyT
+        vEZkmA2ATN1nwAzV3sl6pjwHgFDdM841dR+P95rAcLwp59VavKur9WVVtkW5BfPxFrB1Uo/MPH1m
+        F8Pnd6f4Yy8ONY87jr0Q8bjd6f7YS1mgBvbj1GO2jEMQUHGXewwUjOJaMsxURQDQCVmgkOpScXB3
+        J5H30zdY/rOo1zI3tMsUUXEWX9ygauouzh97PFXMNHmNHJMFgFLIJoqUP+cJKuYRBIT+v+pUyssh
+        N4CKp5HH41g10/l4v/8y3xTg3lz/AEtyUbTbmoaeyLIGMX13xIRzYDxWnt/zwAdtZB+NhYGOm6kX
+        +ar6g2tEiNoAyAwAGaXM9JsQYBlaBAOZDQAbpn5mHEQajCdptV5XZef4XBXfiwVwSvrnNEw9srZh
+        q8buQlMB6NeAa3eJeQHi8FsYKNNSzM8CA4OPBIhsDISMZSxJDQwMcS5tDISMZRkz70M23se6EksB
+        uy4+5z+IElKH9QxBGqfOmBl5aiI/Yj6qXy0AdLQMvSBW87VBPBABGSmZl6ZqKYG8tmWoDYCKkRno
+        eMWT5fGURH7vyZT3l3nz7d2q+pOEk/aqBjMDZzIz8XikVR8lHKv9sRGQURP86SRVE2CZ7yUIM2wE
+        hMYnk8EgNfnEMC8fwUCXHA3hmQy0JJx8ZifHpC7m82pbtnf5Q/51RWSK4ksbXA2dxUtBp3A1mN9d
+        24dkAaCTosCKJNRkGJbEtwHQMTWMwkQvZIjsqC2CgLBSj2lhUzaVos2eSB/FXBTfJZco46b4+oYx
+        GjlT+SHcmYO6CRmqb+39CaP7PEi1qlbEDra3J7RB/SA0XUfMFrcxENqgmSEvsvGFpTuD8TGwSW2G
+        HlY1jVFnIf2hxqi7mP5QY9RdUH+gMeosqE9ijH6oynsnIVF0YYOfnP+T9fj29qeux0cQnLgeH0FA
+        Rc/YY2riXl5OCdo7I+ixtc2QfeTQFM20rGDQxzbOngZAWFjCEq2whCEPib09YTVpwiK9lhMrfrYR
+        kCl3sL3TTLfFx1dByYRlTx5wZ2SBUkPY0XR8dZOo7nym1MsCPXyeYakVZz5TqGevwz55/dz2hB5T
+        ksS6x5Rgj4ozj0k2KkRao0I0Rdl3qfUWHJtC+jG7tqSLciFLl4GtY9b6KDb7tqY+v9SF7UlIf3Rx
+        s+bPXR5AVmRyLf6dgBWBVd65ywOkcOqxlrFJw76c+DkMhKUrMU+1GHwmU81DMJCxHyxd5ocaBu6x
+        8TUAu9CoXlnyWLEPf1zM2+J70RZUIYTBu5nJWGdmMfPijKuxHxZjnLYRUIa/woxrKjfE0qDODGOZ
+        VIpZbCSVYsTusDGQETqUD7Yarz4P4cGeHqjtqvt+r+o/uvh/Jy/pqweN9c3ywcxlC2ustbDicTAL
+        AaH9IdOxiv2B5WLt7ensj0TtVgjQXgF7eyq2Mg9s5P3tZ2n2ku5VN3FafV1DnDJntS2RF6gHA5dI
+        yZW1PWHWiynR2QzLziO7UwpSP8zMKgUkk2BjIBOk3ItYpFX2RtNLsB0K0Cdlpx+7izGAU6+VPkdo
+        6ZUFgLCANeFqEAhpHkF2J4zR8iDQrA2kQwABQJiSVQV3ON5m3Qf3HTZZPbWD2cnizDaVYyG01skA
+        Lba2EZBxlXuxH6h5SSTMgGxPF7KNI61GEOwcbISKjYCOrTxOtSOAezC+3Urr11ea9eHzlXAzFQDd
+        xZwNEPzjswFMBKefDWAhOPlsAAvBK5sNsGuP3jvqfSkAae+1tbjZe+20HluLeQeoN2MBoIxq8UBx
+        51IeoO6cjYBwIFAcqtnrOByIgDCea5xBOqH7ej/r7EXxV2R22pMhV2dSVGYZDqeSZjgtrP0J3SnF
+        zc0ytKIB2Z5QgPqxaixOk127EWN2dJ9Eeh1b3hxo5q7yZOhAM3elJwMHmrmrPBk20MxdNynNQLPD
+        WDwlKTUyC3VY4+7umnhYn1zRpLXLutRhbVI2hhO3SSEATt4mhWB4dW1Sh/E6lGX+9qpmmb87inI4
+        ilR1Ms65j3aZOqRo5iWZnglM0GIEhyTlXhTFkXYboj558xwGQpIGfsq4UuoPTwrQ9IUppH5AxIci
+        /1qsCDOhz+xhppLc9VAxL9UrNpEIj7U9oYXJg0SN2GP11Pb2VMyNvZRrwdhs0K+nKwgEkmix4Ogl
+        vaeTiwGxZtOjFarOspqDvB17/5N6O8j2r8nbeVcLQatc1QVNv9dZRAaeQ70oI87wQiNnIRmw8yKt
+        wC2N8DIjZyEZ7oVc06k89LitUhEElNFDxrTpkYHsgZ6sUPvWtkZOrJ3P661YdPMXGto+uuO7mFlw
+        Z3GbgS11FoBTt9TZAE7dUmcjeE0tdV116G54raPw0fENTE/bmeKVZo/WGQHiFnUxnaneWDoQqiGE
+        cAXZnjB85KexVhOAZQBsAIRVG3GiFW3EE0blHIy3XV089QSS/brmwDGXpW7Dqo5tDKevOkYwnLzq
+        GMHwf1J1vJ/XcJKqY2w3M3DkbIze4PkQzsboDZ4P4XB0/uD5EA6H5xPNh/goNo+ikbDPyVzTdL/c
+        lciBJ6y6ot014nk4K5EDezmKuSZoggidUGpjIBS4qX4PUsz7cteJBzaAUcgZj3e91IwS6asd0IVN
+        i9WZ/Oz8mUjThszvo2dnT2OgJCmIDpbpEee4lx7PoaCcCMHjWEfh7+zH51CQkTX1EunxqhbSbjbG
+        KL4OHEiKTB0fMGw08J15mxSjLt+K+6Is+0TWXdUUZIWB+MqmteMsnBeC6A4ivYwTKzp298a1WA5C
+        Va2d2AfNPwQB1XMKjEgzdYhixL0Us/gcTmMFlaohgFMYn2/QHrTjfuaemvgTesyR5O5CYken8Y52
+        XXZzOBu6IZ/WqmYDpLsE4NDxnjaG04/3RDCcfLwnguHVjfc8FNNSJoPsVU0V4swlGdqmayE4dZuu
+        DeD0bbo2hlfXpntdLsitHHNNk5zOCjAHWxfOCjAHWxfOKjCPWxfPIaB7LRKT8/4VK5P1pVgEscl9
+        kdlJYpPYbqZB4C7iPriozcJw+qI2G8Lpi9psDK+wqE0d7EWaHUIXNq16d4GgQaFKGwDpC5OTUDef
+        QywShWA4aagS2f91hSp/FS1FLduRNPuAyrbUXT1I4snuAyOJiflYFgbKJGbAUj2JGWDvgkUwEBKV
+        ZYl2HzLWv77wOQyvL4mp1xu5qGGyKpbcydGBFUvu5OjAiiWH6ciBFUsOX+tFUrF0d3ftqFQJWdnM
+        +DibhTCiG8jdpK6B3UAuJ3UN7QZyN6mL7KVJu3ny0geinVDfrWi+QMHlTPpIeyMhOJ7Yy7QsBJRG
+        qM8i6+FAQkM2BsIaukx/gXiGvcTBZezU53Fo3AM+XoR2LTm/Vh2JblqxpnGT7FXN+QYu+4O15v7k
+        WHO/y9fNpkp7Lk8H7k8ZOk3VYbFsKALKWvoDAFlHP6U9uK7mQiwaGSzqPJnbjQx0Xv8Q9bxoxGJk
+        p/DuVfKPg+LE4vLd7cgVpE1Q969cML220TE3+FFXRTN/DILJVzhgM0hHZSrBQLld7trzx/+0d1Ut
+        ivvysj/l6x/zTr+8z4vyQzV6QeU1P3rnw0uO7KqoxbwdPacYvrxpmyXc8ffVd1GXMmjzvs4fQ0JT
+        5xpN7lNXKuDrCh6zCUdtv87zY/8Yjlzoc/5DNB/Fcrt/g+OYb++ocVu+iHvANPgSQHkrSrEs2v3z
+        /hbu1+KyWkvqTLnn9hN/M/7A9wOrprBfmay285rHLNO9p/1mvcmLWvIFVq3vx67xeDSPwxHGf2/6
+        YAZ1Itft8pMA7TFFqqnLKNnd0RaO/K4qCfDq6ynskg/OeF2C6QA86zIpSANqGWB1/Bkt5HaFGdMf
+        GxBs34sGTiwvF7/DsQORltVyEhpTxown8o413bFvQaIUJXL4k1SLToF3Y+9Snz5oq27mYiHqZlnV
+        76tq0cB9+yTq78V8ohVAoGP05/cFA1r6X1mVb8W3fAU8uF5vVtWDGL2SoawmndhVJf2aYi5v0+hf
+        QmH76YsYr0+epmJ2HJyiYVSReLkFKq6BhRMFxjRBeJ3XslSzkQ+56Gz96/9ui/bhQOEXC7BJTOnN
+        4SlE2YsXKbz6HzbxdA/3dsrp7jXf7iGk0XxqFl/VX/3Ko60lvS10L7Be9nqS6+USDv12ufNjPoKT
+        exjkOIlPk6XOQYkdfudki0hVOpPQ7Lg12Sy9A3tczlwtFztR3lvu07y8y1Uun5BqqTJ1KtMvFv/Z
+        Pt7gGwC56I+82EVdp5z79IDBIxixeC+q+zrffHv4JO4ltKvHyc3T9cbEu/RbWYt8VfwFiCgZqR0g
+        rZGNnOvttn3hwWK29xGo8F2461U9e1NuV6ufP/8HH9R+qvWgAAA=
     headers:
       Age:
-      - '0'
+      - '3'
       Connection:
       - keep-alive
       Expect-CT:
@@ -112,21 +112,21 @@ interactions:
       content-type:
       - application/json;charset=utf-8
       date:
-      - Tue, 19 Sep 2023 20:25:12 GMT
+      - Tue, 26 Sep 2023 12:12:59 GMT
       server:
       - ATS
       vary:
       - Origin,Accept-Encoding
       x-envoy-decorator-operation:
-      - finance-company-fundamentals-api--mtls-production-sg3.finance-k8s.svc.yahoo.local:4080/*
+      - finance-company-fundamentals-api--mtls-production-ir2.finance-k8s.svc.yahoo.local:4080/*
       x-envoy-upstream-service-time:
-      - '61'
+      - '39'
       x-request-id:
-      - 358e385d-0006-468b-a4ab-c9747d51c4a0
+      - 9ae9fdd3-b449-4533-9dc9-6401ad1ef50e
       x-yahoo-request-id:
-      - 7onpp41igk0t8
+      - 5qfqqkhih5imb
       y-rid:
-      - 7onpp41igk0t8
+      - 5qfqqkhih5imb
     status:
       code: 200
       message: OK

openbb_sdk/providers/yfinance/tests/record/http/test_yfinance_fetchers/test_y_finance_futures_historical_fetcher.yaml

@@ -5,17 +5,17 @@ interactions:
       Accept:
       - '*/*'
       Accept-Encoding:
-      - gzip, deflate
+      - gzip, deflate, br
       Connection:
       - keep-alive
     method: GET
     uri: https://query2.finance.yahoo.com/v8/finance/chart/ES=F?interval=1d&range=1d
   response:
     body:
-      string: '{"chart":{"result":[{"meta":{"currency":"USD","symbol":"ES=F","exchangeName":"CME","instrumentType":"FUTURE","firstTradeDate":969249600,"regularMarketTime":1695311200,"gmtoffset":-14400,"timezone":"EDT","exchangeTimezoneName":"America/New_York","regularMarketPrice":4401.5,"chartPreviousClose":4447.0,"priceHint":2,"currentTradingPeriod":{"pre":{"timezone":"EDT","start":1695268800,"end":1695268800,"gmtoffset":-14400},"regular":{"timezone":"EDT","start":1695268800,"end":1695355140,"gmtoffset":-14400},"post":{"timezone":"EDT","start":1695355140,"end":1695355140,"gmtoffset":-14400}},"dataGranularity":"1d","range":"1d","validRanges":["1d","5d","1mo","3mo","6mo","1y","2y","5y","10y","ytd","max"]},"timestamp":[1695311200],"indicators":{"quote":[{"low":[4395.0],"close":[4401.5],"volume":[993779],"open":[4445.0],"high":[4447.0]}],"adjclose":[{"adjclose":[4401.5]}]}}],"error":null}}'
+      string: '{"chart":{"result":[{"meta":{"currency":"USD","symbol":"ES=F","exchangeName":"CME","instrumentType":"FUTURE","firstTradeDate":969249600,"regularMarketTime":1695729778,"gmtoffset":-14400,"timezone":"EDT","exchangeTimezoneName":"America/New_York","regularMarketPrice":4363.5,"chartPreviousClose":4378.75,"priceHint":2,"currentTradingPeriod":{"pre":{"timezone":"EDT","start":1695700800,"end":1695700800,"gmtoffset":-14400},"regular":{"timezone":"EDT","start":1695700800,"end":1695787140,"gmtoffset":-14400},"post":{"timezone":"EDT","start":1695787140,"end":1695787140,"gmtoffset":-14400}},"dataGranularity":"1d","range":"1d","validRanges":["1d","5d","1mo","3mo","6mo","1y","2y","5y","10y","ytd","max"]},"timestamp":[1695729778],"indicators":{"quote":[{"close":[4363.5],"high":[4382.0],"volume":[201094],"open":[4382.0],"low":[4344.0]}],"adjclose":[{"adjclose":[4363.5]}]}}],"error":null}}'
     headers:
       Age:
-      - '1'
+      - '0'
       Connection:
       - keep-alive
       Expect-CT:
@@ -33,25 +33,25 @@ interactions:
       cache-control:
       - public, max-age=10, stale-while-revalidate=20
       content-length:
-      - '884'
+      - '885'
       content-type:
       - application/json;charset=utf-8
       date:
-      - Thu, 21 Sep 2023 15:56:39 GMT
+      - Tue, 26 Sep 2023 12:12:58 GMT
       server:
       - ATS
       vary:
       - Origin,Accept-Encoding
       x-envoy-decorator-operation:
-      - finance-chart-api--mtls-production-sg3.finance-k8s.svc.yahoo.local:4080/*
+      - finance-chart-api--mtls-production-ir2.finance-k8s.svc.yahoo.local:4080/*
       x-envoy-upstream-service-time:
-      - '3'
+      - '2'
       x-request-id:
-      - f2c31509-0b1d-46ea-ada0-f23aa55a3a6d
+      - 7dbae154-1c52-40db-a974-c783d6c9d5bc
       x-yahoo-request-id:
-      - 45o2061igopto
+      - 4itskcpih5ima
       y-rid:
-      - 45o2061igopto
+      - 4itskcpih5ima
     status:
       code: 200
       message: OK
@@ -61,17 +61,17 @@ interactions:
       Accept:
       - '*/*'
       Accept-Encoding:
-      - gzip, deflate
+      - gzip, deflate, br
       Connection:
       - keep-alive
     method: GET
     uri: https://query2.finance.yahoo.com/v8/finance/chart/ES=F?events=div%2Csplits%2CcapitalGains&includePrePost=False&interval=1d&period1=MOCK_PERIOD_1&period2=MOCK_PERIOD_2
   response:
     body:
-      string: '{"chart":{"result":[{"meta":{"currency":"USD","symbol":"ES=F","exchangeName":"CME","instrumentType":"FUTURE","firstTradeDate":969249600,"regularMarketTime":1695311200,"gmtoffset":-14400,"timezone":"EDT","exchangeTimezoneName":"America/New_York","regularMarketPrice":4401.5,"chartPreviousClose":3846.0,"priceHint":2,"currentTradingPeriod":{"pre":{"timezone":"EDT","start":1695268800,"end":1695268800,"gmtoffset":-14400},"regular":{"timezone":"EDT","start":1695268800,"end":1695355140,"gmtoffset":-14400},"post":{"timezone":"EDT","start":1695355140,"end":1695355140,"gmtoffset":-14400}},"dataGranularity":"1d","range":"","validRanges":["1d","5d","1mo","3mo","6mo","1y","2y","5y","10y","ytd","max"]},"timestamp":[1672722000,1672808400,1672894800,1672981200,1673240400,1673326800],"indicators":{"quote":[{"low":[3814.5,3836.5,3822.5,3819.0,3909.75,3891.5],"high":[3906.75,3896.25,3885.5,3928.75,3973.25,3943.75],"close":[3846.0,3874.5,3829.0,3915.5,3913.75,3940.75],"volume":[1782473,1912155,1679973,2026154,1697887,1520955],"open":[3895.0,3842.75,3871.0,3833.0,3918.5,3914.5]}],"adjclose":[{"adjclose":[3846.0,3874.5,3829.0,3915.5,3913.75,3940.75]}]}}],"error":null}}'
+      string: '{"chart":{"result":[{"meta":{"currency":"USD","symbol":"ES=F","exchangeName":"CME","instrumentType":"FUTURE","firstTradeDate":969249600,"regularMarketTime":1695729778,"gmtoffset":-14400,"timezone":"EDT","exchangeTimezoneName":"America/New_York","regularMarketPrice":4363.5,"chartPreviousClose":3846.0,"priceHint":2,"currentTradingPeriod":{"pre":{"timezone":"EDT","end":1695700800,"start":1695700800,"gmtoffset":-14400},"regular":{"timezone":"EDT","end":1695787140,"start":1695700800,"gmtoffset":-14400},"post":{"timezone":"EDT","end":1695787140,"start":1695787140,"gmtoffset":-14400}},"dataGranularity":"1d","range":"","validRanges":["1d","5d","1mo","3mo","6mo","1y","2y","5y","10y","ytd","max"]},"timestamp":[1672722000,1672808400,1672894800,1672981200,1673240400,1673326800],"indicators":{"quote":[{"low":[3814.5,3836.5,3822.5,3819.0,3909.75,3891.5],"open":[3895.0,3842.75,3871.0,3833.0,3918.5,3914.5],"high":[3906.75,3896.25,3885.5,3928.75,3973.25,3943.75],"volume":[1782473,1912155,1679973,2026154,1697887,1520955],"close":[3846.0,3874.5,3829.0,3915.5,3913.75,3940.75]}],"adjclose":[{"adjclose":[3846.0,3874.5,3829.0,3915.5,3913.75,3940.75]}]}}],"error":null}}'
     headers:
       Age:
-      - '0'
+      - '1'
       Connection:
       - keep-alive
       Expect-CT:
@@ -93,21 +93,21 @@ interactions:
       content-type:
       - application/json;charset=utf-8
       date:
-      - Thu, 21 Sep 2023 15:56:40 GMT
+      - Tue, 26 Sep 2023 12:12:58 GMT
       server:
       - ATS
       vary:
       - Origin,Accept-Encoding
       x-envoy-decorator-operation:
-      - finance-chart-api--mtls-production-sg3.finance-k8s.svc.yahoo.local:4080/*
+      - finance-chart-api--mtls-production-ir2.finance-k8s.svc.yahoo.local:4080/*
       x-envoy-upstream-service-time:
-      - '5'
+      - '3'
       x-request-id:
-      - 3ec9768d-f778-4c28-93d2-a4b5e4a44c4b
+      - bb8c4bf3-b256-4fde-9bb4-f49d36757303
       x-yahoo-request-id:
-      - 3uh35g9igopto
+      - 1q5gtbtih5imb
       y-rid:
-      - 3uh35g9igopto
+      - 1q5gtbtih5imb
     status:
       code: 200
       message: OK

openbb_sdk/providers/yfinance/tests/record/http/test_yfinance_fetchers/test_y_finance_income_statement_fetcher.yaml

@@ -5,7 +5,7 @@ interactions:
       Accept:
       - '*/*'
       Accept-Encoding:
-      - gzip, deflate
+      - gzip, deflate, br
       Connection:
       - keep-alive
     method: GET
@@ -13,60 +13,60 @@ interactions:
   response:
     body:
       string: !!binary |
-        H4sIAAAAAAAAAM1dXXObuhb9L35ONUgCgfrmJm4nM22TSXruebjTB2rLKXMw5AJO09Ppf78bx7GF
-        pKRAthy/ZDCttVfQYu1PyK9Jk61UrapM1ZO3vyaVqtd5M3n731+TlWrS9lT9c/WtzOHUZDq9/Dj5
-        ejJpft6q9nNaFOs0/6ya82JertRpWTRZsS7X9cWtqtImK4t68vX3yYOJJl3dwpdoJGQSUBEEJ/CD
-        hiwMNoecSTi3ORRhuDkGS30stFgXaZOeLyZvWRDIEL5WXyzP0gZATlhA5ZtAvuHB5GQCX8rKxZcN
-        /Alln+DUfF1Vqpj/PC0X7cm/rs/gZKVuy6pRi/+k+VptLkv6Y/I2IhGLxIwGJ5PlCq7RJIoIE+8m
-        v3+fPI+ABWgI4pBSHUFMQtoHAUVCIEkoEg2ADIlI+gBgaACAPlxHIEkStAi+thj6kvZLej9bLtW8
-        uVj+VaxrOHPeqBUOXZ9au0vUkEpfRA3I7urAYWDujm0ZjaDDLWMRc7hlLEbalgcx8UrNy2Ke5Wpx
-        WtZAmSt1pwpYHoOJT63dZSKn3iSTEkHjhM0ofbxEVFAS24phY0DjJGCQUSQ7GCSJbOF2YMBiJyOU
-        yYRqGBhloGR9MGDxlBHGo1DoGBgnUTRYO3fu+H1VrrYuOStudi4Z/v1TVpRV1vw8LxoFIUWDGwYM
-        sGswndNXDg5sBIcODhwIDhscOAAcW3BQNmm+pVVx88C5aX21NYkTIzxvwggVeOSLtoJwqV8wwYnk
-        1pbZANBYK4hgiU4aIQiTfRBgsZaSIJFhxz8ECZFRHwxYxKWEypDHOgYKd1M4Jq69AnTvy+o0zedo
-        8WxnTTOOTfzFsTSCy5Lswysq7MDONI8YzNIwZAnTzIc9zONFtJTzgHHNPO9hHi+spQIMRMbFH8TG
-        d2mdzad3oHI36vp7Ch4ZhZCOZTuclEErJ74i2iSMYWN0V08TEsamXDhAIIa0MY8YSIQOIibc0iwX
-        CDzdFHFAWcx0EILEQR8QeMIpGIiE4F0QjA1Wzn2udKZuKzXPNjElchrWWdrMwrw5eUpYFMb6FWLb
-        uP/keQSIhKVBJzqm4HVdGZhHL09ZEnYRMFf+5dPH08BAQIcHp1oxdLUqi+umnP/zvcwXqkIvtlrr
-        m6VW/uqlVhPB4UutFoJDl1otAEeWTZ1l+RrWxg8DnAubgYC3hB8CgUhGImLdQEC43J+3nB8CgQgi
-        VBp2A4HISuFcIBADgUSEshuNCJJY96sLBGIgwFmUmCA4Hy+wuHJqiedrl6JsBIcXz1cuRTkAHJl4
-        zt6df0Hh4WahLgVp4q0D1a+sZAM4dFnJgeDgZSUHhqMrK30uq1WaZ/+qBaY0mouaCZF47WK9heDg
-        xXobwYGL9TaAI1PIXRF9dn+rihqHmtaihnIG3mqeHG5PoceUPISNskXDQoBGTQ6RW4cZHKJaq7zl
-        QoBFzZDwJNHrFSFgcoi3jQCLmxGhPIz025MSPqIa33Z5MBv6nQVNTnqreTLIamgc6p1jERDq4oS3
-        kicDwYxopGOIQxLZkunAgMVLTgRkGLo75SIiCeuDAYuZEEiFnCU6BlDuEWnOlapVWs2/T4vFGRAq
-        L29XqsBp1D+xtMHXyGNqLhiNXRXhk+cRIOblSWxWBmJH6GcjQJw4kZ2yAKNEOu4WGwHevIlgkR7i
-        MNiF4dMm+FNRz81CBdRbTbP3LJSN4fCzUA4MB5+FcmA4ulmoywr+4z1iUtRZ0FBM7i0hEiSKua6Y
-        ok1QbLWwECAm7HEgdbUQMQkcMZ+NADFhlyzoJMuBJMyhmTYGzISdtklRJ2Ef0SV6HIDDTIrMNQ3l
-        jGJ/OVEUi5ncBTwkcoiFZR4x9ExivjfffuxjHk8vBaQimnlhBxIO83hSKTnVzcvhsea2U/P5fHqX
-        ZnlTnpYr9L7ln2wYU0vstR8TsREcurjkQHDY4pIDwJEVl76k95dVeZfVWKMgnQUN9x56HAAJwkQn
-        BA1IaO+HjQCNkhL2fy8i0sUGh3U81x5GrJMQho4eqQsBnmPv9EPAqfPxTv0hOvxcFrsyJap/dyxv
-        uPrYG1NDIoXmbdqPtrOzzCPWPmPB9Ugj7mUez9UnYTfSsGNwh3k8V5+wTqSRvKB7Dj/z9QLIA0Sa
-        l0VTlXm+GXV/IBnysNIfrRm9pfDVe0sWgoP3lmwEB+4t2QCOzP3vO5Rt+/xsitz23C5qRqbe6vgx
-        ZBKx7gZj4QoDbARo1IxJzEO9KhnH277KnxDghQKwGO9k2CwgzPHMi40BLxjgQRTqFTDKAxIN7y9t
-        BuFnl9d4U/XtYsYIXeAtU4JcUrJIyyylNTBmGUd09XzfQoHjHqaxOBgREe+0GY57mMainiB0d8Hb
-        46GM+1CVdQ0ZzDLDaRXp6xlBpj8XDb6AS707IxPC7VqjjQCxDh+EMhKdWqM71vXnpCkEKgnvYIjc
-        Eac/P01JHBg9kTjY9kSGTYE031WlpywPYeG2VIkTbP7JhvlcHPM4ehzE+zgdPjqKO5Z5NPImBEKr
-        3UN5EGeRIPjUwz5elhQle/ssSnraxyLtG3AX4R7AG87DLYJBlL1WmxTlgyqATvm0WEwXq6zI6qbC
-        e/LoTzbMlry3gVDgKOsM1NBk2ww+eR4BouRKSUW3BiNdQwHeJkLblnzMjZa8Y4jGRoCX4EeB7AwF
-        RNsm23Cx7Ygfnr52lzX4Sb21mPpIqm3+sJLqsH9QSXXYPzJJNTwz7iiouycfvPYMvQXg4DP0NoLD
-        z9DbGI5vhr6tVeoVdrwKaGdV8zkjj10lnkS6ZrpyKMs8omZKTTJl4JIsh3k8bkpNMql0SqbDPppk
-        tk9Qa5JJAzFGMp94qVI7upnV84fParF7x5LPFzk9adOo3fuT3L61e3+a27d2709ze9bu/Qku9nMh
-        mKOj1qJmgOot5+8/g+8v8e8/g+8v+e8/g++vAIA2g4/YVXL2kqh87V6SjeDQvSQHgoP3khwYjq6X
-        5CE2fTYwpbG3ZL7PEIlt/qBDJA7zhxwicZg/piGSzWNuqLX77ooGE4XH999KwULda1MJSbRjQywM
-        iF47SBjTPSaDJNqlUjYGxPqSSITuMSHOds1ROzDgETMOE0mN6CUZXv405uC9zeG51jeSe3/M7TVz
-        75O0PWbuffK1x8y9T6q+fOYekuxur1L3xZhl+16GzAFSj4X8HkUpf76/V1HKn+/vV5Ty5/yRilLb
-        ZzmwJpu05czZJm+lJLhn485sk2PKx1sViROW7JWbJT1MI8427fxre9zDNOJs0850ezySdU/8GZtB
-        K2mv+ZyuAGr27+YYzueqPXgQx+sGrsH2qfvRNdsv6f3Hsq5P06r6uSyrH2m1GLjcLK0KEO66XW32
-        v3X3tf0Dn5YxoXTu5BGbsS8Iv2Q/rm/b3ci377X8nlY3augSu6d23pfVWbn+1izX+XQ+L9dFM3Sp
-        zaAlAsse3iHfNs3fZ0VazFX7YPvANZ6svmujpYPmA9OsuCiu01xdLC8vZwO/vfllzHfvjLosxh/1
-        GfJ9829IvNj+7H77bMKHslz8yPJ84ILbF1xu7gigyePtOnCV86JeVy1LYKNP8zQbfF10IRuzrx/S
-        YjF9AZ2uFfgC2JeBS1xtfcV+7H60Ju10d3bfVGlZwZ6m1VA8l5VaKvBpi83TqWfZXbZQxWLoZiD8
-        No93+HZzsqJuxXvw7bb5+lZgx0nr0/4HLvjFErzKULl/mHoDon9Kq39U9+Vgo/04sFe7A85f6MM3
-        Vx/Hu+25MFK0rwD+9gJdr28hRGl/n3SoTCEFNy0YuNYfQS1g396rcYRcFwtVuW+1McsBBwfj0Nly
-        sQRKp8VN9i1XNQJxXiJAj4LxgiU2GLbRD2wS3PbFzdB76wru72o9b0DTH25VBdJRFdM5KECdjXAy
-        4GazWo3ZqUdmXIKQtW+RfoGTereus0LVwxE8vMr6ZZd0559wdOV8dZtmVUvRi+VpepuBJEzBQQwO
-        iNzTx3dqnCZvw4BM1S8ISGCz0vZPngKmv9PhHuvJqHl8uqN5mpfpgyMJG+0WzMhp5EJ/w37BvbEc
-        KVTuEAX+O2h7WU3eFus8//37/0XuC6XKdgAA
+        H4sIAAAAAAAAAM1dXXObuhb9L35ONUhCAvXNTdJOZtomk/Tc83CnD9SWU+ZgyAWcpqfT/343DnEE
+        UlIgW45fMrZbay/EYu+1P8C/ZnW61pUuU13N3v6albraZPXs7X9/zda6TpqPqp/rb0UGH83m84uP
+        s69Hs/rnjW7eJ3m+SbLPuj7LF8VaHxd5neabYlOd3+gyqdMir2Zffx/dm6iT9Q18iQqp4oDKIDiC
+        PzRkYbB9yZmCz7YvZRhuX4OlIRYarMukTs6Ws7csCFQIX6vOVydJDSBnLKDqTaDe8GB2NIMvpcXy
+        yxb+jLJP8NFiU5Y6X/w8LpbNh39dncCHpb4pylov/5NkG73dluTH7K0gggl5SoOj2WoNezQTgjD5
+        bvb799HzCFiAhiAKKTURRCSkQxBQJASKhDI2AKiQyHgIAIYGAOjDTQSKxEGD4GuDYShpvyR3p6uV
+        XtTnq7/yTQWfnNV6jUPXp9buEjWkyhdRA7LbHXgZ9M+ObRmNoOMtYxFzvGUsRtqWRzHxUi+KfJFm
+        enlcVECZS32rc1geg4lPrd1lIqfeXCYlkkYxO6X0YYuopCSyPYaNAY2TgEEJoToYFBG243ZgwGIn
+        I5SpmBoYGGXgyYZgwOIpI4yLUJoYGCdCjPadu3D8vizWbUhO8+tdSIZ//5TmRZnWP8/yWoOkqHFl
+        wAi7PaZz+sriwEawb3HgQLBfceAAcGjioKiTrKVVfn3PuXl12ZrE0QjPm+hJBS580VYSrswNk5wo
+        bp0yGwAaayWRLDZJIyVhaggCLNZSEsQq7MSHICZKDMGARVxKqAp5ZGKgcDWFU3TtJaB7X5THSbZA
+        07OdNfs6NvanY6mAbYkf5RWVtrDrm0cUszQMWcwM8+EA83iKlnIeMG6Y5wPM48laKsGA6G3+KDa+
+        S6p0Mb8FL3etr74nEJFRCOlYtsNJFTTuxJeijcMITowZ6mlMwqjvLhwgECVtxAUDF2GCiAi3fJYL
+        BJ7flFFAWcRMEJJEwRAQeI5TMnASkndBMDbacz7mSif6ptSLdKspkdOwztL9LMxbkKeEiTAyd4i1
+        uv/oeQSIhKVBRx1TiLquDMxjlKcsDrsImCv/8hnjadBDQMeLU6MYul4X+VVdLP75XmRLXaIXW631
+        +6VW/uql1j6C/ZdaLQT7LrVaAA4smzpJsw2sjS8DnAv3hYC3hB+EgFBCCtYVAtIV/rzl/CAEBChU
+        GnaFgLBSOBcIRCEQy1B11YgksXW9ukAgCgHORNwHwfl0B4vrTi3n+dqlKBvB/p3nK5eiHAAOzHme
+        vjv7gsLD7UJdCtLYWwdqWFnJBrDvspIDwd7LSg4MB1dW+lyU6yRL/9VLTNfYX7SfEMnXLtZbCPZe
+        rLcR7LlYbwM4MA+5K6Kf3t3ovMKhprVoz3MG3mqeHC5PaWpKHsKJsp2GhQCNmhyUW4cZHFStVd5y
+        IcCiZkh4HJv1ihAwOZy3jQCLm4JQHgrz8qSET6jGN10ezIZ+Z8E+J73VPBlkNTQKzc6xDAh1ccJb
+        yZOBwxRUmBiikAjbZTowYPGSEwkZhhlOuRQkZkMwYDEThFTIWWxiAM89Ic251JVOysX3eb48AUJl
+        xc1a5ziN+ieW7vFVeEzNJaORqyJ89DwCxLw8jvqVgcgh/WwEiBMnqlMWYJQox9ViI8CbN5FMmBKH
+        wVkYP22CPxX13CxUQL3VNAfPQtkY9j8L5cCw91koB4aDm4W6KOE/3iEmRZ0Fex6Te0uIJBERNz2m
+        bBIU21tYCBAT9ihQpreQEQkcms9GgJiwKxZ0kuVAEebwmTYGzISdNklRJ2Gf0CV6GIDDTIr6a/Y8
+        p4j85UQikqdqJ3iIcDgLyzyi9Iwj/mi+eTvEPJ6/lJCKGOalLSQc5vFcpeLUNK/Ga822U/P5bH6b
+        pFldHBdr9L7ln2z0ppbYa98mYiPYd3HJgWC/xSUHgAMrLn1J7i7K4jatsEZBOgv2wnvocQAkCGOT
+        EDQgoX0+bARolFRw/h+diHKxwWEdL7SHgnUSwtDRI3UhwAvsnX4IBHX+gtEP+Jttlml+/bmA93ld
+        Flm2HSO+D9DIgyB/tNar24evXre3EOy9bm8j2HPd3gZwYK71gT73HANq7WruqGLVsXxPt0be3G5I
+        lDSkU/PWVm6WecRCfiS5KZujQebxdGscdmWznVA6zOPp1ph1ZHM8YRRk16Fs2ucnc+S2Z7toX5l6
+        q+NHkElEZhiMpEsG2AjQKBmRiIdmVTKK2r7KnxDgSQFYjHcybBYQ5rjnxcaAJwZ4IEKzAkZ5QMT4
+        /tKHsqgq0JOrFKdwb67X85L+gjpED67MWrmKCbcrPzYCxKpoECohO5Uft7P2F9YpSJuYdzAIt8v0
+        F9kpiYJehToK2gr1+Ps+Ti+u8O72aBbrjXYG3jJ4RpRiwqh4KGuQ0TKOGLX5Y2sPXg8wjcVBQWS0
+        07XweoBpLOpJQncb3rwePQVSf9elqfLudV9bqsRJiP5ko39fHPM4ehxEj9IG3jqKO5Z5NIbGBOT/
+        7qY8yAVIEHwaYB9PWIr40T4T8UD7WFx9A5dl+AjgDedhi2AUZa/0No3+oHOgUzbPl/PlOs3Tqi7x
+        7jz6k41+S97bQChwlHUGamjcNoOPnkeAGOSVorJbg1GuoQBvE6FNSz7ivZa8Y4jGRoCXE4lAdYYC
+        RNtkG+9sO84Pz792l+3xk3prMQ1xqbb5/bpUh/29ulSH/QNzqb3IjDsK6u7JB689Q28B2PsMvY1g
+        /zP0NobDm6Fv6ulmURKvSt9ZtX+fkceuEo+F6TNdWbtlHtFnKsNlqsDlshzm8bipDJdJldNlOuyj
+        uczmDmrDZdJATnGZTzxUqRndTKvF/Xu93D1jyeeDnJ602esv+XO5Q/tL/nzu0P6SP587sL/kz+Fi
+        3xeCOTpqLdoXqN5y/uEz+P4S/+Ez+P6S/+Ez+P4KAGgz+IhdJWcviarX7iXZCPbdS3Ig2HsvyYHh
+        4HpJHrTps8KURt6S+SF9d9v8XvvuDvP77Ls7zB9S3317mxtq7b67Yo+J0uPzb5VkoRm1qYIk2nFC
+        LAyIUTuIGTMjJoMk2uWlbAyI9SUZSzNigs52zVE7MOARMwpjRXvqJR5f/uzNwXsbXXKt30vu/TF3
+        0My9T9IOmLn3ydcBM/c+qYo2c4/VhTeW6/fhvaXjcNxRpw/v6Eh7y8Q5YfEj+1k8wDRiH37no5rX
+        A0wj9uF3ppvXE8pJ3Q65qQAxm0WDDPUnPT22jwaUQv0pzkGlUH+Kc1gp1J/kRCqFfknuPhZVdZyU
+        5c9VUf5IymXHiY5WsOavf5zetUP0H4pi+SPNspELztdw4Om/D0XYcXf65w9a4mpzc5Pp5m78ZCyA
+        x7FVY7pr3I3cTxR6J67Xf9Z/NfaA9M5b1GVSlHBykvLnyEW22B8Ppv/bR6O76sBBPemLH5J8OR/5
+        xZbdT/xu04SVcDbCcR1OpMjVTfOw3ax9nun3pLwevblXSZY0P44FnP07Gf/1k/Q2Xep8eaHL7QMq
+        p3K06ZQ49gXrEpzs57YnZr5YFJtmpWvY4/x67EF+SNL8PIeN1ueri4vTKZ52ewm8hws4X+jm8Q7T
+        6PsSR3DZRqYXu0kIFGmlp/gB8+HSzaiXETHO8nsaXdUQfNvnvIybVYNwnNbNdTA9Dp0mZQ4cqRou
+        n/5v0/15mHEPXWjvoHxflCfF5lu92mQtB8fumXk45yvAA/xNv2W6etl+dU6FYQI+z/T9CXnJ8u0j
+        b7e0hcUeNnbKtQsEbeNHmleNexlNO/PybXky9uJxzyfeGgnDyGdyrDSIx+X2/u8HDzz2sC6Bl+Vm
+        UcPxbN3lJw3Ro8znC2BulU6g//12o7qYyW4bYQmT4i9js6WVp+ifNtRPC/J/A2eBvauJYePFlxCS
+        Wzhb3yRp2XzxfHWc3KSwrXNAM9opmlf0u02V5rqadE42+VKX7qsRLXSAQjpfQbQcu1V5tSkbtQBX
+        9nGWpKNJt72aEZRzk5wBho8g3+EA3+vR3NlJRBzx3U6MNw4vKf/R3QdrTrg4XqgNtzzqP41ze0zw
+        X4FWRTl7m2+y7Pfv/wN70TwDynYAAA==
     headers:
       Age:
       - '0'
@@ -93,21 +93,21 @@ interactions:
       content-type:
       - application/json;charset=utf-8
       date:
-      - Tue, 19 Sep 2023 20:25:12 GMT
+      - Tue, 26 Sep 2023 12:13:00 GMT
       server:
       - ATS
       vary:
       - Origin,Accept-Encoding
       x-envoy-decorator-operation:
-      - finance-company-fundamentals-api--mtls-production-sg3.finance-k8s.svc.yahoo.local:4080/*
+      - finance-company-fundamentals-api--mtls-production-ir2.finance-k8s.svc.yahoo.local:4080/*
       x-envoy-upstream-service-time:
-      - '47'
+      - '31'
       x-request-id:
-      - bfa4865b-dc0c-4dfb-8afe-9ba6ec254eb2
+      - 94495fb0-b078-4007-b0d1-2ee71846444f
       x-yahoo-request-id:
-      - 2lp9ldtigk0t8
+      - 0s8cljhih5imc
       y-rid:
-      - 2lp9ldtigk0t8
+      - 0s8cljhih5imc
     status:
       code: 200
       message: OK

openbb_sdk/providers/yfinance/tests/record/http/test_yfinance_fetchers/test_y_finance_major_indices_historical_fetcher.yaml

@@ -5,14 +5,14 @@ interactions:
       Accept:
       - '*/*'
       Accept-Encoding:
-      - gzip, deflate
+      - gzip, deflate, br
       Connection:
       - keep-alive
     method: GET
     uri: https://query2.finance.yahoo.com/v8/finance/chart/SPY?interval=1d&range=1d
   response:
     body:
-      string: '{"chart":{"result":[{"meta":{"currency":"USD","symbol":"SPY","exchangeName":"PCX","instrumentType":"ETF","firstTradeDate":728317800,"regularMarketTime":1695153600,"gmtoffset":-14400,"timezone":"EDT","exchangeTimezoneName":"America/New_York","regularMarketPrice":442.71,"chartPreviousClose":443.63,"priceHint":2,"currentTradingPeriod":{"pre":{"timezone":"EDT","start":1695110400,"end":1695130200,"gmtoffset":-14400},"regular":{"timezone":"EDT","start":1695130200,"end":1695153600,"gmtoffset":-14400},"post":{"timezone":"EDT","start":1695153600,"end":1695168000,"gmtoffset":-14400}},"dataGranularity":"1d","range":"1d","validRanges":["1d","5d","1mo","3mo","6mo","1y","2y","5y","10y","ytd","max"]},"timestamp":[1695153600],"indicators":{"quote":[{"high":[443.2900085449219],"volume":[64338730],"open":[442.67999267578125],"close":[442.7099914550781],"low":[439.94000244140625]}],"adjclose":[{"adjclose":[442.7099914550781]}]}}],"error":null}}'
+      string: '{"chart":{"result":[{"meta":{"currency":"USD","symbol":"SPY","exchangeName":"PCX","instrumentType":"ETF","firstTradeDate":728317800,"regularMarketTime":1695672000,"gmtoffset":-14400,"timezone":"EDT","exchangeTimezoneName":"America/New_York","regularMarketPrice":432.23,"chartPreviousClose":430.42,"priceHint":2,"currentTradingPeriod":{"pre":{"timezone":"EDT","end":1695735000,"start":1695715200,"gmtoffset":-14400},"regular":{"timezone":"EDT","end":1695758400,"start":1695735000,"gmtoffset":-14400},"post":{"timezone":"EDT","end":1695772800,"start":1695758400,"gmtoffset":-14400}},"dataGranularity":"1d","range":"1d","validRanges":["1d","5d","1mo","3mo","6mo","1y","2y","5y","10y","ytd","max"]},"timestamp":[1695648600],"indicators":{"quote":[{"close":[432.2300109863281],"volume":[70782000],"open":[429.1700134277344],"high":[432.2699890136719],"low":[428.7200012207031]}],"adjclose":[{"adjclose":[432.2300109863281]}]}}],"error":null}}'
     headers:
       Age:
       - '0'
@@ -33,25 +33,25 @@ interactions:
       cache-control:
       - public, max-age=10, stale-while-revalidate=20
       content-length:
-      - '939'
+      - '937'
       content-type:
       - application/json;charset=utf-8
       date:
-      - Tue, 19 Sep 2023 20:25:09 GMT
+      - Tue, 26 Sep 2023 12:12:57 GMT
       server:
       - ATS
       vary:
       - Origin,Accept-Encoding
       x-envoy-decorator-operation:
-      - finance-chart-api--mtls-production-sg3.finance-k8s.svc.yahoo.local:4080/*
+      - finance-chart-api--mtls-canary-production-ir2.finance-k8s.svc.yahoo.local:4080/*
       x-envoy-upstream-service-time:
-      - '31'
+      - '34'
       x-request-id:
-      - 9374c3d7-c7f5-415a-8e20-66df9f7eabbb
+      - 5e2e9eb0-5584-410c-a81b-0ebd382fa344
       x-yahoo-request-id:
-      - 6j6rlqligk0t5
+      - 76kv87pih5im9
       y-rid:
-      - 6j6rlqligk0t5
+      - 76kv87pih5im9
     status:
       code: 200
       message: OK
@@ -61,7 +61,7 @@ interactions:
       Accept:
       - '*/*'
       Accept-Encoding:
-      - gzip, deflate
+      - gzip, deflate, br
       Connection:
       - keep-alive
     method: GET
@@ -69,113 +69,115 @@ interactions:
   response:
     body:
       string: !!binary |
-        H4sIAAAAAAAAAJ1c2Y5kN3L9l3ouX3Nf9GaMvLx4IHhkwANBMMrqklSe7qp2dbVmZKH/3ecEyZvJ
-        iBwMYDRQfZPJSwaDsZzDJX+7++Hnh9e3u69+u3t9/PT5PZ6+++3uw+PbA4t++Pz6+vj8w693X939
-        +x++vru/+/Trh/96eY+Pf/jmj/j4+Be8/fzT4+8fPjyi8Jvf/QcKn54/vb1+/vD4/Pbtrx9Z/I/f
-        /hOKf3x6/fT27evDu8evH95QXEOLvjbn7tHzT5/fP7z+68Prnx7fvn1iW7707HMs/PqnD28vP/74
-        6RGy/Z1PiUVvqPS/L8/S+tffXkny7fxiSvQPHx5fn354+PvfP/75P//48vqnO9XZN/gW9VIKR/X3
-        QxffvD7+8vTy+dPv3r98wnexhSPF+7uPrPovT8+QItxPzch4np5/+ga9vLyjxj6+PvI/I9+nN9Gy
-        DMs7GcPj87tZEF24Oc4vp7R/s83ZxKXNv6Y7tPnx5dPb32xwvn9psGCqbjaIFt89vD388+vDM0V9
-        eqO5+HdUNWcEH/D4y8P7p3f/xs+fYGHj68w//sML/kb5W+Sv/xV/Av9k/vGOf399Y+UPD3+5+/7L
-        mH4I++Ej2vKlhpoLh8/HlkKZjz10Nx6j8znNx1DTrBBj8atCSnVVyDG2+YhWZ7uxlzxLk8thliYf
-        22wshZBnYylBiPmYq1sVCp7nY01x9pZa6LPd7NqSN/u65M2h+FUhovZ8RAOz3Vz6kjfDnVaFVsqq
-        0HOc7RYX+2y3oN9ZocS2RC+p+lUh5zrbLSWtAZXelrzV1aX16svSeg1pjYIjWhVyX/LW0pbW8by0
-        Xlteo2jeL3mb70veFtqagBbrmoCW8hpFg+SrFBVXaWtL663XpfXu8hpFj37Ji66W1nvqS+sdapjt
-        dihittt7mPLir59ax2OfWm/OtzkKzEmZo2gwnbYqFJ9Xher8qoBxzHahhilv88H3VRrd1Doe+9R6
-        86nOUTRfY1sVWkirQvd+Veh9ah312hpFiGnJG1JY8gYEglWhuKl1PLY1CtRc8kYX5wQgsIc5AS0G
-        NycAj30NKOa8RI8lLtExr3lVwPBXu7C42W7yeYmeQlqipxjXBKTk1wSk7NaAEgx1VcC/VaHHNQHZ
-        hTUB2bs1oJzykjfnuCYAoWZNQK5+jSL3uuQtLi95CyLkrFBCXBNQkPdmu4gJS17465IXXrEmgKpa
-        7fawRlFDWUIiXi2tI/AsrSNsLK3DtZa8lS/Ox56X1ptLS+swqTWKFvuSF0NeqobAS9XoeYneel9C
-        drj8rNBFF+Mx5KVqmMBSdS/LTfG43BReutwU877cFD2kOYoOAaa8eFxu2l1cbtpdWm4KP89zFBBs
-        uSkel5t215ebYrjLTeEreQ6o+7TctOPBrwp5uWmX2D8fEWBnu8Etj+3BL4/F4/JYzOXyWESSsgYE
-        01qih7o8Fo/LY3toy2OR3eoaUAzLY3uMy2PpbGFVSMtjYfR1DQjxY8mLt+cE4HG5aU++rlGktNy0
-        p7zcFJOy3BSPy00ZEtYosltuujDF9wAVvwA6fSIEeff0y9M7YAz5cAnM/PTw4eUzwZY/sisCMQQW
-        ripAARef2OvDWi/1VxWpvyRT7bd4qb+qfCGueXp+B/T49vIq8v3P5xfWAT7+5eX9Z+LL75C/MxV3
-        D0uFYeMBGbK6zBG75MXE7wEeKnPefclwZnlAWuLs3ncAk8r3GQSp4HtEFzgAv+olBj5gBJnI4J62
-        Xqh4xEHJcfdI7ZJuUYKPrIzM2MRWEDiGx9A6g5N2VkyFGecexhNMj9Ji2JH56x5RXvACROtdhsbg
-        SZO5RyDp0hszfxepkSYZRO9plZ1vIanlPN5K0ctXcH7xFaSNnEXYCJmkC1h7EEuCc3ZB9ghGgGLy
-        XRrYCtnKiWQIzUEagtI4IA52hDG+j+gquga2Gr7t0aIMxFOC4eTQdZc3feoIkdI1cGIv0kiKYcZS
-        AIER+jGmEQng8WF85/3ZA3zJSw/QR5PWoPqB7gumwYseEMurTGxvafTN5ChhgLBSzIBYTZRVMvoI
-        Yg+VaY0PEy9lOryor0AQ0RWMifOOifFlvA6liYWUmIt0hjwbxJyACJO8heg6kijqxiBGCBxW6lS+
-        RAF0VZp0gXiSRdTgQxhjjb23PFQysgWNwotkcJ0kvTrEYH6V4HxO+kAqDMN2MAviKIgMErSg8zYe
-        4AlZTAYwfsgBHdZhqBGeLybn6khXSKMtTgPzsQ6LLV5MJkpQF29gAXXupvE3yWEifhyjhgeUoXPG
-        yyCKjXUo38PBhu3BZEXVoAxJbBc+KQJhLMWLHtEJMNB4SiiKo34Zamd4lBKHuQ2iZA5FpMQ3ZTyM
-        kQDUR5GbAHaqHaqUOQaBGfEZE+rHJDlwkxEpHOXjbCFci0EAf8Rhvz3MzlLIMtpeB7MAEhu0AeAz
-        iROiuT6MF7FWNAqgM7SOP2H0ngEpJb54gFoJT+H0YTd0XWino3LoIjxSzgC1sOEhKm07yxAxhjzi
-        DGZmKA8G1ceEumEZhEmSWhClB3cA6XHyFhC3G3qFfcnrvYnR8606QD5mvoisghQlKCKq1KHgAPcX
-        5XmEVRlHZFgSVbk8gnNxI7NlwB8Jc1BDGWEWUohbVAdwK70itk6T9U2cgGRtfAV/kXDZiLrbDCvF
-        D13VwS/pnwBZTJjvX/6MZBNrPQC4O1FjQDAt95jaAxZR21FpLphRoNOMgn7I8GDhsMyeULEeNHYP
-        iE58xZJygJeAzqGwQD/3iEUHbcUBK8AQ2U4PB4Pe1Vs9HhEBALkJvXYkZuS2A1YCX0CgRBKsWRqC
-        kaJthFtEki7dh03C1kxf+eD0IbaTMUQvLTOYecA5YHxpOB557wvfH8hYV30lFw+JQvABKJS9sdIu
-        EEvqNnrY9SF8AFaJsA7lwoWPtsmYvD+AHa9Gn1w7qOirt1w9hOjXCE/zTWTsR6eMQSi6tOTy0Zwa
-        ST5oJaeO2Hagrulxo0Y78l4D81yvdSbybDqDAx6IHWvoTdTYDkK1KxFlFv1uDbCPoXI9CeWY/yGL
-        wozhovhq2oaxn7gbbO9mutI+bJn2uDdTjtx2o3NHDruFJXS1jwnOUXYJYYZaFy0elRMBSAQk1/xw
-        DEYL8D/G3C7GmrUKYXZVqTBj4vfBBlvJKSuDcAcn+VqPWVu5zELfbJqTyGWIzaj8HgeoWyU4DcR4
-        R9V2lrXho8R0lo9ubK9v0YIt3+ist+vOvNPx44abwRXr7sAokdR+hjg2tAc0lvgt6LGkKHctyvAZ
-        P1RfqFM3BUHApBzaZ927q9rLWKSjTlRNQ4m7v7EzFbw4iq7UCpdGy1xdrpego+ana3MUnUUuYMFs
-        I+Z6lqj50QIllUtAR0zstCXRmlA3ATaoxCV65RdNTwG8dEsXLKmb34JkHCCgZxW2E8oRdz2FrAwS
-        VdA1MK4IHkYVPZPB6DsaY4tJBTIkdBXIANf1BMSm5y1mHTNjUnGVLSvDjkHnhugPr8wGRWoG0LSa
-        AXRP0HKl1+S1hlLQQ0WdtoU1KNc4OsZ6NbChxmpU1E0QSenou5AJkUZNdUKk2yY20f43rWWn8wFQ
-        rh5b9qb/HPRco0SPJEdtIlknSLatAzRa2sXOxQqZ7dCUu0EhytCTBnyss5t+MkGMms7X6ZEl12Yl
-        mo6m96RHmqyCMLFZ2XU+6nCTHQmhXCV3sRMVzNCewmLwLpja9WTSl6Sm8jGIl9Q4m04DsBaVcqB2
-        HdNQpEwD2tFQj9uNw4yVAjBHymkxJaQeV+EXJcqMMY87dGYHKhWjRENnamEzbDCNH8am53cETxoj
-        EippmqEAH5DSLhsh1z4Fgt0UTkKEMeBzNzvCnYENqyEtmytQBA1YLZxxOlyRISirdhqqEU7VvwKG
-        nI5awAyp6cxalQcwZRlYozvtivQxJeo47jXUJdSwVMXtcZwERzUdTLJHDt3HQVqi8JFmd0T5CrA3
-        nUQ4B5s3cdI1f8B0b9lRWMneVdqBAd8xzCoZhaFodzRKqPmwxrM0No3MW1apiCVRWbzXwwDoVwy5
-        a9TBOlt0JglQQ226bzAO1Qpe2uOREO1BqnbHQbnGxt4YYzTB33UdoGCMGnYR1e5RETaje+t2lhBf
-        92SMEhXqxKyVW0UdRb0J77RrldWBa4PbKyXNpr0BTGhaRw5v0BBZxh6zYYC7ldzGvnrdwGe1BABl
-        t2j8XDEaBIyohS6mpGrcbzpHvDBLJLplryOh19mcFGMyJsU9uimB3fgNxZAI7Cgfk6TZouWPScfH
-        4LSWAgG8GnDVAw7eUoGqcy1KFBABXVAQHixDI7/QtTJRokF0NEkEIGcPpMRGeiQE6Aobde0SN14D
-        G9Begu52C4RIym2iRcx4S7OjouNGbIZWRJ1qUtTTjxKlNYxMK8Qs4NyodAMCmrUBoDuNopIO5cSJ
-        yiWzTUCA8DpsCKvY9X+rKNkXs2UoOk7cohXKbHPVus0GxBADK6LX9GihNp2B8dq+yibweoDZ+Z8m
-        dFl7bLLmgXikTKhr/BL1ap4YsNTcF7LF/FSP0RDvcqNHSyX2VThSgt3UQPv2kJgN1syWrNPSthCd
-        zBoIGIUKWElja+HFmirrNZCknVwE1L6pCWY0iwBhn3YQjJ+ffvpZ+EXRS2gETk3RCa9sS4DThEK7
-        E5BWqNVeA2gImBTmMZTRmRUxlPgtBxHPKZbTi8bWLhhE7rV9cRNCo6lk1lCbth6bzgEvFJGU1bZ9
-        ja4dUXkl6IeyXa41quyqYCJTqe4r2R0Pu8oMqKA7yxa5JbsYHHRo4A7Lvg2SjIq8UZGBaWQKc9Vc
-        rff3W+j81vr7DVKhga9dl3J6+ZT9qejovAq8guMVXXIqgbKO6oz+oixerzCQQekNiGQ4g95QpD6N
-        K2k1Zu29NxiVNi+MXPOCdIMSa7+B4apohBLrSTfIi0pwpByaXHsLDM0CIBxOpUGat0HCajHN601P
-        eWtnCt5yLsJ3LVG0i/veuEU1QgY73GyZUTUwPBkc7M16p6wL7Dsy0Yw36v2GcAO8Z7NwYfZf9D6l
-        sMAbBEZLnfUSoe86dIIZKKmD9j3hJWpkNzorekaC2YcOQS2PCS1S3ZvlvaD3R0Ad1JShimr4Rp1u
-        aIJX0ABwX28ZVLMb0U0Y5yroTmUIF3Y8BwSmnBh4S/VetMhc0dULm8m0bCFptHuT0axsAU/pVWsU
-        6eXXqEFhchpWJLOwBh1p3GwyJHc1DP62WwgKmWVvmHtO2sqzwV/kDErqrBMB6yigk/XmaNZzlu0G
-        DqmGIk0G5uSRnnPUAJZkQvGUoI2LHExtvliwRUCtqZS3tYotslSk6PlNyZJwu218YxtDjGdv3Cag
-        ZPAd924UGfDWeKPK9dSBBijQgWo7m4XibPonp9E+r8+rkIwoxJeqGW3TIZHtqH2SqhFT1pj8hvNw
-        M0s5WNxBCwjKy8fHZyEoSQUj7n+oaSBBUYeWWlCxR3CaaqgOEhMU1RCYqYBXVPFucJj9ra5O0PBI
-        idlz2V1bTvGo41ZN0y8AOLOQa1ZbUKIWUgAN9RrVDTyebyy26kxs1hKJ/HbXtwcfvBHRmz1tZ7K+
-        s/nb25MQGoiaxUgu9OoTatEekOs6pjm7swDt68N3XY1VKIwyoayP/nUDFm8RDsvFyGZU/80wjq63
-        JJzatCCFd2pg7phsf2+sFXssLaqgxpeVcQ0lqH0RvW2ksTg5vCUnmudns9t44ySfWX4mwVMe0czC
-        udc4hgejlJEWc1qoaGAjh562xXV/4yDQDfqi4RA3HpUf6fNsstVhfUR5cbCbkxpCer0DLENV2zqV
-        G/Xe69WHbLZ2ktaSN4jIFTtteu/s1gKFiVregF8OTsVIIR47ObylOB3s7PnTpFFNsAfa7HGxagik
-        PsUrOotKrQrCg2KotU9v0DFKlOmHdAymoWoGndhYR4PCYLA96IgizNFp5nP7bIg6P1L08Li0u0fg
-        aFdqoqFr0Z4oi8HYFoo0STGTG23AjdmctbEbKTdOdnhtydzaUUpq5ihas5jS2YVhs0kDVGWhtsZZ
-        ZiMrM+QLedhXlS2/MEsk2awzs47audC7+eQcan6zOQUCgqFgQTZHpNDXxKSa9pg1AeJWs8ehMak5
-        /kwqodf5o4GpN85c2dNcdv/KLABFo0wSEA3JLd2IfaghmdWiaI8h86jXvk9h1sK5j7ZbgtdVsj64
-        ICrfl+ZTM3QmGjphomjS5+pTMV59Y2vFnp4ld1GkLxqvThp+ff8FLOPh3X+vo1a/XX+IFUEQwIOX
-        +BacqVBWqjGGWiYMqQDPPgMduVLmcjTISfO9tRx4VWUV8c52p8W2CbBCx9zN+R+npzxv2Qf+kMEo
-        IX8J+MSLdAM/wklDvmIFSG+Ov5LQedFl3u7g9SLYQjopCNhTjdcgDQCXU+mDDGws/YYYfKpBrtbP
-        BWPHe9cBASXNkp55Xcn3fDmVhTpnT7J8Hwrve5/r+oXi5JI7zHhiWWQzfMAofQM2GOAKzA8xF6Vu
-        nWUIiA4Y17o5wQPcMQ1jm5wlRu/9dOeJv/B1KFHaHa/xYkTwwfEW01hThk6D9zBKF+ZSdDxycbPr
-        CUdCb/jA2/snQvEe0cJlvhQnlEtRvcgNcbxQLsgJ9Kt1WMoV3mf86Lznvd6TWeV1KLm5Xc+jVR5T
-        VttJGwkCeIOc98qGeTCAYFqCmOKaWeYflPmTFiAlOAjQIFpb2xeJV51SPScb1AEK4U9dXA7RMTjy
-        9wVOBM6lNdiCq9WfexMZqhm2d7LpwlvoQTyzC+eAHmu8OoUIOw8d0SOEadV4K/GnN/ppNiAkSNAF
-        BpD6tHzep/A1Ld8dlo53eGf7dAcgEgflYX49nXFsBlI7oaR17wThs2Xebjz9lasCEXqFmG4OpMsq
-        Vna5+BxO9h8Bzk4LYJ2KGtCr2OkgZQj7SAK9hMk/SJFCiBe7LVA+nraNAMQ/B5PJ4lli2xUCw0zg
-        kOuEEqTlD6fkZbWwELgw79CNaRVCknspp5+RsjRe2792GpgxOmuCEafT8Pc15oQtkgKg7yPvWZ5X
-        E2CbMhXnNQgIFhHkxjQLPM+8Rnq6/kD1kXc3L1cM+MMLvDldrg6VQYGhpTJMURY1kDMxjUCScV2l
-        4U/CpHZOz3C+jgBRUsiL6/DW9xkdpSTTdn28OocJ2IFv5QrpPI3Fy6jXUYSbk7yvnJYz3hIS/gIM
-        3a6iU+dlWhjRudLQj4YcMRLmKvGFu87b/RKmCP5UzqQZcLsLU4IzyaV9Xp4+z7fBEzp/ruXq7gWA
-        bGuXoOe5146YvOLw2Nqq8NLTwWS+XL3aIvaBd2jbCorkxKASxc13xgZ1T7CwNPxN2A2GfJV8hCWl
-        q5njRsz4EZR5hgrfMxF1d1IbMPYQ4Z+eP9Qh+yk85gRc5PrSduARQujSLV8kO+ENfeTcEbGkpDkE
-        ixp9SuJEYCf8bR6f3czBcuMDkSvCjU6Yj+55W720U8cE7H5PPpHLAfiad4XPayC8Eor5Kqs7CAnr
-        CyAqU0ie1+LF1HY6QIRSeZ+6AFkMTyepCjFfAYNxUwXIDilqRlUWtcwbqX4Fejk4AwQErsffhSjj
-        IgiyNy+JezdmQ7AffxBnoRDWgaVjWoIPl4M2wEwhXXZ1QNhgxfw9qTQP2pg6iXE2QbtlQhUiu4Rh
-        LCg3boF0hMbAX0doed4LgcjNnYFXFv1z5jXty+kkeC3sKV50lM11GjIYSH9O280SYqfLDovsCHte
-        0p7mTOLCH3nKLlwdFdtCPmlKnNFj7aYw47i27JtbOTVnf+ZWWR5PFfp155k4pkTMMbJSJ1AfuwPw
-        aWTR5TckaYhjiOVxik84WzcoJZsYLfL3H87pBLCD5eeLWXBDjD/oU8f8TvQMsNd5LX7uBHhkO2SE
-        gAQzrRnciD5XTqEjT9cjZfa6wiKtmTkc3QhREEPhDzKlmRjGMUIuicEH/DnDiN0VMbCdMYFrBBkv
-        uwvtQdZUTsDtEhh3vKIOvIvkQ7xG86TW/P0u8bi1y8HADAsKAyTJtRBglp4hZ2/TMAvl7dVdqRZa
-        zNMW1u7MxVEXE8zpwpnH2TpghrRtUabrZJ/kyGa+wlVyk+XKC/6fZ7e+fP+FzOXx9fXl9e6r58/v
-        33/58n/rEQdPP1AAAA==
+        H4sIAAAAAAAAAMVcW29kN3L+L/Pc6fBWvPgtWOfykoWRnQBZGEageGSvsjPSRNJ41zHmv+f7imSr
+        T1UD+xgYGB+xechi3fhVsXh+e/fjn+6eX99989u75/uXLx/x9P1v7z7dv96x6ccvz8/3jz/++u6b
+        d//+h2/fnd69/Prpv54+4s8/fPdH/Hn/V7z9+PP97+8+3aPxu9/9BxofHl9en798un98ff/rZzb/
+        4/t/QvNPD88vr++f7z7cf3v3iuaWeo6th3DCzD9/+Xj3/K93z3++f33/wLFiHVJbCvz550+vTz/9
+        9HIP2v4ulsKmV3T636dHHf3b91eUvF8/LIr+4dP988OPd3//+/u//Ocfn57//M5M9h1+Rb+S0znl
+        0+TFd8/3vzw8fXn53cenF/yWezoX/PaZXf/l4RFUpNPijK7n4fHn7zDL0wdy7PPzPf/n6Xv8MBfV
+        suiiXl6V7doUJd1c59cLtX9jTOnFjrmmuTXm56eX178xIIRjB1xz+AEx4oe717t/fr57JKkPr1SX
+        +IGspkTwBx5/ufv48OHf+PcLNGz+LPwnfnrCv1n/rfpv/BX/JP4j/CcG/vvrKzt/uvvrux++TvGD
+        tk+fMVaEmjSp5CAfe0l1PY40wnzMIUpZj6mV1SHnGneHUtruIDn39YhR17h5VFmtJUharSXmvgYr
+        KckarBQQsR6lhd2h4nk9tpLXbKWnscaV0De9EtumV1KNu0NG7/WIAda4UsemV2BOu0OvdXcYkte4
+        NeSxxq2Yd3WouW/Sa2lxdxBpa9xay15QHX3T20LbXG+xbq63VPYquKLdQcamt9W+uY7nzfXWZa+i
+        x7jp7XFsenvqWwA9ty2AXmSvooPy3YqOu7X3zfU+2ub6CLJXMXLc9GKqzfVRxuY6VH+vYoARa9wx
+        0qIX/8bFdTyOxfUeYl+rgEzqWkWH6vTdoUbZHVqIuwPWscYFGxa9PaY4dmsOi+t4HIvrPZa2VtFj
+        y3136KnsDiPG3WGMxXX063sVKZdNbypp05skyu5Qw+I6HvteBXpuenPISwBw7GkJoOcUlgDwOPaC
+        ssgmPde8SYdcZXfA8ve40Lg1bomySS+pbNJLzlsApcQtgCJhL6hAUXcH/Lc7jLwFICFtAUgMe0FS
+        ZNMrkrcA4Gq2AOC59ypktE1vDbLprfCQq0NNeQugYt9b48InbHphr5teWMUWAFm1xx1pr6KluomE
+        v9pch+PZXIfb2FyHaW16G19cj0M213som+tQqb2KnsemF0verAbBm9WYeZPex9hEDpj86jCUF/Mx
+        yWY1VGCzetRtpnjcZgor3WYKuW8zxQxlrWKAgEUvHreZjpC3mY5QtpnCzmWtAoRtM8XjNtMRxjZT
+        LHebKWxF1oJGLNtMBx7i7iDbTIf6/vUIB7vGTWFb7EhxWywet8VCltti4UnqXhBUa5Oe2rZYPG6L
+        Halvi8Xu1vaCctoWO3LeFktjS7tD2RYLpW97QfAfm168vQSAx22mo8S2V1HKNtNRZJsphLLNFI/b
+        TOkS9iokbDMdEreZDknbTLk3bQFgB9irkKpm+gMwyS+AWS+EKx8efnn4AIiif7w5cf519+npC4FZ
+        PEuoCkcUQu4uQAxv9nPsD81+67+7aP+9CjN+z2/9d5evxEAPjx+ANF+fnpW+//nyxD7A0h+f/oL/
+        59bOcJaDFp9SlXoCW87hBK09Q2uwcWDDrUnQMM6Fgod1QXNGQcd2rhBOhHulbbClnrGnYCtGY21x
+        nGCsZ/I5QM4J2wXGGYCt6fDWyOecxxg1Y9YBRuXRzuAQ9gOou4zcRAeCumHs1qBhdej06UBh724u
+        OStWj4nePkcduUKWEaYI/6wD57Mc58LvZ1jw1Vwl5DMxZUiFXoKzsdORILa0w+qh52f15cBzGTtW
+        PZWYzv1AY4nxDLu/Wn0J/UxGX70V2llBGlBiSbErjeM8SGNSeKUjBTn3YFYi5xCveMSxE3kduK+2
+        2SDHHpBzu+aZ0nPgWQnlHMpl6V3Z2M80sysSVYrxqA3Qj8lyK4R6Xv+LGBfAcfCnpRtOf/JRYcdw
+        4irHZavY83GYCps5Kl04SzpqWMFUxzXBOOqRQqih5UXP50ZBxILtBcKZhkE3hb270NuqsoplIdSu
+        GRYKBH9cbPKdgtEyEHemkK/5KFbLVQrjoNMUIiHkQani0Q+Qt4ZwKoizjmb1TKzio8VNJufhdG8c
+        vAVHvjHZ6NeTxWD9xw0zgym2owGjJdZrF8eBjg6NLfHg9NhSjblWo/j0H2Yu9GkHBoHAYgw6ip09
+        NGtlbLJeJ5uhwcSjvXEy47y4imHYCpPGyNggY3tzOkY+w6qj8iwz+IDaZsh6tRj5WIKK2UuwxTvf
+        6VuyV6HhHGwyG5fylT90KwJY6WG7YEs72G1J+QzwcOnCcVI95yOfkhiFRBdMDdyohKfZxUoyOX5n
+        p2y5GEeGIMM4spKrFUDuVm5ZrM/MxfhVjmwUOye7N+R4jkZt0GQkgKGNBDA9odoVX0u0HCrJLhV9
+        +sGtgbnO0LHWq4VNNjbHouGcSCnncSSywNMYURd4uoNgC/X/wDUJdj9AGGPXJtHNL8nKGi12JZKt
+        iojdIDm2ddAY6Ui2VE+k+KUZcwNDjKIXC/jY56j6xTkxclqut0e2XKuVcjq72YtdafEMgmDF6LWc
+        2zSTIxJCu9ncVU+MM8N4BovBuqBq18KkLWlPY2Mgr5h1drsNQFvMlgO2W5+GJqMa4I6FepitTTU2
+        DICMjNFCJAyartwvWowaQ45H6MwJzFaMFgudyQWj2DBIu7HBRRgPlYb1mP04P0Kup8/3jwxZCMsO
+        akjAFY88yz1a6N/hTw5WqMDJDNTOC2Me6SNcNLEO4VM8vDzoHI5vDYNDCczE0nBUMMXCJmjpxqMS
+        ztldCLt+PLpLtNSjbiEeacZggO/sazDYA3rl5mxUPkbrUbHvmp3Sw4foSIxuZyBOPM4VutVEoheL
+        J4yz4EuGnOq2CjDIhZnwHwa6RY+cxYWww6yVEYdVIbEBNNTMmDoHOoYOGsJZvF3c/N1YtA50zSMq
+        2sHCaCHGh2gIhB8gguNgCF9ccJcNVuLLRrkmEw5EEHJZrgQTh4Eukw5AAGpMTQzo5XpdPFxcZF2c
+        RUBJDaaMxq41vDBKWh3mrsa5zNDhesPBwB5OG7el+QHj2NFkdt1oo0L2scg1OitODqqhkwuczMjB
+        eiOyI8xw5fiq2G0Gxm24hJeyMe7qxdYtu0G52Vqj81rwLT6xYn0kOh0N5zbjrLPzWZxigWjyYaEP
+        uprdZKPNhSnPsmGrgeUpWeiOqWw0163qJ+AC3VVNz2Q3Nvax2JSdjjbB/fqIbRCrGHhwG2EZFFbt
+        8kq2wXP2OByvGdiUfVyWk9MtNJmFZCfc7B1uFodYPYC/gY+i1WTGHYZJ3QV03XmFEnwkUh2Ga1Yp
+        AS6PgESR5HE2ocsn+D/KhSGLiUay5QFDDxeMGBZgHOMVZFj5iksNSbOwQFyggblWRBaOkSRWZJFr
+        t5sq3zJ41yUR0cf6S+imxfg3IhcfE/lAIN7QX8NMRiNGD/maUQ1o1Ipebfom+2QeA6aDd2GMfUhn
+        kg/HfDDCSdNFstONYLZ1Mu+YgSTvbIDvvGix2Wnw0lp1cUma4nNQsAWTsqZbsdx08IskuSjRypdJ
+        EJsBMgEagpU/Pfz8Jw1Wqo1+FF8d4Xx3kKePnSk30xNmmQw0wNAxTzMjkQPucmFscFk6tFiUFY2V
+        MDYx1hacBjGiMC3BMRFIzOZ1uzUJIF8bmlQb3GoG0O672SKoegM/HPPx7GPwjAuk2WJPYfxeeQOs
+        +A0FQ7kEdXIos9mjmeJY5KM3mLjVGA1q2decQUArzJkaw9wbZwI2MVycBQS/Rweb0r0V3EQXMmez
+        Ro3STWyT7WS0F6PxNuuRR3GHInaTI4U2Hk3elCwb5UbAMkyAZtULK7enBsUFscPZDRG0CQbiDUty
+        5jYsEkCLFWv0u0t0SUni7MNiVb3NyYqDCtEexOpbBgw7X8fprYdGL3fg4DZTHpMYIpNfrrhUFRC6
+        gYdE+gbDRpeD5WGXCXSyW2+2OYvk2FZsUlzjA7d+G1Zk3yl5ql1eJQ6H/B1yStb29NDErOzGZA6e
+        J3c2jjDGBrHD7uzJQepkz2yw9drQpNuBb/QZ7mjDhsLZBZQAZPaEZDg3zsysAz4mNQBkZrFetbO7
+        iIthiU22FjdydemD7M9Ls4sCgXtsJp1QqNnIrJuQwyYvJ6A89AGPjC0Wt0PypOXonoAo/bGGyR1I
+        dPGduEylOPzFeMNQfSPaERdW2ANbsTITf6iEQMYm/B3Mkbk9A1WbzCNR9RGkSLoR4tkDIQ+2AJAN
+        JiDvbsQtrqk7zF6tfEvx4ao/yr5xtKLKcxzcb0DF4TueJxn8H73yZhd+DAdQGNm4E7djMRSlYvtE
+        b/O2hqaID92aW223LpHjmBi0WcQkFpPfMB4esBkDyxbvoo9zC676Ihd3+pWOWx0inV+ePn7hpYbv
+        W+nCvflEvhBGnbC+FoSlcwEbB+sqT7ChxkLrUwUn5kPvnSWFJ4wpje+z8pbbzqlCExhYnug+GK6c
+        oOxCJ3RigSU18dSxa9NRn2SI1nijBX+yMzjUtUCx9jzLNFkSqZc3et2FvNBlGWk+VaGOnEZpmUXT
+        pxqSFqmDNNh50xWlxDrFUwMlOhvLzYdSXUYkgDuxFHLwrRpFZL6F/UV/GmlWr3fITpTYDJp0igrL
+        0DLD0OPQ6yQ9QExNfyuzoB9qF5SyLjHpQGAaF8TFztpZvp+j1k+yoH/WMyKwK7qQSApmYSN4PfRN
+        RGtN5tQN6ld1EEh6FfAiDpv1xljTLD8dEd3THPcyw8gspOT0jaXaOj2UUtkPMUTlQ8NUKtjBWxv6
+        XgqzRp93GVQNeEFAmVV5/SSpPjTWUvNhFekLq0yVfRWEKK+gTJQ7BBPrfB1MUw2pWXSzP4lAeKoY
+        vDSiJOYyK7fRNydVwtZqbYv5WnqqJqxTjKwjYT0wkbnWTJOeLJklylSKqJS1rgZ2ws9FZQbLS0Hn
+        qLGkqTuQghpKKPMGBHg+i01pCaIq09KsQR7gYZuKCtObKhfarJGG5fe8FCzmNjW2RlWZrJXEag26
+        84DnYSl/18JpJT/PVcMC6uQ5i3STMja3yfwIA5u6B5VVVsMvFNVdHgY2JQ2+QvmISXLI8wkQUVWj
+        kaIy/UJXBkKbs64JFtjU9rDalOt8mCtpUrPSzVsTi+10YuydofSqmxBonEIKVfr0FIH0UVpwf6oQ
+        2L3y1N+R1mQl6R0nWPC8ziKpzrsqHfSoEWK4MZUXbl852mKaXMc/ac6OnTuqf4lBVLJ0ssuGw+R1
+        pZ7Ozmko8QOBbJ7Klyap1G3RJWINMv0MJDOZB4UaU6BhagZr87WeubQ+L6xg2wz6VoeeTb5Cv/R1
+        bCrzphS2o3mzBJKvSqteT1CnCK/SJoMTzF+ZF+FWdR2ZbklZFWQ65xpmObX03tTNgQ11ullQoWaB
+        bUT0dUhelsrGrkbAG0LzJ6aDVWK86tGXW6lx8qrNS021StTJepJ1pwe2d+Ea5l++WEMR7Eo/zlty
+        37Ni055dsj7T1jabKtNuE8QsDeju6N4WZ4rBcIz7j6EwcwMzJ2MPMM2BGkmwVbK+hjLY0wPm9Wzw
+        70/Hy3nVZLryueAO9quFF9Ed9GqdnKul9NkMA64Qk7oTSZvd1ONGVx9tsHl0uC26OIRJCZMCcWFQ
+        sCXlLOAwp9PdBumUgclYVVe03Ny5d7VTFXtg33w5d3EMC/aAhRTaInyfjvJFDV1M/pEttlgl2mX0
+        WynEI9Bln2Plwch2qfbIl6URZpRhTx20CEB8as3nw5lss8rok01huFxH8FU23cYD0Bk72/BSGjZS
+        Z27PnKt3nybO7kzdHSVRr20aq9yo4DHnIdFVaUaXOVYrchl4E35o2tKel/uCWxups4bhEDOB2SZP
+        QIaYWhx3IuApZFm3LQ5ykydX9ZHcyK7EKdoSQpZ4zKXYgufhWrrLLLoKpejqVW4UrRfrH1OwXNJa
+        BLPgZhecoq8/bi7b1mz8l7o9Jk3VxbrJnTKjxVbuZreJMOdlDkWbTwgkl7kb1iRuvIZI1tUlVqOB
+        IMmYTfan/Kw8MCXZ7iQ++7RJdhm3bMVfXHUcVmYZ4m6N3Oh047jZXUjgMa/NYlhXrsmlo0mK34BE
+        fHIpOf7fair+RfEZNOsnbtUy26KD5hJnDsSw8NZUl3eXqPTZVM2u2VKCVUG7/meryMUdsXv1SDaz
+        SqmaPKq9QqQKrD2Pt+dU/cyM2VX71xsz+vrl49UfVo+Y3GW0dSMOa4q/IUBNs8f8NqdXrMMqFltr
+        Mb4tDrAXL4o1ciXQ2qatas/u5kGyYs+uvAvOwvqB4Kp9TGHxD18Rqtx9+O8drfx2/UducIhAM8xh
+        bWyDSEUK4nEEjAvcNdhflJIyQsYxb6TlM0I1BHOJgdqEYDyDwIYN6yrrbhvVKWGngtt7u2IZNXui
+        0p1N9LYJnZlJmsAMHiAh0OttKHfmaSyEFDJv5dZdRs0QG0wql8pnwISWW7kCithgyRlE01zexM2I
+        OyOCSDiKS6EnInrofIL9ljpW6TOD9jjkLb5Bn8tcetKdKq/aX47AKwlCwDk2jTzYDfgj5h4Ra6+q
+        zsRL2pD91aE8wvaeydm8jvr4SYIpvTRjqJwRsC48tGMY3nzOLVClZnVoxC6bAmP5GXuAsVgp1DCk
+        hSPzWSqwVQxvdc9pdPzBDydcSiMjYnNE4HwprxrSghgb+qWpxTihLd5L9Q1ZQnuZvGqRXwBYZ+HQ
+        Z16w39OpYJkS0Cvz7RKixM5ETlqIm6WHvLnP1MoMLWg8kElSddxVI1wEqFFoMTRQBgtaPeoMg/3S
+        9PMVsxahgRn8wshbKEqnlVubnkPf4lc+wIGLYg89M8XiRMpF90B1ZapoTd+Z58/84MmlDzQ9DYQy
+        KS21xluFXzwZF5VB9AP30/gllbeF6bIvKo7uvCV/CfIANAO4BrHGOgnGvku+wPD2bVG4vi5M7dW6
+        CyygvggXQWEOi76h5zwSpEZJl9sGMDC5CJ59GnqApXnZPat+hJm8UdNC0IzUU8pv2op9EEoth6Ny
+        uMsAVRE1KNXoBoKhH6VdID6o5adqZCsrVAOmywTSlKgWQMuo9WJeLJHu/FDCtalAezFZ141qmQq/
+        aLJktYuisb/HzCTj5UIhlLKMGi5XOWlrGT5uSlgrAIQ51IvFzyrizMTl28VAfuqCxwb1KioDA1Mv
+        dWqhXqKAh4cYc9oDEQPy2zkX8UybG3ALtSybY/EOxIMXyuIHWoS6EvNVIgMRF37V/OkKZ5iJvfYd
+        LN9hsr5sK7xFJEwFQWi/8kmDmWQo0SVRALyNHWLuO7sFnr2YW6E0JH6caAVBsLi3ABV2pJ9J4MnB
+        JUCEEQx+IOfqxiT8Q58+dBcs1wBXvN3vLP5oMNCLbam8QrsqooqJCeS+fSFr8IFnYLBjjwGQNwo0
+        rEx705AGSxYov9r+jJ96uZIcI6z52ZkVhOD3zDRVuBQGIOJKcItpO0a28IsRzJ4vbifG4OBl2LbI
+        iIfHUyOH6ay0pWP/g0eJpagRYevn15CihOWp9J5mhM5wr97QHdPzqKb2C48ZzMTjlpN5/QA/M1F+
+        ubzJ8wrIq+7pQCS0LwHXLSIZ8DAr2y8GAHzCL7TAHludls4ibuAGfqRj7AJt3i+twFh9O1Q2dWE6
+        Nm4Xr8gTWBGAU/f8eX2zYQh+5iNMaWit6bWvZh9oOsSSYnpDqsBLqbzVPbQzIW68AJUbfQr9bAF3
+        q/rmdZiJZWxMOe9uDrjGxKPBLus2J0ju4eJ4FYaK8IziDd7DaqFP+Y1H4i7BsmIa1F/EdrOFuOmt
+        BkFrpiJPKJY6s1Can9WSkK5irYPLZ+STl/fYcQ53nNC3frPYoV1DMT1ALg38DZegkrshZIxdaegm
+        qufnsOkWy7Ybwnr4MfjyvMjnYXU7ICg95u+Zh58XcQLRQfPlTS1YMsJPKLUp31UvAJA34kaUVAJ4
+        5QTP3bY293OgzdUL0ZnpaWyZo223SG1mygnTKJJXReEnsMraGGYczhwbbCBeJAzf3eAD+8Un8E6C
+        lIXM+grWizECFhRAufNVjMAbxDHl6wN9lvLzi2lqcbsOgI4ZGpQmPNLLnAG+V0Dn6EsxK+kdLVyx
+        FlyUpQs7Ankz1BWk8BzmEsrM4PQAqNUKrjf7ojkPuYJUev/0ygr+34Ofr4x/7p+fn57fffP45ePH
+        r1//D4UeqKb5UQAA
     headers:
       Age:
       - '0'
@@ -202,21 +204,21 @@ interactions:
       content-type:
       - application/json;charset=utf-8
       date:
-      - Tue, 19 Sep 2023 20:25:10 GMT
+      - Tue, 26 Sep 2023 12:12:57 GMT
       server:
       - ATS
       vary:
       - Origin,Accept-Encoding
       x-envoy-decorator-operation:
-      - finance-chart-api--mtls-production-sg3.finance-k8s.svc.yahoo.local:4080/*
+      - finance-chart-api--mtls-production-ir2.finance-k8s.svc.yahoo.local:4080/*
       x-envoy-upstream-service-time:
-      - '36'
+      - '34'
       x-request-id:
-      - b15db388-8092-4fbe-90df-811abbacaebf
+      - 644b4947-243a-4d12-aea6-39dcd0905f0c
       x-yahoo-request-id:
-      - 6cuos7higk0t6
+      - 6g505jtih5im9
       y-rid:
-      - 6cuos7higk0t6
+      - 6g505jtih5im9
     status:
       code: 200
       message: OK

openbb_sdk/providers/yfinance/tests/record/http/test_yfinance_fetchers/test_y_finance_stock_historical_fetcher.yaml

@@ -5,17 +5,17 @@ interactions:
       Accept:
       - '*/*'
       Accept-Encoding:
-      - gzip, deflate
+      - gzip, deflate, br
       Connection:
       - keep-alive
     method: GET
     uri: https://query2.finance.yahoo.com/v8/finance/chart/AAPL?interval=1d&range=1d
   response:
     body:
-      string: '{"chart":{"result":[{"meta":{"currency":"USD","symbol":"AAPL","exchangeName":"NMS","instrumentType":"EQUITY","firstTradeDate":345479400,"regularMarketTime":1695311644,"gmtoffset":-14400,"timezone":"EDT","exchangeTimezoneName":"America/New_York","regularMarketPrice":175.55,"chartPreviousClose":175.49,"priceHint":2,"currentTradingPeriod":{"pre":{"timezone":"EDT","start":1695283200,"end":1695303000,"gmtoffset":-14400},"regular":{"timezone":"EDT","start":1695303000,"end":1695326400,"gmtoffset":-14400},"post":{"timezone":"EDT","start":1695326400,"end":1695340800,"gmtoffset":-14400}},"dataGranularity":"1d","range":"1d","validRanges":["1d","5d","1mo","3mo","6mo","1y","2y","5y","10y","ytd","max"]},"timestamp":[1695311644],"indicators":{"quote":[{"high":[176.3000030517578],"volume":[25881397],"open":[174.5500030517578],"close":[175.5500030517578],"low":[174.4987030029297]}],"adjclose":[{"adjclose":[175.5500030517578]}]}}],"error":null}}'
+      string: '{"chart":{"result":[{"meta":{"currency":"USD","symbol":"AAPL","exchangeName":"NMS","instrumentType":"EQUITY","firstTradeDate":345479400,"regularMarketTime":1695672001,"gmtoffset":-14400,"timezone":"EDT","exchangeTimezoneName":"America/New_York","regularMarketPrice":176.08,"chartPreviousClose":174.79,"priceHint":2,"currentTradingPeriod":{"pre":{"timezone":"EDT","end":1695735000,"start":1695715200,"gmtoffset":-14400},"regular":{"timezone":"EDT","end":1695758400,"start":1695735000,"gmtoffset":-14400},"post":{"timezone":"EDT","end":1695772800,"start":1695758400,"gmtoffset":-14400}},"dataGranularity":"1d","range":"1d","validRanges":["1d","5d","1mo","3mo","6mo","1y","2y","5y","10y","ytd","max"]},"timestamp":[1695648600],"indicators":{"quote":[{"low":[174.14999389648438],"open":[174.1999969482422],"high":[176.97000122070312],"volume":[46119600],"close":[176.0800018310547]}],"adjclose":[{"adjclose":[176.0800018310547]}]}}],"error":null}}'
     headers:
       Age:
-      - '0'
+      - '1'
       Connection:
       - keep-alive
       Expect-CT:
@@ -33,25 +33,25 @@ interactions:
       cache-control:
       - public, max-age=10, stale-while-revalidate=20
       content-length:
-      - '941'
+      - '943'
       content-type:
       - application/json;charset=utf-8
       date:
-      - Thu, 21 Sep 2023 15:54:06 GMT
+      - Tue, 26 Sep 2023 12:12:57 GMT
       server:
       - ATS
       vary:
       - Origin,Accept-Encoding
       x-envoy-decorator-operation:
-      - finance-chart-api--mtls-baseline-production-sg3.finance-k8s.svc.yahoo.local:4080/*
+      - finance-chart-api--mtls-production-ir2.finance-k8s.svc.yahoo.local:4080/*
       x-envoy-upstream-service-time:
-      - '39'
+      - '35'
       x-request-id:
-      - cb29f7e9-ce57-469d-8605-dacad0e978ca
+      - d7e5ecf8-8ade-41ed-a96b-dc0f049e2ff8
       x-yahoo-request-id:
-      - 3e5oi45igopou
+      - 0e4vq4hih5ima
       y-rid:
-      - 3e5oi45igopou
+      - 0e4vq4hih5ima
     status:
       code: 200
       message: OK
@@ -61,7 +61,7 @@ interactions:
       Accept:
       - '*/*'
       Accept-Encoding:
-      - gzip, deflate
+      - gzip, deflate, br
       Connection:
       - keep-alive
     method: GET
@@ -69,111 +69,112 @@ interactions:
   response:
     body:
       string: !!binary |
-        H4sIAAAAAAAAAO1c245lt3H9l34+OeH9ojchCpIAsaHE4wfDEIKOpiV1PDM96emRrQjz71mryOru
-        XbUD5wNsA609PNxkse6rSO5fb77/6fbx6earX28e7z59foenP/568/7u6ZZN339+fLz78P0vN1/d
-        /P5339xcbj798v4/H97hn19//e2/4t93f8HrH368++3t+zu0/vY3v0Pj/YdPT4+f3999eHrzy0c2
-        /+O//f5f3vwBv/xw//jp6c3j7du7b26f8EsutfRZQrhg9h8/v7t9/M3t45/unt7cc7jYZs0xtlIu
-        Nz++f3r44YdPd6Dv72KRN57Q6X8ePsgE37x5Rcyb/cMm6uv3d4/339/+/W/v/vwff3h4/NONmexb
-        /MrZer3Weln8+Pbx7uf7h8+f/uHdwyf+luZ15svNR3b95/sPoCJdNndkPfcffvwWszy8Jdc+Pt7x
-        P56+D2/3okIOXMGnJ2E9m9LIiU1unV+eqf0rY6ZWzJg6zdmYHx8+Pf2VAUsYdsA9hx8QI769fbr9
-        p8fbDyT1/okqE9+S1ZQI/oHHn2/f3b/9d/77E7Rs/Vz5J75/wN8sf5v8jb/gT+Kfyj8x8O8vT+z8
-        /vYvN999WeIHbe8/YqzYeuq1kYN8HCW1/TjTDOsxh1jLfky97A45t6gdSunaoeY89iNG3ePm2epu
-        LaGm3VpiHnuwklLdg5UCIvZj7UE7NDzvx17ynq2MNPe4NQylt0Ihd4eaWtQOGb33IwbY49Y2ld7a
-        h9JbR2vagdqwHlvIc4/bMO/u0PJQ0lvpUTtUDrceYYZ73DaH0ttDV6732JTrPRVdBVekHepUensb
-        ynU8K9f7qLqKEaPSO+JUekcaKoCRuwpglKqrGKBcW9FRW8dQro/ZleszVF3FzFHpxVTK9Vmmcn2C
-        DXvcCUbscedMm178jZvreJyb6yPEsVcBmbS9igHVGdqhxaodeojaAevY44INm94RU5zamsPmOh7n
-        5vqIcKV7sNjz0A4jFe0wY9QOc26uo9/QVaRclN5UktKbaqzaoYXNdTwOXQV6Kr1wOVsAI8e0BUDX
-        tgWAx6kLyrUq6bllJR1yrdoBy9dxoXF73BKrkl5SUdJLziqAUqIKoNSgCypQVO2A/2uHmVUANSQV
-        QI1BF1RLVXprzSoAuBoVQO1RV1FnV3pbqEpvg4fcHVrKKoCWo64CPkHphb0qvbAKFQBZpePOpKvo
-        qSmR8FfKdTge5TrchnIdpqX0dr64H2dVro9QlOtQKV3FyFPpxZKV1SBYWY2ZlfQxpxI5YfK7wxRe
-        rMdUldVQAWX1bGqmeFQzhZWqmULuaqaYoexVTBCw6cWjmukMWc10hqJmCjuvexUgTM0Uj2qmM0w1
-        UyxXzRS2UveCZixqphMPUTtUNdMpvn8/wsHucVNQi50pqsXiUS0WslSLhSdpuiColpKeulosHtVi
-        ZxpqsYhuXReUk1rszFktlsaWtENRi4XSd10Q/IfSi7e3APCoZjpL7LqKUtRMZ6lqphCKmike1Uzp
-        EnQVNaiZzhrVTJHyqJlqlvcdso+fkVB9YmLy9v7n+7dIRuQfL2GL/7p9//CZKVi4pix5h+SK2gOp
-        wYvDMN3LS3ftId1Vav93d+3xhanO/Ye3SCifHh6FuP/+/MA+SJu/X9niH2OqVygS/gc+0JWmC5zE
-        NeN9aHsMGR61XaRXZKcGt4s/F6aZjS01RriSXi9g1zUWtIDaBr+VhzQhr0En5jwQCEbK+SoRt8Kf
-        gZPaRN2BgUL5prxYrojBsKIa6FImJsz1Sp6FVGiRLVVpSnyxdSY2Pa0WKkZJnZop7/XraAdCS7yK
-        rr5aX0nXSkLhfqCocBHSaxgulHylE3g1XwFRfC9JNhNJFDpBU0q5pkFmIIBG/JGuxXSt4Uq5BmR5
-        JS3aarnyb3R8ww/NcBe9JkUw6HDg/NeAx7WiD6L8gZE1XyWB0nUlaYpHHaj1mulpkBZEyKpLn35k
-        dgXTOFAOTAA71ziuiOwHutE0jXDLvOZ5XEppdvDS7eLQYtUEPM1cXYf/qzOLcKubjzwwwiUPzPLi
-        9SDttT7LzXCtlGrLcN9YXpL1rR8K9S4m5g/IJxZ3TF80TaP74LMTRqUC1e6YVCeU26yju3UMp5EN
-        /qHKLyevW6VC524sqCXnD1q5DkNda9fYDgJr9So5Apx52pRkZ9YYib71tbwwn5UXqBrhoGpoiUZe
-        jaj4qA3NeQi2GNMC5VZ4rTvSm2cVBJUMq5zZcMmWnydcGE63GxxsN4KcTqXwYs0HPwPSSznYMojq
-        R1/U81XQ3SvHwyb8jY5a/mC42rkA/Cf5USC6/1dTm0dX3sHLoy9BSzSK0Yt1U6DXEQe/nY9M6t7u
-        uvfGHRZ31DG08IcRrsGwHU3zyORO2RwkjxajexjP+nsMZHnIsY9RZmQrQLRYx4cmQ9JozvePYr3q
-        qL6TC3Oj0yVhPKuRw8fbMSBJQ9pcfPTqOzGVMb2ZruU4+4zWqNAyzPJn8MSNazNxnsQdpQSirMZj
-        KGNTHNwoLCk3OoUmG7VndV4KveLRtWA1NrMBE/qaxCRZU/IDtDNVPrCt2kgwm3UE6GMZMpNVW1Bj
-        /PiI3nyGC1tQd+Oi0SlaM+9O3miy3mlaDejOp/XmfU+hkuKvzS979R6huygwmBUeeI05CAZeSaqf
-        aFRwi4SRmZGGj7PDpaXDLRstJjUfyWU3WIpzgWC8sQXw1MZwLs8IrDiPhdBRHDetwziT6vRev55J
-        5pBBAlb9dP/jT8QlgA42w0jDpQoJytMOuATvmcT7DF5EOCQDLxDmzLIAQlwv5z8BL+x8XklyEweI
-        X2zCALSQTUhAkw18gCc2WhFgVEmKrSKX6tLyAgdq0tbmiEQGbLWGSejRAogUbJrsMyqimKNXqcXh
-        ieiIqp7h1adPmI+EtBOAEtawR60G3DCBEdm640d3Zoz3jCNEi4keZ+x3UKZ6vFmd7WHtJyDFgYpi
-        Q1MNLnhQRq+xw2KjQxN5oYJmvQ5arM1Xn7hUD+KQt9t5W7S62DzvTyAHsIr1FRjKZIiYz+Xtgp2Q
-        qxubRIsNAc1lnIAiJu85QyInYCi5jAeDW7zSnKETLAzDL49xkeFbd9Bc7Ggu1hN8WXzUXNJINGQw
-        IRGFXc300T64iAzB+k7GW4LycNRfxBwbhXx9ghjEvWYl04tLL9nLYxcb47y5EDBYdABO2UjYnPww
-        YXej2yQCanvkCldsbImB1wKx4dOw6XjOfMQkH8R0R1YRBhiscPaaYRT6WCNCPuLyKCzGcIUJkU1/
-        iuMd4EU10RFNdslosgEIIMQaDQHL0biHT5MEqRw7DU/VdLIBGrC5DdJyW/ia5MMxz4dW2U7JZQRo
-        aib/np4L01oN0naTKzKRt6DFh3hQbv3SdLF6Difm6YsmeM+BueLyVbLKoh0Wio5sn91CfUxoSjIk
-        wUKwdgrB7Jrpw22Cbqx0OJgG9XdYNzg/gaauSOGIJqYvekynNd3Vc5jf23zbo0r4IkMu3nOA2EVj
-        gh470vTG6suewxcAiWisM5rOq0xXgJjOKsYJuhwn3sg6ZDQZq6Bbc2yx8cZ7FKLL5V2N655WB7uD
-        aBZWAdM8fLz7sDGNjbapOW8JTBOpVD3VzB2tLr0CaUxAEikHmmT2FWcOb/FKXMDD+aLsMxtgG1NB
-        AGyxaR86mRQ4+xQCOMeIvQRfqA9u5YJ8jhn3CRZyWVpJVgbFl5XKcApbhk+5fUkTCbZ1TtWxU2DK
-        caji4Hx1RUNMZxjF3N1iBY9M8Z6N+zVYh8kVu+0LW8gk7rF7Yf1kL8YEytKsrhBjHnlC9hqs4uqY
-        aDGi46aL0ZTqK9BYSXI0uvei3/DwMZEyMCoGBGSUnHsyVi+6C5zVRWXgGL8/Y7cV6/QQzldUOLhJ
-        +qPbtCQkMkMB1diwxb0Miw2KA33NFx0wo0ldm9dEdLLFSTTZ7RSfrBOQ2Sbvmk+RlXvPY7sFDKsT
-        f8tn4M31OsGjfjeue/vils3aLrNIIbiwR2Bgm7LbFskuYzwHTDb98J60n9R14wl+CedQJ/sFuJwJ
-        41mOCPwxhPgiGCacrgZsslJmOEfnMfxOLxCKD9muWjmc2XCvxiY48bpxkU0Dk9VJ7s+YDNNvqvhc
-        FVmVQzIniVZ2tjpczW84D40+Dph1n7+6Gtd0xjt9tEMnt481HVyc0a9vuqSFWWNzvWwyy10a+euQ
-        SfSILTsvNX0hc3oHBLBysn9j18DhDWDKFsQBmTikV846GWeEJpvmkk6zP3XC/erRdHLm6THJcEdI
-        zlCKj31newDDpkno5NPxk+KLzdB99O3dV3aGX3GwHO4e6Hmn7ZN6KZgYRnVfDZkuSgx/6IJFBqOf
-        3WNUrOaktOPY4GckdrF4sWwf7uR40tQdF7s3UdbazMbNu4c/y3mycszh4zo89sqltHlhr96OgCb5
-        GJmmb3LQgkDo6FgBeqw3R5PdOgKSMbqYq8dEfvuBu0Imvck+VhQHRQGKbIJavKfi6TGzxZBcdEeT
-        VSoM5faRhkNT/rRQcJ78DO+4LWGedzKns6ZjS3XlXzmfZpLfdIKlTsCN44E/MUMsY8Fid96zVIRd
-        gw3d9vIJvvHbnsWXbYtLUriJY2BgtIpX44lc3L5Sdzt2xSVA1Z+KKq7iwqNuVsLFQyVftAUusrtP
-        J6jL152qrwxVt4UBiGXzyerL281nXy26GmPzNsqk3rCvRQclkqCEYG0QLQ6CT2c5J+gouwJK8xsX
-        3KrxR8vssa6Tw23+qEPzxffmT6U0l6+eQZ5uDRMgyOoNOvnjZ267qrjiTw/uCFxPTkDdn8ns3mXy
-        RRPko8S76Cpk3Um8O0fW3YmY7oM/EIvd/vLFBoztQmn0RWBf8Tk73NI8w5rfpDqJ1K4Kw8M0J0ff
-        fD5nT6MEiwNY/jYcHr4AMfwex/AAYvgyxRka8odqh0u1z460+TMKaLLvdaduyNXc0Sx/dgRNVjg8
-        MeYq33ZH46SC7fZHh6/VjOEUe3hvNFyt+uzUnNuL5PaTcUY8I7bWbZFWuuq+lhnEA/rpDosTW9ld
-        n+p568vLXIdFc/6A3nCn46nltk7SnbH3s+NNzg01uxrZVzBOzpVN975C9ll3dOUOD/L7OkVEZGAK
-        If6gJ8+8WYsejmYpTg1f+oMaWgrPgIzPSMaJz/V79/7EX3eHQuB03QJOK05Wfj7kdncy/QSHVg/K
-        GF5H57U83s3twDg/P7z7/F6uzcQEwwY3L2PGyAMhF5hWowe7gEOVTLj00KdcTG4clXeJeBmJt2Yv
-        EHOnwC+8tEofij6tyCWjNnktmD+BtlBk5JTWFLzZk9mnlcybYpdWwRC2VHhKaemhrstgkGSs0rmO
-        Xkhq763JOBHs2tejKgbq0muOyiT0gp+S3PpqJSbuOl0q/tXlgeMIsSlK5fDSIq/VyiQYRqYdcmEV
-        nWcsRd4a1Gg+xCB3ZS8FwFkuoVWiQb7OYEqbvtQgvJOf1o2zisWPtTLIVCjsskISFkXWl4Lxi/As
-        g3yhZ0BLhHmlVCG+5yaXCC+8/isU9oaUjT9NqIXcAEOfdd2vZ2gC54KhBLkyxivIKa51zSakJvBQ
-        lgOXldYCYVvkT5k1RGEUWC9X0mqb6/pxgZLIyDCYKH0KdTnKKjqv+PFh32DGKDmLnLkMYRToktkL
-        Xl8D8m7vYkJf979rQt8inIc9CYVwtovPvHYsc8Hax1KTGYSrFbnK3K/3JGSMkmQ5rYqKUwFTXnfp
-        SNeao0K1x1pGEuprBufr4kIsfU8m9w/xS2vSAvMR3kF/a1wKBAq7DNiX5KiZQQYMvaxlYLxcl0Yu
-        Za1QpRo2GfKtBTiRtNQehrYkh8WL4HktuQjzaOKj7N9E8nKldi0aJi90IBORFhCW5lb/JowBrVm+
-        gQCFBkOWXGCIcS9amFYjuCA0ZviBpfZBrndzQVkcA/rINWxoRV5LhBEsi8hAnGMpDKSyVo+sSB54
-        /1wWPfcdW3iOZSMt9HXjtcRc0hI9DHNxsS71IMvEVEcQQjhOhWSp7YitfQuzq8TW5x4KZBCXcoJh
-        axywhUzM8KKiVJmBRTgV4PFECOSPcCrSU3HxiJC9Ca19LMVtvAwrYi28Nix8gXIKNzO/GLAellei
-        wxCxwFluacS4rtKDiXGRmML6pEFFMrl8aaHnlZHLtgReO+9LPEEY1AKvqC8mzqXAYN2atCbBDfTA
-        +6otpDuWAcHfileDZ69irLzcKxzixx36HnpfOaaJLc/dYVuiefBha9GwVmF1qrzZjIDzBSHn9u1/
-        6V3NX1//g/WySl8wuPgxR5FCG1iKUN3XtfohVTXSCT8UJbZKUS3w3u1OUvDPOunEC8xwJTe8yElV
-        j1TArMcFoGr8JEEeu8gGDFkQYxu933NlbJfkEEwb+LNThX1uoOVKFknvXYCTb3fkEBcQ2YepC9IC
-        ODV4JTkTABAV+R0CuDSWE5PUumaSr1ZUCczSAm4ipsEHarkEKSi6QKFXGTKt24JgPUQJBURWvg5W
-        55nq6zoP4ARLfpHC3Aet+UED6FyBlq6aFRk0kYTAfrmEdSKAKvqyYF46HPCVWERaoqi8MZLonxZj
-        9wZ14V18fqxBt+iRZQcw4GUvGBxADIFBxgn/uY8EgG055vi6jsYb5bB12ufaxgZuxRCtJl7/XhWV
-        fOXo8FFYjrCO299ZvqiBAFWbbtz38vr0BjJH2ihPozRtwVrKyhflHTlbisg2M4P6WLUwuHZ+NGdq
-        RZK5dec3AFYevbg7oS/jteQq3ouMKvOZAY3l8VeMkz0YhKIWGaL2xj7Uht8DIQFrYTBbcAxpjO7r
-        i9wg6/mss1wrABmiQJjrrA0PScAh0nlrkQss6gikSLYS+Z/2ORHEsqRLkfpVgc7XADe0C32wUIZ0
-        JB5rMVJBg7E1esPnoQZUBxQXZafe/SxFXNayDDkQ3filiyKmO6QChZ8wIe+n7zJex1j8ogG/hLEU
-        ExYVKaoN9/cBbHCpKQ27goZYy6R8mx1rS/x+wHzmAm8RxkZPxVi13uO2BZPS0ecQHW+wOnSHY85q
-        dU0ulQxwQ02D5xb4RkIe3rPeOuU8WNvIqqrAry0jli+962u6gOAFvsdNk1wTR1bITDX2fY4BRgiX
-        MUfTo9/wawPmOZdNrRoVMER60UweNMBSX2smTyggKX7tU7iN33kXH/H/ucCH2V+KeyfL71ckgxVu
-        Hxq7a5i8GNhBLywGqUKWlpioYAgrazekyUU1KHyp6z2hcfLzL6+0Qq6bIl1KCNZZLIPb9ZPjIL0Z
-        zy3g2JCPishsnVckYDjIwaY4mdUJsQTshlvree/vJwSo+Kzja2eOCUFIFNvzZUt+aGa72dMWGmKP
-        Sd9b0IoRDv9I6olZZEt4EVN2snMdC2CmDTtDTNuwltscsPO8FG7X9BBeEzN5CEt3EJE1LCj9fPco
-        Tn7vZQtho3PGZXjNvs2HTVCcHneAXHtfoxCtleUO15lCgKxnX7duejK4JsR4EKCbkdB2fppJQ8Qq
-        NaRXkYXHFRM8fXrWAw4NxZf0Oz+Xt2A58JNbC1dTIIpAwtmYAa56WuACkQxsvRuVpgGv9Cwr4Hwk
-        2BDnoegGfhOhlKanFKCY+DmnuF0WjykUWvl8fQYbQZrSgrd8rqZhbWDtaM+1AO4NMC9NSWoi627o
-        5Oc2ooa3dZKZehBW6WJvp/fA0I0ph1gDC01A640ZpJ4sRnxlQATjxBzWJjgyMUCwplFpBhCahpo0
-        d15rhXUMiVH74C90h/ka84C+6mZIEvmlId2ZZJ2OnwuqSa2M40IPEWifFUUufz6Hv315k09wlisC
-        rR3/kfmhGIbzqMe9kfPy+0Jq+jxvMaJ8JSS9FNqY87a2Pr62K2yVid3LvVAKFmb9nMaxLAfS0ot3
-        noisrc7nKD7h9QYxwKjp5bR05qdrGuYKz5NjzpdIuqqbkyWesLzFPhzTGbAgnD0bj0AHpvEMi2Hb
-        CdAd5toRZBXg4IW3VJdV2t2Kv10Q/dsF0edzBl+++0JUdPf4+PB489WHz+/effnyv5r+x98ZUgAA
+        H4sIAAAAAAAAAO1c245lt3H9l37unPB+0ZsQBUmA2FBi+cEQhKCjaUkdz3RPenpkK8L8u9cqsnrO
+        rtqGkXdDQGsPDzdZVazLKha5f735/qe755ebL369eb7/8PEtnr799ebd/csdm77/+Px8//j9Lzdf
+        3Pz+d1/d3N58+OXdfz+9xT+//PLrf8e/7/+M1x9/vP/t3bt7tP72N79D48Pjh5fnj+/uH1+++eU9
+        m//5P37/b9/8Ab/88PD84eWb57s391/dveCXXGrps4Rwi9l//Pj27vk3d89/vH/55oHDxTZr6ymE
+        eHvz47uXpx9++HAP+v4hFnnjBZ3+7+lRJvjqmytivtk/bKK+fHf//PD93T/+9v5P//WHp+c/3pjJ
+        vsavnK23Sxi3Sx5fP9///PD08cM/vX36wN/SvMx8e/OeXf/14RFUpNstHeHn4fHHrzHL0xtK7f3z
+        Pf/n6Xt8s5jquQZy8OFFRC9NsSY2OT4/vVL7N8aso9gx9zRnY75/+vDyNwbsadgB9xx+QIz45u7l
+        7l+e7x5J6sMLVSa+oai5IvgHHn++e/vw5j/57w/QsvVz5Z/47gl/s/xt8jf+gj+Jfyr/xMC/v7yw
+        87u7P99892ktP2h79x5jRahJr40S5OMoqe3HmWZYjznEWvZj6mV3yLlF7VBK1w4157EfMeoeN89W
+        d2sJNe3WEvPYg5WU6h6sFBCxH2sP2qHheT/2kvdsZaS5x61hKL01dqW3pha1Q0bv/YgB9ri1TaW3
+        9qH01tGadpg173FbyHOP2zDv7tDyUNJb6VE7VA63HltRhtocSm8PXaXeY1Op91SUC3KkHepUensb
+        KnU8q9T7qMrFiFHpHXEqvSMNXYCRuy7AKFW5GKBcW9FRW8dQqY/ZVeozVOVi5qj0YiqV+ixTpQ7V
+        Vy4mBLHHnTNtevE3bqnjcW6pjxDH5gJr0jYXA6oztEOLVTv0ELUD+NjjQgyb3hFTnNqaw5Y6HueW
+        +ohwpXuw2PPQDiMV7TBj1A5zbqmj31AuUi5KbypJ6U01Vu3QwpY6HodygZ5Kbw55L8DIMe0FGDmF
+        vQB4nMpQrlVJzy0r6VjXqh3Avo4LjdvjlliV9JKKkl5y1gUoJeoClBqUoQJF1Q74TzvMrAtQQ9IF
+        qDEoQ7VUpbfWrAsAV6MLAM+tXNTZld4WqtLb4CF3h5ayLkDLUbmAT1B6Ya9KL6xCF4Ci0nFnUi56
+        akok/JVKHY5HpQ63oVKHaSm9nS/ux1lV6iMUlTpUSrkYeSq9YFlFDYJV1JhZSR9zKpETJr87TJHF
+        ekxVRQ0VUFHPpmaKRzVTWKmaKdZdzRQzlM3FBAGbXjyqmc6Q1UxnKGqmsPO6uQBhaqZ4VDOdYaqZ
+        gl01U9hK3QzNWNRMJx6idqhqplN8/36Eg93jpqAWO1NUi8WjWizWUi0WnqQpQ1AtJT11tVg8qsXO
+        NNRiEd26MpSTWuzMWS2Wxpa0Q1GLhdJ3ZQj+Q+nF23sB8KhmOkvsykUpaqazVDVTLIqaKR7VTOkS
+        lIsa1ExnjWqmsyY1U8YmXQBEAOWiNjHT74BJfgbM+kC48ubh54c3gCjyj8/BjP+6e/f0kcAsXFIW
+        NCIIUnsAMHx2I6Z7+dxde0h3Xcu/3l17fCIAenh8A5j58vQsxP3vxyf2AZj++entRwLRbyNceKTg
+        b2EXMZP5gWBBK72FiQIK4wERFbqJB9jbFJ2hsIkKbnvMnfZyy6A8u/SBljfp0xZcg9uBLcvIKa0p
+        SGNmn1YyLeEWDmdOttQSg7R02IhoTCtASdIZyl1IKuJzk3GwyHkvP5AHwKVMi4DMB/yURKtbgdvn
+        kBX/6vLAcYRYaL683yJhg0yCYWTaIQEZnWFrRd6CrhL634I+wQK3Bd5IjKxWqBlfL2VOopbbGkR2
+        8tOyKKCzPBZnQHtCYRcOSVjkCuN1jF9EZhnkCz3w5kmEVwDa5PXcxEneEt4Ihb3FRqO8BQhajh19
+        ljsDQMwiDYCwICZBiJXi4gvgUQiDDIWdCviwGMyBqPC2wFCiCAqiF5MDrFvwCn6vy8gIxVH6ICxN
+        kXMhZVMeNkLDKDnLOpMNERToktnhx+IakNhlCaEvfFsT+haRfM6yuCUCAcnrhFUyVwVdS03gdoUe
+        ZC1zv96TkIGoLOy0KipOBUx5+QrSteaoUO2x2EhCfUXcF32DFGLpezLxr/ilNWmB+YjsoL/gQ+YA
+        hV0G7GvlqJlBBgyA2EvQseS6NHIpa4Uq1bDJkFxygpyl9jC0tXJgXhaesKuI8BpxQ9m/ycoLZFhM
+        I3QJHQWphUxf4Ju3+jcRDGiFkXDEQIGsdYEhxs20CK1GSEFozPADS+2DwFcylMUxoI/ATGhFXizC
+        CJZF5FgW7iiMPov7MIs8EF8L03NjCHiOZSMt9BXRkcqUtJYehrmkWJd6UGRiqoCvQSZFSoGVpbYD
+        V/a9mF1XbAirSHJ6XMoJga1xIBYKMQ9gTM6emeiIpAI8niwC5SOSivRUZH7CpJrQiggvitsY7GVZ
+        C2GRyAXKKdLMzIjWw/JKdBiyLHCWezViXKkChBgXiQDCy34SUoux1rDUJfGyLYGwuq/lCSKgFgjB
+        lxDnUmCIbk1aOYoYQN9QAqs7lgHB34pXg2evYqwELyIhJq99D70hFU1seW6AY/GcFT5sMT3IJH/K
+        oSwXqiCScXmuAPr0/v6RASgjfEGiE9EG6gnQBvVuF2I3BASEG+h3QVO/xIQWTJYZ/bv0oreBvmM2
+        znTLscTpxkSRAO1LU4J6UQ7ErBNj5Ygm/C9fyDf8LeJTlJZ0CelISi4XAWIINJEeHS0gjr4aEoXx
+        w4VLJ1rBdafqmMrjAt6BSOEs12slXHIgT1iJOvNuspyXfIEzxVBEm1Dn3YLpgHPhyNEVTeVCsYbW
+        mfl38F3ShW9NRGomTklem0Y4ZVyuZ5ORhpNBTRfZIrjiuIYL0qMDndWJEy3dCKHMSznSiZHg0q/p
+        xHRGUBhIMCdS0wDTrE2aajguK94TF6qd1uDRCAEct+PgAYvHPggx8LR8rXQ3H5oYfK8F3C+B0yFS
+        Ru5woKVZXcGy5KNMKF4KLiPfhr6NJaVhW8zSgbVhNIUCqKYJqu5odO9Fp5lokr2GVIgZmixdcipW
+        m1XyWi/B6kW/ZGMcdV4olCs51WHlxJZmFnheiJEPRHWnwBz8uJwtXqrR35YuxQzVykUSUYRGJjZU
+        n9YuBxKS9GJ+AxqngIS2xuLwSXa1ZEkxY4kHA21eE9GJAe6adjSJU/ysHJivGlVs1WknCI2W0HoZ
+        Rxm35t+rVmHZIn/t8reMrke9Oes1LrKndi2e6bSre/tCr8Wt9XXoS/gxK7dOEcIwYofAbVO2jLAl
+        HZcTTcOsAZra0bF070l7vEzDFJqM7XO+W27OZ8tA9gxgjuMyYzwrEXIZDSHZmRImNF6+w96OpoQW
+        4zxGdB59JKt6fTrb6sOZDQa38QKjV/lr7Wkkq5MjW2NFi2FotEtPRwGO4mSDJkdHdrY66qUe9WQ4
+        D40+VgkH3Iwx8TGt75vOeKePduhkAydGGvm49jN6/qYDLWiyqoombvheEzrDZf1NRoiYxEoMBFsv
+        hSbrWqZ3QLP4XtnxwOGPskZLOyKZ2ZzdYvCTTsYZoSmZxSadx8B6Jn1oRHJqas0TYjWebgSLGtDJ
+        uSUf+7qPWLAqA5PQyVLAFuNYko2i3Uff3p2kMJ3jOFgJk/IjTcM7bRHL0bEUF6JhO1a9oaU2Sozh
+        ogSastFPMBiNeoMbq7Kk1IrBzwjPaeFiL9uHu3U8aepOit2bKEY0/qY7ZUbLAZEiEfp+1XO/BYeX
+        YESMHCcbYMReHIJbZwF/blkINnENSU8sR2miyTpWJEBWTtnbMZKbbhOo6haeCc8xRkoKdJRZ7taM
+        SvRIOzkAh14WHhYXOUp1brtImAYIT0eAja4WxAE726yulsvCy1Zu+KEZ6aLXPGLA6lwG+gSbsniQ
+        wlzHgP9qHSlThqOwmaKZZGQ4LUbTNIuLfMyaHbIYn+kY5tBi1QQydclsdfNVj0UoA8NedEicCZBL
+        2yxWBn/rB7sHQOmYvmiyMA9ydoshAJlJjRFS9Ti39pOsxmpkC7L1UL0DxOtWqdC52yQlOX/QPBZi
+        hnB0O0DvNtfIzqwbvdVxvZrfEQFVNtcIZwmJzU6b8xBsMabVmlu81h3pzYuqOiDRnNmQZSvPEykM
+        p9vNAy2mMDargfodEQhIL8e9DRBlkn3AfItS2LSyDkNt9zl/JwMCD9woyQfG0yYLdrrLExmJbZpU
+        rJsCvY646NBA93bXvTcmIDFop1/+Ci4ZbgOpc22OSdG0usdMxvh7DOTwYnD5idutYVZjHB/TmiNJ
+        SDys7yd6OnpVoFPXySdInS4J41mNHD7eAlRZPCiZhfzPqu/024Mz2d06YGoL6qPbYkL64Ygbl2bi
+        PIk7rhKIshrPfMag+uAUlpQbnWIyZjOgepa1GOQNbiyygRD6msSArCn4AO12YwczmUiAfMU4AvSx
+        ApnJqi2oMX58nOxODL/RMa2LRie7e3OWm3Tnndx+bXc+jdjaepWFrYvH4dV7hO6iwIh2B1i2Wo45
+        0olGBcckjMyMNHycHQ6WDsf28NlPcuiGaYLPv1wSM10MJ3tmwYrzWNVtcHTvMM5WdXqvX/3KZAdW
+        QINVB7MHjOzlp4cff9plHAtD0nB4IkHD2iF5YX3mOMlZDhJ9EccXAJCpuF7OySIHsfN5TcptVYiG
+        QxXF78qdlWP8LjGzkCrI2Wp7cdtULBsYKwEqt0Ry296oVnWJfPU7OtXDLqY6Zm+/uKQjOqKqF3j1
+        GAvzVSkf+CwmrGGPql+mqwgFL4/ubL1MVyhz23Zn4nf5TvVJaXUGCt5PMhmXeRQbv6TedSSca+SL
+        aS7lyCt1aK6C1pxjqB7dVJ/pteTmZfXE1Ai87E/yknpSCoiu3JA8uF8ViGZtsjUXJ07KF67oeZau
+        nGRM6ay64Qso1tCZUZi94uYTYaQB1h00F2CaAwTM0GwS1RyybL6uzLTDcjM9JAgubAe3l8byi6lk
+        dburiqBgQ9VppaW61+zKdF/tYi+f4NhA6M2FWYUNXtVtEZ/Va8pJaccijWTre+TY2BKjs83Whsdq
+        82z/0iKU6AoJstN6RB9nrxlBcdfabsYmD7ayr4AUt304ipMdchC3tdwcy8NXK5GpuIKHK6YPj6Uk
+        nTl2Gp6q6QsdfosY2N3ujk13fgGA3BbzZvIFi2T3eEGCk4IrgrOAdASU05fhpw/xoNz6peli9Ry+
+        AOR3VvCey/iKA7UUlU2Jqjv9MbvdD8CEtkLWXJCYvtw3/bb/TK5w6CsWLpcbwSfEwZf2wqVrOjFN
+        hcftjJwUfdymD5MAC8p96glf5Is+Lmt20ZiZkR1pemP1e6NnFdPu/DaLjMarTLdLMZ1VjJMUdJx4
+        I+uQR7BWQbfmxGLjjfcoTEGXdzWue57UuY3ZneRe3cJGFt4PloLE5+3Tn6RoU46oM64KzdX7bd6y
+        F8/IXZ9VS/74Q5q+yZ0a4xm3I+pBdmQtFE029UIqZESbqz/u5uE7syqzwZH9MYDilhLJk90YKr4I
+        zRKNgejJKROaLOrBUC4PGw7/+y354GLr2VE2t+/CooIpgUwnlurgkxSBTCaRTo7JnZxbczLw29LM
+        gWzi2Z2RIb3shtDi9nBOjq75vYXiYU9x50+YBJn8JFrFq/FkXVxe1l3GW9zZlupLD8V5LNaT7AoX
+        X4DxoAeZlc3eTg7Ueb9dvWetLgVAWmz9aPXwsPmDNS26GN28jfK8lhFfiy7JSZJ+BWuDaHGnK6ez
+        nJODb9nlnc0Df6Y6vn5jaycnFSS/n9g8eG1+67e5o0hnp9m6NUxkVlZv0MnXeFy6V1ze1oOrM/Xk
+        Fqj7wmf3LpMvmkMFUbZbo0N43a14d46su23n7s91IOOx6aM/R4qx3SmJ6EGUP8x7toPcvMCaT/JO
+        DmG4A7bcsT6pL/mjOnbLN1jwQPhoJDz82dLhc4Thz4YNfwL17KCbr1wPd4rqrG7k9/jQZN/rTt2A
+        5Fz9w++9oskuDssyDjnajOAEAbr9heGP4Y7hFHt4bzQc1jsrTblcnumbcUYsxCy+bWqSLpoXmkH8
+        rvB0JzJ4bM5mTdXL1u/wkA97UM9XwYY7gkItt7C8O2PvZzUE54aaO9rUvZNzSfzG5dmnTdGdZPXn
+        N/vaheehL3PG1VdTWViyFj0czXLuePhT3VBDS+HZGTWPSMaJz/V7X76s1t2mKpyuY+D0MLFdPx9y
+        uzv+cXLEsPrzdtmBVdmPO4rQoqTvPiEXunvzP3qK7dfrfzDJqbznN3ixacxRJDsaKUO+fX0SYEgq
+        xDtIvWV4Q37zQlKhwPvDQT6gIO4RTRXut/EGVkpN6jSAf7zF1XLKy8dk7gQmflIhj50dIfgX/M47
+        oPRNOxVauRSk0HhL8PVSEX5qufIGFFbnNXHiHWBQxsvV6+Qci0gFywlRhCQEIwGqvLkKVa1tI28o
+        eWLYPJx3S/VYO8oQI0x8JY/rHBsvX5WcMy94CfBOWKxUeCtfGE/yonz0Ai4dPRc8hwbxGt6qrAW9
+        /wL1hY3GRB7WaSvezlpKrcfSRi0BXKS1HJX19MT7h5E39/K+NFL4LQF+bELPX8E9Bkjgcx0DIpgj
+        5N7j7GuBmA1k2EWO1wkQb8T3PLly61QYAAeGaDW9SpjVDjxAdBMhkivDKylZvggyO2WwMr7Qy7V4
+        YfK8g8fFbNoCXsoydHlHNtX7yDPz0u5YSUzF7/y4hi4LnWLnNwyWA1z1uwl9wTL168Idr7MlMeEl
+        gMa9qyvBSS0zY6LIK6jrBBxiXOH3TEjAYqxUsJhKfD0mJ+sGI99qWBaviKQTaGMuVeXFpTp5RzZr
+        dgIR9dzzlZ7I3a0EQKGsSOJRoEw1lKYZGqyUV3Zz28xI6nOwtbQu6fDbSEXFqSfjSpEricRWuxLU
+        +KUO0ct9WA4/YULer9/5F8B24RcZ+CWPpZgwqcil2jhtV54gpfbZ3iX16WHSm267Y1LA7x/MVynw
+        jFVsDI+8i7re454iL52PPofoOLIEaGVqaWY1vCYl9wFpqGmwGsY3Ehwo3NI+k8d5wNvIqqoAHnBA
+        detdX9MFBCbIPW6a5BDtqxdaszGywGfAiLXmFSA+mOdcNrWSCzj/9FkzebQPrF5rJm8NwRPkK83k
+        mcDOrwbUkl8zs+Uj9zAn7PfLrFCoFKCxO/nksakOemExAOhZWmKigsW4t7GaHOOBwpe63hMaJz9f
+        c6UVchivYxl75y3cVUMJk+OMEsZrCyQ25KMoMltnbRiGk2BlcXk0doIfhLinhgpWiHoL8VXHJafJ
+        vPAbEpft9SgaP5SzPe1pCw2xx6TvrXDHu7T4R2o7eDA7SngRU3aKc0VO3qSHnSGubTzC/SnYeV4K
+        t5OxBlZ5Ux+LpXWrXjcGej2ZATRZXhdhwyreu4XX7Nt82ATF6fw0yPb+PPNT+DWGUjXMcWsbC6q+
+        bp2DI+JIszIW6wEVaDs/LaUhYmFEfuKM14B33gP+C6/nbz3g0FB8uV6fX/MSWA785NbC1RT4lYA5
+        iUfSPj4XyCAAwdY75CUwDXil17UCQGvwPRDydbYEefMLBKXpzSEoJn7OKW6XxatDhVY+r4tPiNJc
+        LXjL1zQIvEG0wDoK4ripw3vnKQmYXSfnJj8XEjW8rRIO9SAszLmvuPTA6I0ph1gDMwTE7sYb4lpS
+        QXxlQITgxBzWxZQroLDv7UDNh5o061q1wjqGxKhd8YDu8D42oMDaKwceAm0jD91SZoLFzx3VpFbG
+        caGHhEiqKHI07jX87aNtfIKzXBFo3cIZmR+6YTiPWucaUBB+90ung0KPKN8zSZ8zJG7RNIRypYC7
+        m2O8KjhG5sLCrOFLdzIDzAbS0mfvjCQI3M/XKD7h9Qbv+I+aPpeJMj+90zBXeJ0cc36OpCstncTm
+        YXmLfWGtM2BhcfZsrP0EXtNnWAzbTmrtmGtHkJU5wQvvVV1WabeZ/n587u/H5/5/x+c+ffeJ6dP9
+        8/PT880Xjx/fvv306S/jE5s5/lIAAA==
     headers:
       Age:
       - '0'
@@ -200,21 +201,21 @@ interactions:
       content-type:
       - application/json;charset=utf-8
       date:
-      - Thu, 21 Sep 2023 15:54:06 GMT
+      - Tue, 26 Sep 2023 12:12:58 GMT
       server:
       - ATS
       vary:
       - Origin,Accept-Encoding
       x-envoy-decorator-operation:
-      - finance-chart-api--mtls-baseline-production-sg3.finance-k8s.svc.yahoo.local:4080/*
+      - finance-chart-api--mtls-production-ir2.finance-k8s.svc.yahoo.local:4080/*
       x-envoy-upstream-service-time:
-      - '40'
+      - '35'
       x-request-id:
-      - af4778c0-800f-4a0e-969d-1ad6abcd7fbd
+      - 1275a198-8d33-497a-a606-db0d28f9f018
       x-yahoo-request-id:
-      - 44k8ok5igopou
+      - 69p8ss9ih5ima
       y-rid:
-      - 44k8ok5igopou
+      - 69p8ss9ih5ima
     status:
       code: 200
       message: OK

openbb_sdk/providers/yfinance/tests/record/http/test_yfinance_fetchers/test_y_finance_stock_news_fetcher.yaml

@@ -5,7 +5,7 @@ interactions:
       Accept:
       - '*/*'
       Accept-Encoding:
-      - gzip, deflate
+      - gzip, deflate, br
       Connection:
       - keep-alive
     method: GET
@@ -13,47 +13,44 @@ interactions:
   response:
     body:
       string: !!binary |
-        H4sIAAAAAAAAAL1Z23LbOBL9FZSqUvtiSATBq990tRVbF1uSb1spFwiAEmVeFIK0LKeyNR+xL/t7
-        8yXbkJRY42RmFCeacrlsAg3g9EEfdIP8VJFPi5hFqaoc//vDUYVnZVpUjgk5qnwss0Lq5k9gw2cs
-        ncrKcaXfG1WOKmqW5UXKEt1SXyxiibopr1a2g8arhe5oX0y641ttvUqCLNam9eE5PEepkE/wuF0B
-        DHiWwwir6lrUpm33qFLAFK1ILfQ0H8uoWIFVnKXT762p0W1t+/VRq36hZ5S8yHJoGUs+S7M4m66+
-        tm5t/9ADkEpV5Ctob2apKhOZo3YM5nmWRlztWGxH/4mVgN6R5N1UdGI2rRwXeSlhrLplsyzrRClL
-        udy0fj76G157Ec8zlYUFamb5IstZEWXp31LcG3XGf0ExqXo+IWQPiv9s+V/M9ghWWLJc/v7bf7tp
-        mDNoLnlRAtZvKP9L0+8xDPGcyuUmhMsyEjCHJwNCmW9gyUwHUzN0sWdRF9uCCNcybde3HJiuiIp4
-        HWcJe85SFCmUsIconcKfeZajJHuUCuXRdFagQIbALIoKte0swFMEqspgnkUZxJGayTU3MzkqcimL
-        Ks8SzXWUPkDzrCgW6rhWCzfQqyvthzapJbV90NbYGiOOFN5gxGsYeI2xOiuSWOPIs8dIyHy4wTOO
-        9BYTx7eJbdmOsQkGTfF4cKnDqZiVSZCyCCLqUyWXKotLvf1bKvN4B7eqrqJkugZcljW2iGpgXyNV
-        s+bQsXN/dpmJRnFSfzqvc6crnpcY/6dRYy3juf88WQ4o9/vj+rLXKmb8tLG4axFbnHTm7DR+DKYY
-        176skkgRseqzTEO1XkqmtWIm1Vc+ay7lVEpHOlT4JjFtIm2XWRZzLWFYgnrg1DISxaxybBsGODyT
-        evcqx9S1tftaq5UMdhR2Ia5obe7r5ShoieuRaI8fvNOz5dg5fTovlxsv75IH/y6JVdAqsuG4bYCX
-        S3ntJ3dzY+15b3yxHJidJT+JH4Y3sXF73c+gvzyE18TacXr9sPEZ/n2C38rnD5+PYKdjVkgxjviD
-        zPVmV+q9uz5Msj1V1uf3hzU7Gzn5wjCIFAJbdggBGgqCfeGHmAtKqLBNU9jBjpwa5Qq9nCujIuMP
-        R6gOjK8UPLKVqqJ6F11HcYxOZCrhzJHoFCDDMTvMsxA0Vn0lqgbL4exV+0tqH8S1oFzh5AtOrDTO
-        d2YTsw3SfURFzQOJan45WfSycERntzfcWJjPK1+V0y+iMvutuiuejafefPrDobXDZY26FieB6Vie
-        E1DP5j6jvuUZpi3skDuhsxNYprcTWY71c2oqV7L1YD6cLfldL5pn593B/R2pH0xNb3T5bVpai2hX
-        PTaVhmsEEoN8LUypKbEvTYFD6bmeGVAmKN9NRrro+ZdC0WCEiIt6bIUaEuSDJotpzoQ8Qo2ygGeR
-        Z5FAp0ygUZREMctRRzKdJxW6lSxXqD59nZu6KSSLIltohvbT0T7YYWcB8TvTVTjKFCYupKYVhjEs
-        /XsNWY5jk8NoaHAz7wA1DTqI/baZTbyiyZvTl8Q05/YmMU2eBuMfT0zRDpmbNiJY4DHHCgLCHOKY
-        PrdCl5g8DIRLjZ3Ism3i7+Qmx/V/Sk3sbEG8+RldlXHDzp7ipMn7i4uDqeknHH9retpcKE4Gg5NX
-        iYlIYrLAwS61TEyZDjoC/4XCDKnnS8ul5o60umkh43UGQu1Hma/QsLlJQ6MMyj9QWZMtWABXjixE
-        l2Wa6lIQMpVWZMTZJgJ/NjHtgRgYBpxYAU4sNU684HgJOLECnHtoyjxYXmo3WzcfefQw/9jvR7Pg
-        Yj65D27qvzwvcUaZhCAKhQG1jwmnnulR1/QdiKggDNxD5aXJjRq+d1gn8WbmdHx1nQxv2qfTfyQv
-        /YDLbxPR6VDf4Vrtcy2lbn/cfCn4+let+h90ZQEOx7dcbHCTYGpIjoOQSOyyIPAtGlqCeTu6mowQ
-        RFnzbISvmVZTgVQMoakQU2icS6ZK0NoqkrFQKIzyBLGZhLwFKutIgRYZqGuFEqh2X6nrUpaFRr+H
-        svQNsFaqTRWn8JJptUBRt8aBiWOZlmH67h7iIe53bkrf0jlqTG50rbypnFvd0V/QyT0jMAUXWATS
-        BzoZVKOW4WAr4BaR3PRCbuzQ+VI7w+EDoQnZnAMhQCfnADotwLkViiV7QNQbNzSPQMGCpSskWMFe
-        kdjJ8qJM5d4kvlTELMI7q+Pd1bFeHWiFCsowbGMfWm16oDOpOry9ft++WXTqy+C8kbA+XUVXX/P8
-        U+/5lqwFOq8bgzdcQMMNf/fEtWvS8Qh3peNazHCYByoxOHUJNzlkdMsnLyI1DcvbUSl17J86mCzT
-        H6Q0B/iroFfct+6Dejc43MH0Np9/VcHsEho4PDCxHVC4vDHBsGd5UHR6nsegYBTMIt+Ty++//U+/
-        nVEqepToJsieNhqJQDgpknDU5ijUb25mErGpfJ3K366T7ZL4CZbcCGO9GMgDfmzbcPaQhwFUH0Ye
-        T/wsCkWh/NOz+O6KsfeZEaYXB5GHZxEPLt2+G3qWa5lSBsSDVBY6xOUEBHEweVwtn+Ph4+NQDGi1
-        Iy/vq6q8CQ9XAb/N518lj5AaJswcQkqWElPBHcgmJIASkjDf45YRUPv1fXItjWg4y1KJiI1aMmGp
-        QF2FBmWxYFwXuqMSDFdHm/J4+7bmZ6vdfaBur49t851nvPN9uEQuNExMbCzWMHG0xwtO6huHqnnJ
-        1WTeuKXmwHs/pNO5N6vejcnyl9e8jmSBHxqU+ZzYoSedIKSSwlErDc4sYR+q5h2G3XL0nITlpXOV
-        tPPk6v2yevbP1Lw/4PLbtHMyenmdqT8TsMf1zsPf7ZeV3uR83L2YDMbtr19Xdm+cW+190MGuiu3H
-        sy810aVcwDmwbVQ8l/pdZkdXuZdSlfGXniKDimkbqaapdZnIMXuQKSSci+3HN8ujf+zorz9o+PoV
-        9m5zPZ5mS1bwmYYDw173D3MpJAhRitEWz3eMmnmZ8lnAFCB61dXXBH0z4PK1w6/6R7u+f9PbBCrK
-        nMV1peR68Of/A9ynVb2OHAAA
+        H4sIAAAAAAAAAM1Y23LbOBL9FZSqpubFkAiS4MX7JFuXcWJJtkTFsreyUyAJUrBJguHFspzK1H7E
+        vuzv7Zdsg5LGip1JNM5mdx9sULiePujTDeBjiz/kCRNZ2Tr+6/ujViDrrGodE3LU+lDLiqvqj9An
+        WLIs5q3j1ng0ax21yqUsqoylqqab5wlHZ1nQbm0HeetcNfQv52feteq9Tn2ZqK7di3P4LbKQP8DP
+        7QrQIZAFjNDbruGYdt8+alUwRU+UuZrmQy2qNfRKZBZ/aU2Fbtt33J31updqRh5UsoAajwfLTCYy
+        Xv9eu+37WQtAqsuqWEP9qczKOuUF6ifQvZCZCMq9HtvRf9ArhNYZD86ycJCwuHVcFTWHseU1W0o5
+        EBnLAr6p/XT0DV5HIihkKaMKncoilwWrhMy+SfFoNvC+QjFpW6btHMDwH63+HyZ7BiusWMH/9fd/
+        nGVRwaC6DqoaoL5g/Ktdv0QwuHPGVxsPrmsRwhxMY7ru6CYmlDNsEEqxS12CqW1Rm5LIIq4O01Wi
+        ShQJPblCb2TGSzSo1UpQsiQ5Rm/5GpwvShpSUI9VDJ1LmZaoW6JrwZOwRG/qNP8L8niZMDSrZHAH
+        A9BABjV0WnIWokmEejwR97wQzQbltZ+IcskVj2fZPS+BvJ9LdFKXAgCUsIpImj0S2R10WVZVXh53
+        OtHG5PZa2d8OZNpJO4dY2QnlCt8q23C0sQ1HYNtPRhff8XV7WaWJAlXIexHy4mIDzhPKN4jlUlt3
+        HEo3XqT2xptMlRtWyzr1M0DaOv7YgjllUiuKtntQJHvAy/ZapHGDuK47LBcd6N8hbb2zHlyLh8p8
+        jNK8Pzw5ic3JZD1bYfzbSYf1NDK+Hdnho/Yw6nVXE32wCobJ3cUi0a6vxpJfuXVnt0LKQ8HajzyL
+        ymYZnnWEHzafAbF96lvUIQ5zDY2avm4x37ICN9Bt3XLBlJUIqyUYq2naUWvJRbyEuEgtA4xUwm7J
+        QsTAfdJSQj7UNOIR/+YMvDq5WRtT6i3c5Poxbky7Se/cmzQp/V4lL7y+NupVKzAnvbnVVhMjcEfe
+        5X/DXHPP2ubHxlr4fIC/1qf3n45gY8HzeeiJ4I4Xam9b3uy8C5P8rffmTBXD2cUplPOT/hSK3tvx
+        EIruyfgEim2AOp2MLlrvG+420jRM8CnCNRyaLMCGYQbYiQwLvJKH1I2YGYXhnjSbDAD6KLdRAdV5
+        CKAQ6FFcLMGvEdFRIlIBQFEl0aBQMkEYnfAkFixDBY9rMAPi1ufam/K6UlYdoDQVXWB7AUiJdziw
+        yNXqmOh4uzomxKCa49rOIaoimvNCVS/5bhLpPnuWFjDXJTa2bU3DhqNbmEVahGFVFnFdCyNq7LHX
+        n6vQUvAK6Kp4kkBQajLqaX+iyJI5BxqrEvFAluuy4qmqLcQ9S56Hqj9LF69L7DcL42Zh3PCHAy6B
+        J40Q2zHIATxZmm2/hifKDNPgDseWzwwIjZqF3cA2MCW24RuOFWqutcfT/KLX9fpIx4OCZ8ESsbqC
+        DC0qCNngQAGH8B0i9sIJI1mgnYM+eSNGqciEymgwoC4C/p1UEhw1qPAeKrxD9eSQmmsQk2iGeQCt
+        mq2R19BqhIalmaaJQaUmNjSLYceJIkxDiC+aZjohJXu0DqWMwdu8QrAEzXKhHLDHK8gbpRLwjLMC
+        yO5nEGAh3f9TNYLnoStRLTe8HqEZS8s6i59R6C05uoI0Bim34LyC5F0XKkYflDYPMaITN9BxpaDj
+        soGOww30Q/i1VDb5EUlTm/ZGXv/mIe0X2mR+9Xjzhv9C413S1Me97iZp3sZ/OousytvmU4MIHQZu
+        qFu6HTo+112LGqET6YERRZa2n0V0Zy+NWE9p5FVJczEv3iWzd4P+Ylo+fLCnq0zXuz8uab7C3Ncl
+        ze1taDYbnw+gHE4mw23xubhczaCmyRhmbgDHOYMQ7Luhj6MAsNDANyN7/9A6htiAZITG4ISC/azE
+        k4oSbkslGhacVcka9R9YHPNC4TlGXdgPiPHPlDSSMNsaTqzyQPUcgrKJW1hGOGuw/aTbSjwKHRb/
+        W/mcT7LunUHlasWGD1m+6F5TI73cyQdkE2z86XZEJl61DH45yW96hIbDwS37Jbn3wR2/5lNpw2YE
+        ZDY1DLxJDywSGD7hnBrE0Ag14Z9PtTBkzpNr6QZ193xLt79PSglznfmiWsiFdZpR/U1yxR69Hyel
+        V5v9SkWN3/W6T0dMbzZSx87RzfiLsiJm6HMeBjhyfDhwhnaIfWZp2GLEDTkcjSOb7snq//EEcFD+
+        3x5QNVfRbRP92zojLtwUfozOontmi+L6rfe2fTWL4nzSHhDz6W4H6UmlKRPudvb14mTFri5dvpgu
+        r/Ul9eFC+zVnKzbk4R1XzcWHmnDytYmvuRq1Qj8w4IzsuK5p2BbEdf/J45zPrnm6810y+/XXxcXt
+        VX6ZzQvHvl8ls9t5cd79YTL7Psu/J3vt60nnVPfhAI+JaTrqaO3A7SOAG4kTcko1g3Nn/wry9MAE
+        p72sBOHEBQubC9yQZ90zBP5Z5jyoymNEkS9ixDaJCuUA4ssvJiJrtuNg/aQ7DLjBgLcYcMzBz/Hv
+        ALBGqUUpMQ64wWm2Q16+i7ykbxuj3o4WTzfk2ZnXB0rVuxW7b2QF5falbzQ/984u5xPosXvt2z9E
+        NNM1QwFPtX3MBXdsTtJTnstiV1kGcDLOeDFQ71RTXtbJrqWSFUt2puhqp1LusTueDWRxuX0MNg3r
+        84Zx88JmN3l5r7qbxHLFqmCp4MCw5+0XBQ857AoPZ1s8X+h0WtQQ3nxWAqJnTWNF0IsB0+cGP2uf
+        7dv+ovUUqKgLlnTLkjeDP/0b9wqa/x4XAAA=
     headers:
       Age:
       - '0'
@@ -76,25 +73,25 @@ interactions:
       content-encoding:
       - gzip
       content-length:
-      - '2298'
+      - '2135'
       content-type:
       - application/json;charset=utf-8
       date:
-      - Tue, 19 Sep 2023 20:25:11 GMT
+      - Tue, 26 Sep 2023 12:12:59 GMT
       server:
       - ATS
       vary:
       - Origin,Origin,Accept-Encoding
       x-envoy-decorator-operation:
-      - finance-search--mtls-production-sg3.finance-k8s.svc.yahoo.local:4080/*
+      - finance-search--mtls-production-ir2.finance-k8s.svc.yahoo.local:4080/*
       x-envoy-upstream-service-time:
-      - '125'
+      - '166'
       x-request-id:
-      - 17cd2ee0-1218-4948-b29f-704f91157bf0
+      - 82460c5e-69a5-4a84-b935-543d77237044
       x-yahoo-request-id:
-      - 457ldf5igk0t7
+      - 6v8bd35ih5imb
       y-rid:
-      - 457ldf5igk0t7
+      - 6v8bd35ih5imb
     status:
       code: 200
       message: OK

openbb_sdk/sdk/core/openbb_core/app/router.py

@@ -382,6 +382,9 @@ class CommandMap:
         self._command_coverage = self.get_command_coverage(
             router=self._router, sep=coverage_sep
         )
+        self._commands_model = self.get_commands_model(
+            router=self._router, sep=coverage_sep
+        )
 
     @property
     def map(self) -> Dict[str, Callable]:
@@ -395,6 +398,10 @@ class CommandMap:
     def command_coverage(self) -> Dict[str, List[str]]:
         return self._command_coverage
 
+    @property
+    def commands_model(self) -> Dict[str, List[str]]:
+        return self._commands_model
+
     @staticmethod
     def get_command_map(
         router: Router,
@@ -460,6 +467,26 @@ class CommandMap:
                         coverage_map[rp] = providers
         return coverage_map
 
+    @staticmethod
+    def get_commands_model(
+        router: Router, sep: Optional[str] = None
+    ) -> Dict[str, List[str]]:
+        api_router = router.api_router
+
+        coverage_map: Dict[Any, Any] = {}
+        for route in api_router.routes:
+            openapi_extra = getattr(route, "openapi_extra")
+            if openapi_extra:
+                model = openapi_extra.get("model", None)
+                if model and hasattr(route, "path"):
+                    rp = (
+                        route.path if sep is None else route.path.replace("/", sep)  # type: ignore
+                    )
+                    if route.path not in coverage_map:  # type: ignore
+                        coverage_map[rp] = []
+                    coverage_map[rp] = model
+        return coverage_map
+
     def get_command(self, route: str) -> Optional[Callable]:
         return self._map.get(route, None)
 

pyproject.toml

@@ -203,13 +203,28 @@ target-version = "py38"
 # This is an introductory addition of ruff. We should look to adding:
 # D: pydocstyle, PD: pandas-vet
 # All options here: https://github.com/charliermarsh/ruff#supported-rules
-select = ["E", "W", "F", "Q", "S", "UP", "I", "PLC", "PLE", "PLR", "PLW", "SIM", "T20"]
+select = [
+    "E",
+    "W",
+    "F",
+    "Q",
+    "S",
+    "UP",
+    "I",
+    "PLC",
+    "PLE",
+    "PLR",
+    "PLW",
+    "SIM",
+    "T20",
+]
 # These ignores should be seen as temporary solutions to problems that will NEED fixed
 ignore = ["PLR2004", "PLR0913", "PLR0915"]
 exclude = ["^openbb_sdk/sdk/core/openbb_core/app/static/package/.*"]
 
 [tool.ruff.per-file-ignores]
 "*tests/*" = ["S101"]
+"*integration/*" = ["S101"]
 "*init*.py" = ["F401"]
 "website/*" = ["T201"]