schwab-py-utils 0.1.0__tar.gz

schwab_py_utils-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.3
+Name: schwab-py-utils
+Version: 0.1.0
+Summary: Quality-of-life utilities for schwab-py
+Requires-Dist: schwab-py
+Requires-Dist: pandas<3
+Requires-Dist: envchain-python ; extra == 'envchain'
+Requires-Python: >=3.11
+Provides-Extra: envchain

schwab_py_utils-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["uv_build"]
+build-backend = "uv_build"
+
+[project]
+name = "schwab-py-utils"
+version = "0.1.0"
+description = "Quality-of-life utilities for schwab-py"
+requires-python = ">=3.11"
+dependencies = [
+    "schwab-py",
+    "pandas<3",
+    # httpx is already a dependency of schwab-py, so we can use it in our utils without adding it to our own dependencies
+    # "httpx",
+]
+[project.optional-dependencies]
+envchain = ["envchain-python"]
+
+[dependency-groups]
+dev = ["pytest>=8.0", "python-dotenv>=1.0"]
+
+[tool.uv.build-backend]
+module-root = "src"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "integration: tests that require real credentials/network and are opt-in",
+]
+schwab_live_token_path = "~/testdir/unusualwhales-python/.credentials/token.json"
+schwab_live_auth_method = "easy_client"
+schwab_live_symbol = "AAPL"

schwab_py_utils-0.1.0/src/schwab_py_utils/__init__.py

@@ -0,0 +1,67 @@
+"""
+schwab-py-utils: Quality-of-life utilities for schwab-py.
+
+Example usage:
+    from schwab_py_utils import get_client, get_price_history, normalize_ticker, Client, AsyncClient
+
+    client = get_client()
+    df = get_price_history(client, "AAPL", interval=5)
+"""
+
+from schwab.client import AsyncClient, Client
+
+from ._types import (
+    EquityTickerClassStyle,
+    SchwabPriceHistoryInterval,
+    SchwabPriceHistoryIntervalStr,
+    Ticker,
+    TickerNormalized,
+    TickerUpperCase,
+)
+from .client import (
+    SchwabClientMethod,
+    SchwabPyGetClientMethod,
+    get_client,
+    get_schwab_client,
+)
+from .price_history import (
+    get_price_history,
+    get_price_history_from_schwab,
+    get_price_history_from_schwab_non_df,
+    get_price_history_raw,
+    price_history_to_df,
+)
+from .ticker import (
+    DEFAULT_DOLLAR_PREFIX_TICKERS,
+    add_dollar_prefix_tickers,
+    dollar_prefix_tickers,
+    normalize_ticker,
+)
+
+__all__ = [
+    # Client
+    "Client",
+    "AsyncClient",
+    "get_client",
+    "get_schwab_client",
+    "SchwabClientMethod",
+    "SchwabPyGetClientMethod",
+    # Price history
+    "get_price_history",
+    "get_price_history_from_schwab",
+    "get_price_history_raw",
+    "get_price_history_from_schwab_non_df",
+    "price_history_to_df",
+    # Ticker
+    "normalize_ticker",
+    "add_dollar_prefix_tickers",
+    "dollar_prefix_tickers",
+    "DEFAULT_DOLLAR_PREFIX_TICKERS",
+    # Types
+    "Ticker",
+    "TickerUpperCase",
+    "TickerNormalized",
+    "EquityTickerClassStyle",
+    "SchwabPriceHistoryInterval",
+    "SchwabPriceHistoryIntervalStr",
+]

schwab_py_utils-0.1.0/src/schwab_py_utils/_types.py

@@ -0,0 +1,9 @@
+from typing import Literal
+
+Ticker = str
+TickerUpperCase = str
+TickerNormalized = str
+EquityTickerClassStyle = Literal[".", "/"]
+
+SchwabPriceHistoryInterval = Literal[1, 5, 10, 15, 30, "d", "w"]
+SchwabPriceHistoryIntervalStr = Literal["1", "5", "10", "15", "30", "d", "w"]

schwab_py_utils-0.1.0/src/schwab_py_utils/auth.py

