flashalpha 0.3.3__tar.gz → 0.3.4__tar.gz

flashalpha-0.3.4/CLAUDE.md

@@ -0,0 +1,67 @@
+# CLAUDE.md
+
+Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+## 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
+
+---
+
+**These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.
+
+_Source: [forrestchang/andrej-karpathy-skills](https://github.com/forrestchang/andrej-karpathy-skills)_

{flashalpha-0.3.3 → flashalpha-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flashalpha
-Version: 0.3.3
+Version: 0.3.4
 Summary: Python SDK for the FlashAlpha options analytics API — live options screener, gamma exposure (GEX), VRP, delta, vanna, charm, greeks, 0DTE analytics, volatility surfaces, and more.
 Project-URL: Homepage, https://flashalpha.com
 Project-URL: Documentation, https://flashalpha.com/docs

{flashalpha-0.3.3 → flashalpha-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flashalpha"
-version = "0.3.3"
+version = "0.3.4"
 description = "Python SDK for the FlashAlpha options analytics API — live options screener, gamma exposure (GEX), VRP, delta, vanna, charm, greeks, 0DTE analytics, volatility surfaces, and more."
 readme = "README.md"
 license = "MIT"

flashalpha-0.3.4/src/flashalpha/__init__.py

@@ -0,0 +1,54 @@
+"""FlashAlpha Python SDK — options exposure analytics API."""
+
+from .client import FlashAlpha
+from .exceptions import (
+    AuthenticationError,
+    FlashAlphaError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+    TierRestrictedError,
+)
+from .types import (
+    ZeroDteDecay,
+    ZeroDteExpectedMove,
+    ZeroDteExposures,
+    ZeroDteFlow,
+    ZeroDteHedging,
+    ZeroDteHedgingBucket,
+    ZeroDteLevels,
+    ZeroDteLiquidity,
+    ZeroDteMetadata,
+    ZeroDtePinComponents,
+    ZeroDtePinRisk,
+    ZeroDteRegime,
+    ZeroDteResponse,
+    ZeroDteStrike,
+    ZeroDteVolContext,
+)
+
+__version__ = "0.3.4"
+__all__ = [
+    "FlashAlpha",
+    "FlashAlphaError",
+    "AuthenticationError",
+    "TierRestrictedError",
+    "NotFoundError",
+    "RateLimitError",
+    "ServerError",
+    "ZeroDteResponse",
+    "ZeroDteRegime",
+    "ZeroDteExposures",
+    "ZeroDteExpectedMove",
+    "ZeroDtePinRisk",
+    "ZeroDtePinComponents",
+    "ZeroDteHedging",
+    "ZeroDteHedgingBucket",
+    "ZeroDteDecay",
+    "ZeroDteVolContext",
+    "ZeroDteFlow",
+    "ZeroDteLevels",
+    "ZeroDteLiquidity",
+    "ZeroDteMetadata",
+    "ZeroDteStrike",
+]

{flashalpha-0.3.3 → flashalpha-0.3.4}/src/flashalpha/client.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import requests
 
@@ -15,6 +15,9 @@ from .exceptions import (
     TierRestrictedError,
 )
 
+if TYPE_CHECKING:
+    from .types import ZeroDteResponse
+
 BASE_URL = "https://lab.flashalpha.com"
 
 
@@ -192,8 +195,13 @@ class FlashAlpha:
         """Verbal narrative analysis of exposure. Requires Growth+."""
         return self._get(f"/v1/exposure/narrative/{symbol}")
 
-    def zero_dte(self, symbol: str, *, strike_range: float | None = None) -> dict:
-        """Real-time 0DTE analytics: regime, expected move, pin risk, hedging, decay. Requires Growth+."""
+    def zero_dte(self, symbol: str, *, strike_range: float | None = None) -> "ZeroDteResponse":
+        """Real-time 0DTE analytics: regime, expected move, pin risk, hedging, decay. Requires Growth+.
+
+        Returns a ``ZeroDteResponse`` (a ``TypedDict`` — runtime-equivalent to
+        ``dict``). Existing ``result["field"]`` access continues to work; new
+        callers get autocomplete and type-checking on the documented fields.
+        """
         params: dict[str, Any] = {}
         if strike_range is not None:
             params["strike_range"] = strike_range

flashalpha-0.3.4/src/flashalpha/types.py

@@ -0,0 +1,215 @@
+"""Typed response models for FlashAlpha SDK.
+
+These are ``TypedDict`` aliases — at runtime each is a plain ``dict``. Existing
+code that does ``result["field"]`` keeps working unchanged. Static type
+checkers (mypy/pyright) and IDEs see the field shape and provide autocomplete.
+
+Currently typed:
+    - ``ZeroDteResponse`` (full payload of GET /v1/exposure/zero-dte/{symbol})
+
+All numeric fields are typed ``Optional[float]``/``Optional[int]`` because
+the API returns ``null`` for any value it can't compute (insufficient data,
+market closed, etc.). Treat the typed shape as a *hint*, not a guarantee —
+unknown fields added by the API in future revisions will still pass through.
+"""
+
+from typing import List, Literal, Optional, TypedDict
+
+
+class ZeroDteRegime(TypedDict, total=False):
+    label: str
+    description: str
+    gamma_flip: Optional[float]
+    spot_vs_flip: Literal["above", "below"]
+    spot_to_flip_pct: Optional[float]
+    distance_to_flip_dollars: Optional[float]
+    distance_to_flip_sigmas: Optional[float]
+
+
+class ZeroDteExposures(TypedDict, total=False):
+    net_gex: float
+    net_dex: float
+    net_vex: float
+    net_chex: float
+    pct_of_total_gex: Optional[float]
+    total_chain_net_gex: float
+
+
+class ZeroDteExpectedMove(TypedDict, total=False):
+    implied_1sd_dollars: Optional[float]
+    implied_1sd_pct: Optional[float]
+    remaining_1sd_dollars: Optional[float]
+    remaining_1sd_pct: Optional[float]
+    upper_bound: Optional[float]
+    lower_bound: Optional[float]
+    straddle_price: Optional[float]
+    atm_iv: Optional[float]
+
+
+class ZeroDtePinComponents(TypedDict, total=False):
+    oi_score: int
+    proximity_score: int
+    time_score: int
+    gamma_score: int
+
+
+class ZeroDtePinRisk(TypedDict, total=False):
+    magnet_strike: Optional[float]
+    magnet_gex: Optional[float]
+    distance_to_magnet_pct: Optional[float]
+    pin_score: int
+    components: ZeroDtePinComponents
+    max_pain: Optional[float]
+    oi_concentration_top3_pct: Optional[float]
+    description: str
+
+
+class ZeroDteHedgingBucket(TypedDict, total=False):
+    dealer_shares_to_trade: float
+    direction: Literal["buy", "sell"]
+    notional_usd: float
+
+
+class ZeroDteHedging(TypedDict, total=False):
+    spot_up_10bp: ZeroDteHedgingBucket
+    spot_down_10bp: ZeroDteHedgingBucket
+    spot_up_25bp: ZeroDteHedgingBucket
+    spot_down_25bp: ZeroDteHedgingBucket
+    spot_up_half_pct: ZeroDteHedgingBucket
+    spot_down_half_pct: ZeroDteHedgingBucket
+    spot_up_1pct: ZeroDteHedgingBucket
+    spot_down_1pct: ZeroDteHedgingBucket
+    convexity_at_spot: Optional[float]
+
+
+class ZeroDteDecay(TypedDict, total=False):
+    net_theta_dollars: Optional[float]
+    theta_per_hour_remaining: Optional[float]
+    charm_regime: str
+    charm_description: str
+    gamma_acceleration: Optional[float]
+    description: str
+
+
+class ZeroDteVolContext(TypedDict, total=False):
+    zero_dte_atm_iv: Optional[float]
+    seven_dte_atm_iv: Optional[float]
+    iv_ratio_0dte_7dte: Optional[float]
+    vix: Optional[float]
+    vanna_exposure: Optional[float]
+    vanna_interpretation: str
+    description: str
+
+
+class ZeroDteFlow(TypedDict, total=False):
+    total_volume: int
+    call_volume: int
+    put_volume: int
+    net_call_minus_put_volume: int
+    total_oi: int
+    call_oi: int
+    put_oi: int
+    pc_ratio_volume: Optional[float]
+    pc_ratio_oi: Optional[float]
+    volume_to_oi_ratio: Optional[float]
+    atm_volume_share_pct: Optional[float]
+    top3_strike_volume_pct: Optional[float]
+
+
+class ZeroDteLevels(TypedDict, total=False):
+    call_wall: Optional[float]
+    call_wall_gex: Optional[float]
+    call_wall_strength: Optional[float]
+    distance_to_call_wall_pct: Optional[float]
+    put_wall: Optional[float]
+    put_wall_gex: Optional[float]
+    put_wall_strength: Optional[float]
+    distance_to_put_wall_pct: Optional[float]
+    distance_to_magnet_dollars: Optional[float]
+    highest_oi_strike: Optional[float]
+    highest_oi_total: Optional[int]
+    max_positive_gamma: Optional[float]
+    max_negative_gamma: Optional[float]
+    level_cluster_score: Optional[int]
+
+
+class ZeroDteLiquidity(TypedDict, total=False):
+    atm_spread_pct: Optional[float]
+    weighted_spread_pct: Optional[float]
+    execution_score: Optional[int]
+
+
+class ZeroDteMetadata(TypedDict, total=False):
+    snapshot_age_seconds: Optional[float]
+    chain_contract_count: int
+    data_quality_score: Optional[int]
+    greek_smoothness_score: Optional[int]
+
+
+class ZeroDteStrike(TypedDict, total=False):
+    strike: float
+    distance_from_spot_pct: float
+    call_symbol: str
+    put_symbol: str
+    call_gex: Optional[float]
+    put_gex: Optional[float]
+    net_gex: Optional[float]
+    call_dex: Optional[float]
+    put_dex: Optional[float]
+    net_dex: Optional[float]
+    net_vex: Optional[float]
+    net_chex: Optional[float]
+    call_oi: Optional[int]
+    put_oi: Optional[int]
+    call_volume: Optional[int]
+    put_volume: Optional[int]
+    gex_share_pct: Optional[float]
+    oi_share_pct: Optional[float]
+    volume_share_pct: Optional[float]
+    call_iv: Optional[float]
+    put_iv: Optional[float]
+    call_delta: Optional[float]
+    put_delta: Optional[float]
+    call_gamma: Optional[float]
+    put_gamma: Optional[float]
+    call_theta: Optional[float]
+    put_theta: Optional[float]
+    call_mid: Optional[float]
+    put_mid: Optional[float]
+    call_spread_pct: Optional[float]
+    put_spread_pct: Optional[float]
+
+
+class ZeroDteResponse(TypedDict, total=False):
+    """Full response for GET /v1/exposure/zero-dte/{symbol}.
+
+    On weekends/holidays or symbols without 0DTE today, ``no_zero_dte`` is
+    ``True`` and most fields are absent — only ``symbol``, ``as_of``,
+    ``message``, and ``next_zero_dte_expiry`` are populated.
+    """
+
+    symbol: str
+    underlying_price: float
+    expiration: Optional[str]
+    as_of: str
+    market_open: bool
+    time_to_close_hours: Optional[float]
+    time_to_close_pct: Optional[float]
+    regime: ZeroDteRegime
+    exposures: ZeroDteExposures
+    expected_move: ZeroDteExpectedMove
+    pin_risk: ZeroDtePinRisk
+    hedging: ZeroDteHedging
+    decay: ZeroDteDecay
+    vol_context: ZeroDteVolContext
+    flow: ZeroDteFlow
+    levels: ZeroDteLevels
+    liquidity: ZeroDteLiquidity
+    metadata: ZeroDteMetadata
+    strikes: List[ZeroDteStrike]
+    # Optional — only present near close (<5 min) when greeks may be unstable.
+    warnings: List[str]
+    # ── No-0DTE fallback ─────────────────────────────────────────────
+    no_zero_dte: bool
+    message: str
+    next_zero_dte_expiry: Optional[str]

{flashalpha-0.3.3 → flashalpha-0.3.4}/tests/test_integration.py

@@ -136,6 +136,260 @@ def test_zero_dte(fa):
         assert "decay" in result
 
 
+def test_zero_dte_new_fields(fa):
+    """Validate the full zero-DTE response shape including the v0.3.4 fields:
+    distance-to-flip in dollars/sigmas, sub-score breakdown for pin_score,
+    fine-grained hedging buckets (10bp/25bp/50bp/100bp + convexity_at_spot),
+    flow concentration (atm/top-3 + net_call_minus_put_volume), wall-strength
+    and level-cluster scores, the new liquidity and metadata sections, and
+    per-strike greeks/quotes/spreads.
+
+    Uses SPX which has daily 0DTE — falls back gracefully on weekends/holidays.
+    """
+    result = fa.zero_dte("SPX")
+    assert result["symbol"] == "SPX"
+
+    if result.get("no_zero_dte"):
+        # Weekend / holiday — response is just a stub, nothing else to verify
+        assert "next_zero_dte_expiry" in result
+        return
+
+    # ── top-level ──────────────────────────────────────────────────────
+    for k in ("underlying_price", "expiration", "as_of", "market_open",
+              "time_to_close_hours", "time_to_close_pct"):
+        assert k in result, f"top-level {k} missing"
+
+    # ── regime ─────────────────────────────────────────────────────────
+    regime = result["regime"]
+    for k in ("label", "description", "gamma_flip", "spot_vs_flip", "spot_to_flip_pct",
+              "distance_to_flip_dollars", "distance_to_flip_sigmas"):
+        assert k in regime, f"regime.{k} missing"
+
+    # ── exposures ──────────────────────────────────────────────────────
+    exposures = result["exposures"]
+    for k in ("net_gex", "net_dex", "net_vex", "net_chex",
+              "pct_of_total_gex", "total_chain_net_gex"):
+        assert k in exposures, f"exposures.{k} missing"
+
+    # ── expected_move ──────────────────────────────────────────────────
+    em = result["expected_move"]
+    for k in ("implied_1sd_dollars", "implied_1sd_pct", "remaining_1sd_dollars",
+              "remaining_1sd_pct", "upper_bound", "lower_bound",
+              "straddle_price", "atm_iv"):
+        assert k in em, f"expected_move.{k} missing"
+
+    # ── pin_risk ───────────────────────────────────────────────────────
+    pr = result["pin_risk"]
+    for k in ("magnet_strike", "magnet_gex", "distance_to_magnet_pct",
+              "pin_score", "components", "max_pain",
+              "oi_concentration_top3_pct", "description"):
+        assert k in pr, f"pin_risk.{k} missing"
+    components = pr["components"]
+    for k in ("oi_score", "proximity_score", "time_score", "gamma_score"):
+        assert k in components, f"pin_risk.components.{k} missing"
+
+    # ── hedging — fine-grained buckets + convexity ─────────────────────
+    hedging = result["hedging"]
+    for bucket in ("spot_up_10bp", "spot_down_10bp",
+                   "spot_up_25bp", "spot_down_25bp",
+                   "spot_up_half_pct", "spot_down_half_pct",
+                   "spot_up_1pct", "spot_down_1pct"):
+        assert bucket in hedging, f"hedging.{bucket} missing"
+        b = hedging[bucket]
+        for k in ("dealer_shares_to_trade", "direction", "notional_usd"):
+            assert k in b, f"hedging.{bucket}.{k} missing"
+    assert "convexity_at_spot" in hedging
+
+    # ── decay ──────────────────────────────────────────────────────────
+    decay = result["decay"]
+    for k in ("net_theta_dollars", "theta_per_hour_remaining", "charm_regime",
+              "charm_description", "gamma_acceleration", "description"):
+        assert k in decay, f"decay.{k} missing"
+
+    # ── vol_context ────────────────────────────────────────────────────
+    vc = result["vol_context"]
+    for k in ("zero_dte_atm_iv", "seven_dte_atm_iv", "iv_ratio_0dte_7dte",
+              "vix", "vanna_exposure", "vanna_interpretation", "description"):
+        assert k in vc, f"vol_context.{k} missing"
+
+    # ── flow ───────────────────────────────────────────────────────────
+    flow = result["flow"]
+    for k in ("total_volume", "call_volume", "put_volume",
+              "net_call_minus_put_volume",
+              "total_oi", "call_oi", "put_oi",
+              "pc_ratio_volume", "pc_ratio_oi", "volume_to_oi_ratio",
+              "atm_volume_share_pct", "top3_strike_volume_pct"):
+        assert k in flow, f"flow.{k} missing"
+
+    # ── levels ─────────────────────────────────────────────────────────
+    levels = result["levels"]
+    for k in ("call_wall", "call_wall_gex", "call_wall_strength",
+              "distance_to_call_wall_pct",
+              "put_wall", "put_wall_gex", "put_wall_strength",
+              "distance_to_put_wall_pct",
+              "distance_to_magnet_dollars",
+              "highest_oi_strike", "highest_oi_total",
+              "max_positive_gamma", "max_negative_gamma",
+              "level_cluster_score"):
+        assert k in levels, f"levels.{k} missing"
+
+    # ── liquidity (new section) ────────────────────────────────────────
+    liquidity = result["liquidity"]
+    for k in ("atm_spread_pct", "weighted_spread_pct", "execution_score"):
+        assert k in liquidity, f"liquidity.{k} missing"
+
+    # ── metadata (new section) ─────────────────────────────────────────
+    metadata = result["metadata"]
+    for k in ("snapshot_age_seconds", "chain_contract_count",
+              "data_quality_score", "greek_smoothness_score"):
+        assert k in metadata, f"metadata.{k} missing"
+
+    # ── per-strike entries ─────────────────────────────────────────────
+    strikes = result["strikes"]
+    assert isinstance(strikes, list)
+    if strikes:
+        s = strikes[0]
+        for k in ("strike", "distance_from_spot_pct",
+                  "call_symbol", "put_symbol",
+                  "call_gex", "put_gex", "net_gex",
+                  "call_dex", "put_dex", "net_dex",
+                  "net_vex", "net_chex",
+                  "call_oi", "put_oi", "call_volume", "put_volume",
+                  "gex_share_pct", "oi_share_pct", "volume_share_pct",
+                  "call_iv", "put_iv",
+                  "call_delta", "put_delta",
+                  "call_gamma", "put_gamma",
+                  "call_theta", "put_theta",
+                  "call_mid", "put_mid",
+                  "call_spread_pct", "put_spread_pct"):
+            assert k in s, f"strikes[0].{k} missing"
+
+
+def test_zero_dte_typed_response(fa):
+    """Comprehensive end-to-end test of the typed ``ZeroDteResponse``.
+
+    Mirrors ``test_zero_dte_new_fields`` field-for-field, but reads via the
+    typed paths (``r["regime"]["distance_to_flip_dollars"]`` is fine because
+    ``ZeroDteResponse`` is a ``TypedDict`` — at runtime it's identical to
+    ``dict``). The point is to lock in that every documented field name
+    in the Python type definitions matches what the API actually ships.
+    """
+    from flashalpha.types import ZeroDteResponse
+
+    r: ZeroDteResponse = fa.zero_dte("SPX")
+    assert r["symbol"] == "SPX"
+
+    if r.get("no_zero_dte"):
+        assert "next_zero_dte_expiry" in r
+        return
+
+    # Top-level
+    assert isinstance(r["underlying_price"], (int, float))
+    assert "expiration" in r
+    assert isinstance(r["as_of"], str)
+    assert isinstance(r["market_open"], bool)
+    assert "time_to_close_hours" in r
+    assert "time_to_close_pct" in r
+
+    # regime
+    regime = r["regime"]
+    for k in ("label", "description", "gamma_flip", "spot_vs_flip", "spot_to_flip_pct",
+              "distance_to_flip_dollars", "distance_to_flip_sigmas"):
+        assert k in regime, f"regime.{k} missing in typed access"
+
+    # exposures
+    exposures = r["exposures"]
+    for k in ("net_gex", "net_dex", "net_vex", "net_chex",
+              "pct_of_total_gex", "total_chain_net_gex"):
+        assert k in exposures, f"exposures.{k} missing in typed access"
+
+    # expected_move
+    em = r["expected_move"]
+    for k in ("implied_1sd_dollars", "implied_1sd_pct",
+              "remaining_1sd_dollars", "remaining_1sd_pct",
+              "upper_bound", "lower_bound",
+              "straddle_price", "atm_iv"):
+        assert k in em, f"expected_move.{k} missing in typed access"
+
+    # pin_risk
+    pr = r["pin_risk"]
+    for k in ("magnet_strike", "magnet_gex", "distance_to_magnet_pct",
+              "pin_score", "components", "max_pain",
+              "oi_concentration_top3_pct", "description"):
+        assert k in pr, f"pin_risk.{k} missing in typed access"
+    for k in ("oi_score", "proximity_score", "time_score", "gamma_score"):
+        assert k in pr["components"], f"pin_risk.components.{k} missing"
+
+    # hedging
+    hedging = r["hedging"]
+    for bucket in ("spot_up_10bp", "spot_down_10bp",
+                   "spot_up_25bp", "spot_down_25bp",
+                   "spot_up_half_pct", "spot_down_half_pct",
+                   "spot_up_1pct", "spot_down_1pct"):
+        assert bucket in hedging, f"hedging.{bucket} missing in typed access"
+        for k in ("dealer_shares_to_trade", "direction", "notional_usd"):
+            assert k in hedging[bucket], f"hedging.{bucket}.{k} missing"
+    assert "convexity_at_spot" in hedging
+
+    # decay
+    for k in ("net_theta_dollars", "theta_per_hour_remaining", "charm_regime",
+              "charm_description", "gamma_acceleration", "description"):
+        assert k in r["decay"], f"decay.{k} missing in typed access"
+
+    # vol_context
+    for k in ("zero_dte_atm_iv", "seven_dte_atm_iv", "iv_ratio_0dte_7dte",
+              "vix", "vanna_exposure", "vanna_interpretation", "description"):
+        assert k in r["vol_context"], f"vol_context.{k} missing in typed access"
+
+    # flow
+    for k in ("total_volume", "call_volume", "put_volume",
+              "net_call_minus_put_volume",
+              "total_oi", "call_oi", "put_oi",
+              "pc_ratio_volume", "pc_ratio_oi", "volume_to_oi_ratio",
+              "atm_volume_share_pct", "top3_strike_volume_pct"):
+        assert k in r["flow"], f"flow.{k} missing in typed access"
+
+    # levels
+    for k in ("call_wall", "call_wall_gex", "call_wall_strength",
+              "distance_to_call_wall_pct",
+              "put_wall", "put_wall_gex", "put_wall_strength",
+              "distance_to_put_wall_pct",
+              "distance_to_magnet_dollars",
+              "highest_oi_strike", "highest_oi_total",
+              "max_positive_gamma", "max_negative_gamma",
+              "level_cluster_score"):
+        assert k in r["levels"], f"levels.{k} missing in typed access"
+
+    # liquidity
+    for k in ("atm_spread_pct", "weighted_spread_pct", "execution_score"):
+        assert k in r["liquidity"], f"liquidity.{k} missing in typed access"
+
+    # metadata
+    for k in ("snapshot_age_seconds", "chain_contract_count",
+              "data_quality_score", "greek_smoothness_score"):
+        assert k in r["metadata"], f"metadata.{k} missing in typed access"
+
+    # strikes[0] — every per-strike field
+    strikes = r["strikes"]
+    assert isinstance(strikes, list)
+    if strikes:
+        s = strikes[0]
+        for k in ("strike", "distance_from_spot_pct",
+                  "call_symbol", "put_symbol",
+                  "call_gex", "put_gex", "net_gex",
+                  "call_dex", "put_dex", "net_dex",
+                  "net_vex", "net_chex",
+                  "call_oi", "put_oi", "call_volume", "put_volume",
+                  "gex_share_pct", "oi_share_pct", "volume_share_pct",
+                  "call_iv", "put_iv",
+                  "call_delta", "put_delta",
+                  "call_gamma", "put_gamma",
+                  "call_theta", "put_theta",
+                  "call_mid", "put_mid",
+                  "call_spread_pct", "put_spread_pct"):
+            assert k in s, f"strikes[0].{k} missing in typed access"
+
+
 # ── Pricing ─────────────────────────────────────────────────────────
 
 

flashalpha-0.3.3/src/flashalpha/__init__.py

@@ -1,22 +0,0 @@
-"""FlashAlpha Python SDK — options exposure analytics API."""
-
-from .client import FlashAlpha
-from .exceptions import (
-    AuthenticationError,
-    FlashAlphaError,
-    NotFoundError,
-    RateLimitError,
-    ServerError,
-    TierRestrictedError,
-)
-
-__version__ = "0.3.2"
-__all__ = [
-    "FlashAlpha",
-    "FlashAlphaError",
-    "AuthenticationError",
-    "TierRestrictedError",
-    "NotFoundError",
-    "RateLimitError",
-    "ServerError",
-]