@@ -0,0 +1,114 @@
+"""
+Envchain-based token storage for schwab-py.
+
+Requires the `envchain` optional dependency:
+    pip install schwab-py-utils[envchain]
+"""
+
+import json
+import logging
+from typing import Any, Callable
+
+logger = logging.getLogger(__name__)
+
+TokenReadFunc = Callable[[], dict[str, Any] | None]
+TokenWriteFunc = Callable[[dict[str, Any]], None]
+
+
+def create_envchain_token_handlers(
+    envchain_namespace: str = "schwab-py",
+    envchain_key: str = "token",
+    envchain_cmd: str = "/opt/homebrew/bin/envchain",
+) -> tuple[TokenReadFunc, TokenWriteFunc]:
+    """
+    Create token read/write functions that use envchain for secure storage.
+
+    The returned functions are suitable for use with schwab-py's
+    `client_from_access_functions`.
+
+    Args:
+        envchain_namespace: The namespace in envchain for token storage
+        envchain_key: The key within the namespace
+        envchain_cmd: Path to the envchain command
+
+    Returns:
+        Tuple of (token_read_func, token_write_func)
+
+    Raises:
+        ImportError: If envchain-python is not installed
+    """
+    try:
+        from envchain_python import (  # pyright: ignore[reportMissingImports]
+            EnvchainError,
+            deserialize_string_to_object,
+            get_var,
+            serialize_object_to_string,
+            set_var,
+        )
+    except ImportError:
+        raise ImportError(
+            "envchain-python is required for envchain token storage. "
+            "Install with: pip install schwab-py-utils[envchain]"
+        )
+
+    if not isinstance(envchain_namespace, str) or not envchain_namespace.strip():
+        raise ValueError("envchain_namespace must be a non-empty string.")
+    if not isinstance(envchain_key, str) or not envchain_key.strip():
+        raise ValueError("envchain_key must be a non-empty string.")
+
+    envchain_kwargs = {"envchain_cmd": envchain_cmd}
+
+    def read_func() -> dict[str, Any] | None:
+        """Read token from envchain."""
+        logger.debug(
+            f"Reading token from envchain: namespace='{envchain_namespace}', key='{envchain_key}'"
+        )
+        try:
+            token_str = get_var(envchain_namespace, envchain_key, **envchain_kwargs)
+
+            if token_str is None or not token_str:
+                logger.info(
+                    f"No token found in envchain for namespace='{envchain_namespace}'"
+                )
+                return None
+
+            token_obj = deserialize_string_to_object(token_str)
+            if not isinstance(token_obj, dict):
+                logger.warning(f"Deserialized token is not a dict: {type(token_obj)}")
+                return None
+
+            logger.debug("Successfully read token from envchain.")
+            return token_obj
+
+        except EnvchainError as e:
+            logger.warning(f"EnvchainError reading token: {e}")
+            return None
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to deserialize token: {e}")
+            return None
+
+    def write_func(
+        metadata_wrapped_token: dict[str, Any], *args: Any, **kwargs: Any
+    ) -> None:
+        """Write token to envchain."""
+        logger.debug(
+            f"Writing token to envchain: namespace='{envchain_namespace}', key='{envchain_key}'"
+        )
+        if not isinstance(metadata_wrapped_token, dict):
+            raise TypeError(f"Expected dict, got {type(metadata_wrapped_token)}")
+
+        try:
+            serialized = serialize_object_to_string(metadata_wrapped_token)
+            set_var(
+                envchain_namespace,
+                envchain_key,
+                serialized,
+                require_passphrase=True,
+                **envchain_kwargs,
+            )
+            logger.debug("Successfully wrote token to envchain.")
+        except EnvchainError as e:
+            logger.error(f"EnvchainError writing token: {e}")
+            raise
+
+    return read_func, write_func

schwab_py_utils-0.1.0/src/schwab_py_utils/client.py

@@ -0,0 +1,256 @@
+import os
+from enum import Enum
+from functools import cache
+from pathlib import Path
+from typing import Literal, overload
+
+from schwab.client import AsyncClient, Client
+
+
+DEFAULT_TOKEN_PATH = Path.home() / ".credentials" / "schwab-token.json"
+
+AUTH_METHOD_ENV_VAR = "SCHWAB_PY_UTILS_AUTH_METHOD"
+TOKEN_PATH_ENV_VAR = "SCHWAB_PY_UTILS_TOKEN_PATH"
+ENVCHAIN_CMD_ENV_VAR = "SCHWAB_PY_UTILS_ENVCHAIN_CMD"
+
+_TOKEN_ONLY_PLACEHOLDER_API_KEY = "TOKEN_ONLY"
+_TOKEN_ONLY_PLACEHOLDER_SECRET = "TOKEN_ONLY"
+
+
+class SchwabClientMethod(Enum):
+    """
+    Methods to instantiate a Schwab API client:
+
+    - easy_client: Use schwab-py's easy_client with file-based token storage
+    - envchain_token: Fetch OAuth token via envchain (requires envchain-python)
+    - envchain: Fetch OAuth token + credentials via envchain (requires envchain-python)
+    """
+
+    easy_client = "easy_client"
+    envchain_token = "envchain_token"
+    envchain = "envchain"
+
+
+def _get_env_credentials() -> tuple[str, str, str]:
+    """Get Schwab API credentials from environment variables."""
+    api_key = os.getenv("SCHWAB_API_KEY")
+    app_secret = os.getenv("SCHWAB_SECRET")
+    callback_url = os.getenv("SCHWAB_CALLBACK_URL")
+
+    if not api_key or not app_secret or not callback_url:
+        raise ValueError(
+            "Please set SCHWAB_API_KEY, SCHWAB_SECRET, and SCHWAB_CALLBACK_URL environment variables."
+        )
+    return api_key, app_secret, callback_url
+
+
+def _resolve_method(method: SchwabClientMethod | str | None) -> SchwabClientMethod:
+    """Resolve auth method from explicit argument or environment variable."""
+    if isinstance(method, SchwabClientMethod):
+        return method
+
+    raw_method = method
+    if raw_method is None:
+        raw_method = os.getenv(
+            AUTH_METHOD_ENV_VAR, SchwabClientMethod.easy_client.value
+        )
+
+    try:
+        return SchwabClientMethod(raw_method)
+    except ValueError:
+        raise ValueError(f"Unknown method: {raw_method}")
+
+
+def _resolve_token_path(token_path: str | Path | None) -> Path:
+    """Resolve token path from explicit argument, env var, or default."""
+    if token_path is None:
+        token_path = os.getenv(TOKEN_PATH_ENV_VAR)
+
+    if token_path is None:
+        token_path = DEFAULT_TOKEN_PATH
+
+    return Path(token_path).expanduser()
+
+
+def _resolve_envchain_cmd(envchain_cmd: str | None) -> str:
+    """Resolve envchain binary path from explicit argument, env var, or default."""
+    if envchain_cmd:
+        return envchain_cmd
+
+    return os.getenv(ENVCHAIN_CMD_ENV_VAR, "/opt/homebrew/bin/envchain")
+
+
+def _resolve_token_auth_credentials() -> tuple[str, str]:
+    """
+    Resolve API key + secret used by token-file clients for refresh operations.
+
+    Priority:
+    1. SCHWAB_API_KEY + SCHWAB_SECRET env vars
+    2. envchain namespace "schwab-app-data-studies"
+    3. Placeholder values (works if token remains valid and no refresh is needed)
+    """
+    api_key = os.getenv("SCHWAB_API_KEY")
+    app_secret = os.getenv("SCHWAB_SECRET")
+    if api_key and app_secret:
+        return api_key, app_secret
+
+    try:
+        import envchain_python  # pyright: ignore[reportMissingImports]
+
+        non_token_credentials = envchain_python.get_vars(
+            "schwab-app-data-studies", "SCHWAB_API_KEY", "SCHWAB_SECRET"
+        )
+
+        envchain_api_key = non_token_credentials.get("SCHWAB_API_KEY")
+        envchain_app_secret = non_token_credentials.get("SCHWAB_SECRET")
+        if envchain_api_key and envchain_app_secret:
+            return envchain_api_key, envchain_app_secret
+    except Exception:
+        pass
+
+    return (
+        api_key or _TOKEN_ONLY_PLACEHOLDER_API_KEY,
+        app_secret or _TOKEN_ONLY_PLACEHOLDER_SECRET,
+    )
+
+
+@overload
+def get_client(
+    asyncio_: Literal[True],
+    method: SchwabClientMethod | str | None = None,
+    token_path: str | Path | None = None,
+    envchain_cmd: str | None = None,
+) -> AsyncClient: ...
+
+
+@overload
+def get_client(
+    asyncio_: Literal[False] = False,
+    method: SchwabClientMethod | str | None = None,
+    token_path: str | Path | None = None,
+    envchain_cmd: str | None = None,
+) -> Client: ...
+
+
+@overload
+def get_client(
+    asyncio_: bool = False,
+    method: SchwabClientMethod | str | None = None,
+    token_path: str | Path | None = None,
+    envchain_cmd: str | None = None,
+) -> Client | AsyncClient: ...
+
+
+@cache
+def get_client(
+    asyncio_: bool = False,
+    method: SchwabClientMethod | str | None = None,
+    token_path: str | Path | None = None,
+    envchain_cmd: str | None = None,
+) -> Client | AsyncClient:
+    """
+    Get a Schwab API client.
+
+    Args:
+        asyncio_: If True, return an async client
+        method: Authentication method to use. If not provided, resolves from
+            SCHWAB_PY_UTILS_AUTH_METHOD or defaults to "easy_client".
+        token_path: Path to token file (for easy_client method).
+            If omitted, resolves from SCHWAB_PY_UTILS_TOKEN_PATH or defaults to
+            ~/.credentials/schwab-token.json
+        envchain_cmd: Path to envchain command (for envchain methods)
+
+    Returns:
+        Schwab Client or AsyncClient
+
+    Note:
+        Results are cached. Call `get_client.cache_clear()` if credentials change.
+    """
+    method = _resolve_method(method)
+    envchain_cmd = _resolve_envchain_cmd(envchain_cmd)
+
+    if method == SchwabClientMethod.easy_client:
+        from schwab.auth import client_from_token_file, easy_client
+
+        token_path = _resolve_token_path(token_path)
+        token_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Token-first mode: if token file exists, we can create a fully usable
+        # client without requiring SCHWAB_* env vars.
+        if token_path.is_file():
+            api_key, app_secret = _resolve_token_auth_credentials()
+
+            return client_from_token_file(
+                token_path=str(token_path),
+                api_key=api_key,
+                app_secret=app_secret,
+                asyncio=asyncio_,
+            )
+
+        # Fall back to easy_client login flow when no token exists.
+        api_key, app_secret, callback_url = _get_env_credentials()
+
+        return easy_client(
+            api_key=api_key,
+            app_secret=app_secret,
+            callback_url=callback_url,
+            token_path=str(token_path),
+            asyncio=asyncio_,
+        )
+
+    elif method == SchwabClientMethod.envchain_token:
+        from schwab.auth import client_from_access_functions
+
+        from .auth import create_envchain_token_handlers
+
+        api_key, app_secret, _ = _get_env_credentials()
+        token_read_func, token_write_func = create_envchain_token_handlers(
+            envchain_cmd=envchain_cmd
+        )
+
+        return client_from_access_functions(
+            api_key=api_key,
+            app_secret=app_secret,
+            token_read_func=token_read_func,
+            token_write_func=token_write_func,
+            asyncio=asyncio_,
+        )
+
+    elif method == SchwabClientMethod.envchain:
+        from schwab.auth import client_from_access_functions
+
+        try:
+            import envchain_python  # pyright: ignore[reportMissingImports]
+        except ImportError:
+            raise ImportError(
+                "envchain-python is required for envchain method. "
+                "Install with: pip install schwab-py-utils[envchain]"
+            )
+
+        from .auth import create_envchain_token_handlers
+
+        non_token_credentials = envchain_python.get_vars(
+            "schwab-app-data-studies", "SCHWAB_API_KEY", "SCHWAB_SECRET"
+        )
+        api_key = non_token_credentials["SCHWAB_API_KEY"]
+        app_secret = non_token_credentials["SCHWAB_SECRET"]
+
+        token_read_func, token_write_func = create_envchain_token_handlers(
+            envchain_cmd=envchain_cmd
+        )
+
+        return client_from_access_functions(
+            api_key=api_key,
+            app_secret=app_secret,
+            token_read_func=token_read_func,
+            token_write_func=token_write_func,
+            asyncio=asyncio_,
+        )
+
+    else:
+        raise ValueError(f"Unknown method: {method}")
+
+
+# Alias for backwards compatibility
+get_schwab_client = get_client
+SchwabPyGetClientMethod = SchwabClientMethod

schwab_py_utils-0.1.0/src/schwab_py_utils/price_history.py

@@ -0,0 +1,158 @@
+from datetime import datetime
+from warnings import warn
+
+import httpx
+import pandas as pd
+from schwab.client import AsyncClient, Client
+
+from ._types import SchwabPriceHistoryInterval, SchwabPriceHistoryIntervalStr
+from .ticker import normalize_ticker
+
+
+def _warn_if_futures(symbol: str) -> None:
+    """Warn if the symbol appears to be a futures contract."""
+    if symbol.startswith("/"):
+        warn(
+            f"Symbol '{symbol}' appears to be a futures contract. "
+            "Schwab's price history API only supports equities and ETFs, not futures. "
+            "You may receive limited or no data. For futures data, consider using "
+            "Schwab's streaming API (chart_futures_subs) or an alternative data source.",
+            UserWarning,
+            stacklevel=3,
+        )
+
+
+# Mapping from interval to schwab-py method name
+_INTERVAL_TO_METHOD: dict[
+    SchwabPriceHistoryInterval | SchwabPriceHistoryIntervalStr, str
+] = {
+    "1": "get_price_history_every_minute",
+    "5": "get_price_history_every_five_minutes",
+    "10": "get_price_history_every_ten_minutes",
+    "15": "get_price_history_every_fifteen_minutes",
+    "30": "get_price_history_every_thirty_minutes",
+    1: "get_price_history_every_minute",
+    5: "get_price_history_every_five_minutes",
+    10: "get_price_history_every_ten_minutes",
+    15: "get_price_history_every_fifteen_minutes",
+    30: "get_price_history_every_thirty_minutes",
+    "d": "get_price_history_every_day",
+    "w": "get_price_history_every_week",
+}
+
+
+def price_history_to_df(price_history: dict | httpx.Response) -> pd.DataFrame:
+    """
+    Convert Schwab price history response to a pandas DataFrame.
+
+    Args:
+        price_history: Raw response from Schwab API (dict or httpx.Response)
+
+    Returns:
+        DataFrame with columns: open, high, low, close, volume, timestamp, datetime, date
+    """
+    if isinstance(price_history, httpx.Response):
+        price_history = price_history.json()
+
+    if price_history.get("empty", True):
+        return pd.DataFrame()
+
+    candles = price_history.get("candles")
+    if not candles:
+        return pd.DataFrame()
+
+    df = pd.DataFrame(candles)
+    df.rename(columns={"datetime": "timestamp"}, inplace=True)
+    df["datetime"] = pd.to_datetime(df["timestamp"], unit="ms", utc=True)
+    df["datetime"] = df["datetime"].dt.tz_convert("America/New_York")
+    df["date"] = df["datetime"].dt.date.astype(str)
+
+    return df
+
+
+def get_price_history_raw(
+    client: Client | AsyncClient,
+    symbol: str,
+    interval: SchwabPriceHistoryInterval | SchwabPriceHistoryIntervalStr,
+    start_datetime: datetime | None = None,
+    end_datetime: datetime | None = None,
+    need_extended_hours_data: bool | None = None,
+    need_previous_close: bool | None = None,
+) -> dict:
+    """
+    Get price history from Schwab as raw dict.
+
+    Args:
+        client: Schwab API client
+        symbol: Ticker symbol
+        interval: Time interval (1, 5, 10, 15, 30 minutes, or "d", "w" for daily/weekly)
+        start_datetime: Start of date range
+        end_datetime: End of date range
+        need_extended_hours_data: Include extended hours data (default True in API)
+        need_previous_close: Include previous close price
+
+    Returns:
+        Raw dict from Schwab API
+    """
+    _warn_if_futures(symbol)  # Check before normalization strips the /
+    symbol = normalize_ticker(symbol)
+    method_name = _INTERVAL_TO_METHOD[interval]
+
+    response = getattr(client, method_name)(
+        symbol,
+        start_datetime=start_datetime,
+        end_datetime=end_datetime,
+        need_extended_hours_data=need_extended_hours_data,
+        need_previous_close=need_previous_close,
+    )
+
+    return response.json()
+
+
+def get_price_history(
+    client: Client | AsyncClient,
+    symbol: str,
+    interval: SchwabPriceHistoryInterval | SchwabPriceHistoryIntervalStr,
+    start_datetime: datetime | None = None,
+    end_datetime: datetime | None = None,
+    need_extended_hours_data: bool | None = None,
+    need_previous_close: bool | None = None,
+    set_datetime_index: bool = True,
+) -> pd.DataFrame:
+    """
+    Get price history from Schwab as a pandas DataFrame.
+
+    Args:
+        client: Schwab API client
+        symbol: Ticker symbol
+        interval: Time interval (1, 5, 10, 15, 30 minutes, or "d", "w" for daily/weekly)
+        start_datetime: Start of date range
+        end_datetime: End of date range
+        need_extended_hours_data: Include extended hours data (default True in API)
+        need_previous_close: Include previous close price
+        set_datetime_index: If True, set datetime as the index
+
+    Returns:
+        DataFrame with OHLCV data
+    """
+    raw = get_price_history_raw(
+        client,
+        symbol,
+        interval,
+        start_datetime=start_datetime,
+        end_datetime=end_datetime,
+        need_extended_hours_data=need_extended_hours_data,
+        need_previous_close=need_previous_close,
+    )
+
+    df = price_history_to_df(raw)
+
+    if set_datetime_index and "datetime" in df.columns:
+        df = df.set_index("datetime")
+
+    return df
+
+
+# Alias for backwards compatibility
+get_price_history_from_schwab = get_price_history
+get_price_history_from_schwab_non_df = get_price_history_raw

schwab_py_utils-0.1.0/src/schwab_py_utils/ticker.py

@@ -0,0 +1,83 @@
+from ._types import EquityTickerClassStyle, TickerNormalized, TickerUpperCase
+
+# Common index tickers that should be prefixed with $
+DEFAULT_DOLLAR_PREFIX_TICKERS: set[str] = {
+    "SPX",
+    "VIX",
+    "NDX",
+    "RUT",
+    "DJI",
+    "DJX",
+    "VVIX",
+    "VIX9D",
+    "VIX3M",
+    "VIX6M",
+    "VIX1Y",
+    "VIXEQ",
+    "VIX1D",
+    "VXN",
+    "RVX",
+    "VXD",
+}
+
+# Module-level set that users can extend
+dollar_prefix_tickers: set[str] = DEFAULT_DOLLAR_PREFIX_TICKERS.copy()
+
+
+def add_dollar_prefix_tickers(*tickers: str) -> None:
+    """Add tickers to the set that should be prefixed with $."""
+    for t in tickers:
+        dollar_prefix_tickers.add(t.upper().lstrip("$"))
+
+
+def normalize_ticker(
+    ticker: str,
+    prefix_dollar: bool = True,
+    normalize_index_tickers: bool = True,
+    equity_ticker_class_style: EquityTickerClassStyle = "/",
+    prefix_futures_ticker: bool = False,
+) -> TickerNormalized | TickerUpperCase:
+    """
+    Normalize a ticker symbol.
+
+    - Uppercase the ticker
+    - Optionally add $ prefix for index tickers
+    - Normalize index ticker variants (SPXW -> SPX, etc.)
+    - Handle equity ticker class styles (BRK.B vs BRK/B)
+
+    Args:
+        ticker: The ticker symbol to normalize
+        prefix_dollar: If True, add $ prefix for index tickers
+        normalize_index_tickers: If True, normalize variants like SPXW -> SPX
+        equity_ticker_class_style: "/" or "." for class shares (e.g., BRK/B or BRK.B)
+        prefix_futures_ticker: If True, prefix with / for futures
+
+    Returns:
+        Normalized ticker string
+    """
+    ticker = ticker.upper().lstrip("/$")
+
+    if equity_ticker_class_style == "/":
+        ticker = ticker.replace(".", "/")
+    elif equity_ticker_class_style == ".":
+        ticker = ticker.replace("/", ".")
+
+    if normalize_index_tickers:
+        if ticker == "SPXW":
+            ticker = "SPX"
+        elif ticker == "NDXP":
+            ticker = "NDX"
+        elif ticker == "RUTW":
+            ticker = "RUT"
+        elif ticker == "VIXW":
+            ticker = "VIX"
+
+    if prefix_dollar:
+        if ticker in dollar_prefix_tickers:
+            return f"${ticker}"
+        else:
+            return ticker
+    elif prefix_futures_ticker:
+        return f"/{ticker.strip('$/')}"
+    else:
+        return ticker.removeprefix("$")