dex-connector-alphavantage 0.1.0__tar.gz

dex_connector_alphavantage-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+/.dex-local/dexcli
+/.dex-local/dex-server-zd
+/.dex-local/data/
+/.dex-local/cli.log
+/.dex-local/visualize.json
+/.dex-local/visualize.err

dex_connector_alphavantage-0.1.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.5
+Name: dex-connector-alphavantage
+Version: 0.1.0
+Summary: Alpha Vantage connector for Dex Flows
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: dex-connectors-sdk==0.1.0
+Requires-Dist: dex-python-sdk>=1.28.0
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# Alpha Vantage connector for Python
+
+Install with `pip install dex-connector-alphavantage==0.1.0`. The package
+requires `dex-connectors-sdk==0.1.0` and `dex-python-sdk>=1.28.0`, and
+implements the manifest Queries `getGlobalQuote` and `getTimeSeriesDaily` with
+the same branches, defaults, and failure classification as the Go module.
+
+## Operations
+
+| Operation | Factory | Happy branch | Optional branches |
+| --- | --- | --- | --- |
+| `getGlobalQuote` | `new_get_global_quote_step` | `found` | `notFound`, `providerRejected`, `invalidResponse`, `defect` |
+| `getTimeSeriesDaily` | `new_get_time_series_daily_step` | `found` | `notFound`, `providerRejected`, `invalidResponse`, `defect` |
+
+Both take a ticker symbol of 1 to 25 letters, digits, `.`, `_`, or `-`.
+Alpha Vantage reports problems in HTTP 200 bodies: a `Note`, or an
+`Information` message about rate limits, call frequency, or requests per day,
+retries as a rate limit; another `Information` or an `Error Message` selects
+`providerRejected`; an empty quote or series selects `notFound`. HTTP 404 also
+selects `notFound`; 408, 429, 5xx, and transport failures retry. The daily
+series is returned newest day first.
+
+## Authorization
+
+Create a Dex Web connection named `alphavantage` as described in the
+[connector README](../README.md#authorization). Alpha Vantage accepts the API
+key only as the `apikey` query parameter, so the key is part of each request
+URL; it is resolved for every attempt.
+
+## Example
+
+[`examples/demo`](examples/demo/flow.py) reads a quote and records it. Run the
+Worker with `uv run python -m examples.demo.worker` after `dexcli dev` has
+loaded a project containing the `alphavantage` connection.
+
+## Tests
+
+`alphavantagemock.Mock` scripts both Queries and defaults to the manifest
+answers. Run `uv run pytest tests` for provider parity and manifest contract
+checks.

dex_connector_alphavantage-0.1.0/README.md

@@ -0,0 +1,40 @@
+# Alpha Vantage connector for Python
+
+Install with `pip install dex-connector-alphavantage==0.1.0`. The package
+requires `dex-connectors-sdk==0.1.0` and `dex-python-sdk>=1.28.0`, and
+implements the manifest Queries `getGlobalQuote` and `getTimeSeriesDaily` with
+the same branches, defaults, and failure classification as the Go module.
+
+## Operations
+
+| Operation | Factory | Happy branch | Optional branches |
+| --- | --- | --- | --- |
+| `getGlobalQuote` | `new_get_global_quote_step` | `found` | `notFound`, `providerRejected`, `invalidResponse`, `defect` |
+| `getTimeSeriesDaily` | `new_get_time_series_daily_step` | `found` | `notFound`, `providerRejected`, `invalidResponse`, `defect` |
+
+Both take a ticker symbol of 1 to 25 letters, digits, `.`, `_`, or `-`.
+Alpha Vantage reports problems in HTTP 200 bodies: a `Note`, or an
+`Information` message about rate limits, call frequency, or requests per day,
+retries as a rate limit; another `Information` or an `Error Message` selects
+`providerRejected`; an empty quote or series selects `notFound`. HTTP 404 also
+selects `notFound`; 408, 429, 5xx, and transport failures retry. The daily
+series is returned newest day first.
+
+## Authorization
+
+Create a Dex Web connection named `alphavantage` as described in the
+[connector README](../README.md#authorization). Alpha Vantage accepts the API
+key only as the `apikey` query parameter, so the key is part of each request
+URL; it is resolved for every attempt.
+
+## Example
+
+[`examples/demo`](examples/demo/flow.py) reads a quote and records it. Run the
+Worker with `uv run python -m examples.demo.worker` after `dexcli dev` has
+loaded a project containing the `alphavantage` connection.
+
+## Tests
+
+`alphavantagemock.Mock` scripts both Queries and defaults to the manifest
+answers. Run `uv run pytest tests` for provider parity and manifest contract
+checks.

dex_connector_alphavantage-0.1.0/examples/demo/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Alpha Vantage demo example Flow."""

dex_connector_alphavantage-0.1.0/examples/demo/flow.py

@@ -0,0 +1,79 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Runnable Alpha Vantage demo Flow using the getGlobalQuote Query."""
+
+import dex
+from dex_connectors.sdk import QueryResult
+
+from dex_connectors.alphavantage import (
+    Connection,
+    GlobalQuoteOutput,
+    StockInput,
+    new_get_global_quote_step,
+)
+
+FLOW_TYPE = "AlphaVantageDemo"
+CONNECTION_NAME = "alphavantage"
+_OPERATION_STEP_TYPE = "CallGetGlobalQuote"
+_OUTCOME = dex.Attribute("alphavantage-demo-outcome", GlobalQuoteOutput)
+
+
+def map_to_operation_input(input: StockInput) -> StockInput:
+    """Read the requested symbol unchanged."""
+    return input
+
+
+# dex:group group-id:demo group-label:"Demo"
+# dex:explanation text:"Start the quote lookup with the requested symbol."
+class _StartRequest(dex.Step[StockInput]):
+    def get_step_type(self) -> str:
+        return "StartGetGlobalQuote"
+
+    def execute(self, context: dex.Context, input: StockInput) -> dex.StepDecision:
+        return dex.go_to(dex.StepRef(_OPERATION_STEP_TYPE), input)
+
+
+# dex:group group-id:demo group-label:"Demo"
+# dex:explanation text:"Record the quote and complete the Flow."
+class _CompleteResult(dex.Step[QueryResult[GlobalQuoteOutput]]):
+    def get_step_type(self) -> str:
+        return "CompleteGetGlobalQuote"
+
+    def execute(self, context: dex.Context, input: QueryResult[GlobalQuoteOutput]) -> dex.StepDecision:
+        _OUTCOME.set(context, input.value)
+        return dex.graceful_complete(input.value)
+
+
+class DemoFlow(dex.Flow[StockInput]):
+    """Read a stock quote through the static alphavantage connection."""
+
+    def __init__(self, connection: Connection) -> None:
+        if connection.reference.name != CONNECTION_NAME:
+            raise ValueError("demo requires the static alphavantage connection")
+        self._start = _StartRequest()
+        self._complete = _CompleteResult()
+        self._read = new_get_global_quote_step(
+            step_type=_OPERATION_STEP_TYPE,
+            step_input_type=StockInput,
+            annotations={
+                "groupId": "provider",
+                "groupLabel": "Alpha Vantage",
+                "explanation": "Call the provider's getGlobalQuote operation.",
+            },
+            connection=connection,
+            connection_name=CONNECTION_NAME,
+            map_to_operation_input=map_to_operation_input,
+            found=self._complete,
+        )
+
+    def get_flow_type(self) -> str:
+        """Return the stable Flow identity used in Dex Web."""
+        return FLOW_TYPE
+
+    def get_steps(self) -> dex.StepList[StockInput]:
+        """Register the start, provider read, and completion Steps."""
+        return dex.StepList.start_step(self._start).other_steps(self._read, self._complete)
+
+    def get_persistence_schema(self) -> dex.PersistenceSchema:
+        """Persist the quote outcome."""
+        return dex.PersistenceSchema.of(_OUTCOME)

dex_connector_alphavantage-0.1.0/examples/demo/worker.py

@@ -0,0 +1,51 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Worker entrypoint for the Alpha Vantage demo Flow."""
+
+import asyncio
+import os
+import tempfile
+from pathlib import Path
+
+import dex
+from dex_connectors.sdk.projectconfig import load_from_environment
+
+from dex_connectors.alphavantage import new_project_connection
+
+from .flow import CONNECTION_NAME, DemoFlow
+
+
+async def run_worker() -> None:
+    """Load the named Dex Web connection and serve quote lookups."""
+    project = await load_from_environment()
+    connection = None
+    cache = None
+    try:
+        connection = new_project_connection(project, CONNECTION_NAME)
+        registry = dex.Registry([DemoFlow(connection)], allow_async_handlers=True)
+        cache_directory = os.environ.get(
+            "DEX_BLOB_CACHE_DIR", str(Path(tempfile.gettempdir()) / "dex-alphavantage-demo-blobs")
+        )
+        cache = dex.open_blob_cache(dex.BlobCacheConfig(cache_directory, 1 << 30))
+        worker = dex.AsyncWorker(
+            registry,
+            cache,
+            dex.WorkerOptions(server_address=os.environ.get("DEX_FLOW_SERVICE_ADDRESS", "localhost:8801")),
+        )
+        async with worker:
+            await worker.start()
+    finally:
+        if connection is not None:
+            await connection.aclose()
+        if cache is not None:
+            cache.close()
+        await project.close()
+
+
+def main() -> None:
+    """Run until the Worker stops or the process receives an interrupt."""
+    asyncio.run(run_worker())
+
+
+if __name__ == "__main__":
+    main()

dex_connector_alphavantage-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dex-connector-alphavantage"
+version = "0.1.0"
+description = "Alpha Vantage connector for Dex Flows"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+dependencies = ["dex-connectors-sdk==0.1.0", "dex-python-sdk>=1.28.0", "httpx>=0.27"]
+
+[dependency-groups]
+dev = ["pytest>=8", "pytest-asyncio>=0.24", "mypy>=1.13", "ruff>=0.7", "pyyaml>=6", "types-PyYAML>=6"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dex_connectors"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = [".", "src"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+mypy_path = "src"
+explicit_package_bases = true
+
+[tool.ruff]
+target-version = "py311"
+line-length = 110
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

dex_connector_alphavantage-0.1.0/src/dex_connectors/alphavantage/__init__.py

@@ -0,0 +1,48 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Alpha Vantage stock market Queries for Dex connector Steps."""
+
+from .client import (
+    CONNECTOR_ID,
+    DEFECT,
+    FOUND,
+    GET_GLOBAL_QUOTE_DEFINITION,
+    GET_TIME_SERIES_DAILY_DEFINITION,
+    INVALID_RESPONSE,
+    NOT_FOUND,
+    PROVIDER_REJECTED,
+    Client,
+    Config,
+    Credentials,
+    GetGlobalQuoteOperation,
+    GetTimeSeriesDailyOperation,
+)
+from .connection import Connection, new_connection, new_connection_with_operations, new_project_connection
+from .models import DailyPrice, DailySeriesOutput, GlobalQuoteOutput, StockInput
+from .steps import new_get_global_quote_step, new_get_time_series_daily_step
+
+__all__ = [
+    "Client",
+    "Config",
+    "Connection",
+    "Credentials",
+    "DailyPrice",
+    "DailySeriesOutput",
+    "GetGlobalQuoteOperation",
+    "GetTimeSeriesDailyOperation",
+    "GlobalQuoteOutput",
+    "StockInput",
+    "new_connection",
+    "new_connection_with_operations",
+    "new_get_global_quote_step",
+    "new_get_time_series_daily_step",
+    "new_project_connection",
+    "CONNECTOR_ID",
+    "DEFECT",
+    "FOUND",
+    "GET_GLOBAL_QUOTE_DEFINITION",
+    "GET_TIME_SERIES_DAILY_DEFINITION",
+    "INVALID_RESPONSE",
+    "NOT_FOUND",
+    "PROVIDER_REJECTED",
+]

dex_connector_alphavantage-0.1.0/src/dex_connectors/alphavantage/_generated/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT

dex_connector_alphavantage-0.1.0/src/dex_connectors/alphavantage/_generated/config.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+# ruff: noqa
+
+from dataclasses import dataclass
+
+from dex_connectors.sdk import SecretString
+
+
+@dataclass(frozen=True, slots=True)
+class Config:
+
+    base_url: str = "https://www.alphavantage.co"
+    timeout_seconds: float = 15
+    max_response_bytes: int = 1048576
+
+setattr(Config, '__module__', 'dex_connectors.alphavantage.client')
+
+
+@dataclass(frozen=True, slots=True)
+class Credentials:
+
+    api_key: SecretString
+
+setattr(Credentials, '__module__', 'dex_connectors.alphavantage.client')

dex_connector_alphavantage-0.1.0/src/dex_connectors/alphavantage/_generated/connection.py

@@ -0,0 +1,131 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+# ruff: noqa
+
+from typing import Any
+
+import httpx
+from dex_connectors.sdk import ConnectionRef, Query, Call, SecretString
+from dex_connectors.sdk.projectconfig import ConnectionKey, LoadedProject
+
+from ..client import Client, Config, Credentials
+from .definitions import CONNECTOR_ID, GET_GLOBAL_QUOTE_DEFINITION, GET_TIME_SERIES_DAILY_DEFINITION
+from ..models import DailySeriesOutput, GlobalQuoteOutput, StockInput
+
+class Connection:
+
+    __slots__ = ('_get_global_quote', '_get_time_series_daily', '_client', 'reference')
+
+    def __init__(self,
+        reference: ConnectionRef,
+        get_global_quote: Query[StockInput, GlobalQuoteOutput],
+        get_time_series_daily: Query[StockInput, DailySeriesOutput],
+        client: Client | None = None,
+    ) -> None:
+        reference.validate()
+        if reference.provider != CONNECTOR_ID or get_global_quote is None or get_time_series_daily is None:
+            raise ValueError("Alpha Vantage connection provider and operations are required")
+        if get_global_quote.definition().operation != GET_GLOBAL_QUOTE_DEFINITION.operation:
+            raise ValueError("Alpha Vantage connection operation identity differs")
+        if get_time_series_daily.definition().operation != GET_TIME_SERIES_DAILY_DEFINITION.operation:
+            raise ValueError("Alpha Vantage connection operation identity differs")
+        self.reference = reference
+        self._get_global_quote = get_global_quote
+        self._get_time_series_daily = get_time_series_daily
+        self._client = client
+
+    def get_global_quote(self) -> Query[StockInput, GlobalQuoteOutput]:
+        return self._get_global_quote
+
+    def get_time_series_daily(self) -> Query[StockInput, DailySeriesOutput]:
+        return self._get_time_series_daily
+
+    async def aclose(self) -> None:
+        if self._client is not None:
+            await self._client.aclose()
+
+    def __repr__(self) -> str:
+        return "alphavantage.Connection([REDACTED])"
+
+    def __reduce__(self) -> tuple[object, ...]:
+        raise TypeError("Alpha Vantage connections cannot be serialized")
+
+setattr(Connection, '__module__', 'dex_connectors.alphavantage.connection')
+
+
+def new_connection(client: Client, reference: ConnectionRef) -> Connection:
+    if client is None:
+        raise ValueError("Alpha Vantage client is required")
+    return Connection(reference, client.get_global_quote(), client.get_time_series_daily(), client)
+
+setattr(new_connection, '__module__', 'dex_connectors.alphavantage.connection')
+
+
+def new_connection_with_operations(
+    get_global_quote: Query[StockInput, GlobalQuoteOutput],
+    get_time_series_daily: Query[StockInput, DailySeriesOutput],
+    reference: ConnectionRef,
+) -> Connection:
+    return Connection(reference, get_global_quote, get_time_series_daily)
+
+setattr(new_connection_with_operations, '__module__', 'dex_connectors.alphavantage.connection')
+
+
+class _ProjectCredentialSource:
+
+    def __init__(self, project: LoadedProject, key: ConnectionKey) -> None:
+        self.project = project
+        self.key = key
+
+    async def resolve(self, call: Call) -> Credentials:
+        material = await self.project.resolve_credential(self.key, str(call.id))
+        api_key = material.get("api_key")
+        if not isinstance(api_key, str) or not api_key:
+            raise ValueError("Alpha Vantage credential api_key is required")
+        return Credentials(SecretString(api_key))
+
+
+def new_project_connection(
+    project: LoadedProject, connection_name: str, http_client: httpx.AsyncClient | None = None
+) -> Connection:
+    if project is None:
+        raise ValueError("Alpha Vantage connection requires loaded project configuration")
+    reference = ConnectionRef(CONNECTOR_ID, connection_name)
+    reference.validate()
+    key = ConnectionKey(CONNECTOR_ID, connection_name)
+    matching = [
+        entry
+        for entry in project.configuration.connections
+        if entry.connector_id == CONNECTOR_ID and entry.connection_name == connection_name
+    ]
+    if len(matching) != 1:
+        raise ValueError("Alpha Vantage project connection is missing or duplicated")
+    if matching[0].provider != CONNECTOR_ID:
+        raise ValueError("Alpha Vantage project connection provider differs")
+    config = _decode_config(matching[0].configuration)
+    client = Client(config, _ProjectCredentialSource(project, key), http_client)
+    return new_connection(client, reference)
+
+setattr(new_project_connection, '__module__', 'dex_connectors.alphavantage.connection')
+
+
+def _decode_config(value: dict[str, Any]) -> Config:
+    if set(value) - {"baseUrl", "timeout", "maxResponseBytes"}:
+        raise ValueError("Alpha Vantage configuration has unknown fields")
+    config_arguments: dict[str, Any] = {}
+    if "baseUrl" in value:
+        base_url = value["baseUrl"]
+        if not (isinstance(base_url, str)):
+            raise ValueError("Alpha Vantage configuration baseUrl has an invalid type")
+        config_arguments['base_url'] = base_url
+    if "timeout" in value:
+        timeout = value["timeout"]
+        if not (type(timeout) is int):
+            raise ValueError("Alpha Vantage configuration timeout has an invalid type")
+        config_arguments['timeout_seconds'] = timeout / 1_000_000_000
+    if "maxResponseBytes" in value:
+        max_response_bytes = value["maxResponseBytes"]
+        if not (type(max_response_bytes) is int):
+            raise ValueError("Alpha Vantage configuration maxResponseBytes has an invalid type")
+        config_arguments['max_response_bytes'] = max_response_bytes
+    return Config(**config_arguments)

dex_connector_alphavantage-0.1.0/src/dex_connectors/alphavantage/_generated/definitions.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+# ruff: noqa
+
+from datetime import timedelta
+
+from dex_connectors.sdk import (
+    BranchDefinition,
+    MutationDefinition,
+    OperationRef,
+    QueryDefinition,
+    RetryPolicy,
+    StepDefaults,
+    default_connector_step_execute_retry_policy,
+)
+
+CONNECTOR_ID = "alphavantage"
+PROVIDER = "alphavantage"
+GET_GLOBAL_QUOTE_OPERATION_ID = "getGlobalQuote"
+GET_TIME_SERIES_DAILY_OPERATION_ID = "getTimeSeriesDaily"
+DEFECT = "defect"
+FOUND = "found"
+INVALID_RESPONSE = "invalidResponse"
+NOT_FOUND = "notFound"
+PROVIDER_REJECTED = "providerRejected"
+
+GET_GLOBAL_QUOTE_DEFINITION = QueryDefinition(
+    OperationRef(CONNECTOR_ID, GET_GLOBAL_QUOTE_OPERATION_ID),
+    (
+        BranchDefinition(FOUND, "Alpha Vantage returned the requested result.", False),
+        BranchDefinition(NOT_FOUND, "No market data exists for the requested symbol.", True),
+        BranchDefinition(PROVIDER_REJECTED, "The provider conclusively rejected the request.", True),
+        BranchDefinition(INVALID_RESPONSE, "The provider returned malformed or oversized data.", True),
+        BranchDefinition(DEFECT, "Local input or credentials are invalid.", True),
+    ),
+    StepDefaults(
+        timedelta(seconds=30),
+        2,
+        execute_retry=default_connector_step_execute_retry_policy(),
+    ),
+)
+
+GET_TIME_SERIES_DAILY_DEFINITION = QueryDefinition(
+    OperationRef(CONNECTOR_ID, GET_TIME_SERIES_DAILY_OPERATION_ID),
+    (
+        BranchDefinition(FOUND, "Alpha Vantage returned the requested result.", False),
+        BranchDefinition(NOT_FOUND, "No market data exists for the requested symbol.", True),
+        BranchDefinition(PROVIDER_REJECTED, "The provider conclusively rejected the request.", True),
+        BranchDefinition(INVALID_RESPONSE, "The provider returned malformed or oversized data.", True),
+        BranchDefinition(DEFECT, "Local input or credentials are invalid.", True),
+    ),
+    StepDefaults(
+        timedelta(seconds=30),
+        2,
+        execute_retry=default_connector_step_execute_retry_policy(),
+    ),
+)

dex_connector_alphavantage-0.1.0/src/dex_connectors/alphavantage/_generated/mock.py

@@ -0,0 +1,119 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+# ruff: noqa
+
+from datetime import datetime
+
+from dex_connectors.sdk import ConnectionRef, Failure, FailureKind
+from dex_connectors.sdk.connectormock import Case, Query
+
+from ..connection import Connection, new_connection_with_operations
+from ..models import DailyPrice, DailySeriesOutput, GlobalQuoteOutput, StockInput
+from .definitions import CONNECTOR_ID, DEFECT, FOUND, GET_GLOBAL_QUOTE_DEFINITION, GET_TIME_SERIES_DAILY_DEFINITION, INVALID_RESPONSE, NOT_FOUND, PROVIDER_REJECTED
+
+def get_global_quote_found(value: GlobalQuoteOutput, failure: Failure | None = None) -> Case[GlobalQuoteOutput]:
+    return Case.branch_result(FOUND, value, failure)
+
+setattr(get_global_quote_found, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_global_quote_not_found(value: GlobalQuoteOutput, failure: Failure | None = None) -> Case[GlobalQuoteOutput]:
+    return Case.branch_result(NOT_FOUND, value, failure)
+
+setattr(get_global_quote_not_found, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_global_quote_provider_rejected(value: GlobalQuoteOutput, failure: Failure | None = None) -> Case[GlobalQuoteOutput]:
+    return Case.branch_result(PROVIDER_REJECTED, value, failure)
+
+setattr(get_global_quote_provider_rejected, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_global_quote_invalid_response(value: GlobalQuoteOutput, failure: Failure | None = None) -> Case[GlobalQuoteOutput]:
+    return Case.branch_result(INVALID_RESPONSE, value, failure)
+
+setattr(get_global_quote_invalid_response, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_global_quote_defect(value: GlobalQuoteOutput, failure: Failure | None = None) -> Case[GlobalQuoteOutput]:
+    return Case.branch_result(DEFECT, value, failure)
+
+setattr(get_global_quote_defect, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_global_quote_retry(failure: Failure, after_seconds: float = 0) -> Case[GlobalQuoteOutput]:
+    return Case.retry(failure, after_seconds)
+
+setattr(get_global_quote_retry, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_global_quote_found_default() -> Case[GlobalQuoteOutput]:
+    return Case.branch_result(FOUND, GlobalQuoteOutput(symbol='IBM', price='255.25', latest_trading_day='2026-10-28'))
+
+setattr(get_global_quote_found_default, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_time_series_daily_found(value: DailySeriesOutput, failure: Failure | None = None) -> Case[DailySeriesOutput]:
+    return Case.branch_result(FOUND, value, failure)
+
+setattr(get_time_series_daily_found, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_time_series_daily_not_found(value: DailySeriesOutput, failure: Failure | None = None) -> Case[DailySeriesOutput]:
+    return Case.branch_result(NOT_FOUND, value, failure)
+
+setattr(get_time_series_daily_not_found, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_time_series_daily_provider_rejected(value: DailySeriesOutput, failure: Failure | None = None) -> Case[DailySeriesOutput]:
+    return Case.branch_result(PROVIDER_REJECTED, value, failure)
+
+setattr(get_time_series_daily_provider_rejected, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_time_series_daily_invalid_response(value: DailySeriesOutput, failure: Failure | None = None) -> Case[DailySeriesOutput]:
+    return Case.branch_result(INVALID_RESPONSE, value, failure)
+
+setattr(get_time_series_daily_invalid_response, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_time_series_daily_defect(value: DailySeriesOutput, failure: Failure | None = None) -> Case[DailySeriesOutput]:
+    return Case.branch_result(DEFECT, value, failure)
+
+setattr(get_time_series_daily_defect, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_time_series_daily_retry(failure: Failure, after_seconds: float = 0) -> Case[DailySeriesOutput]:
+    return Case.retry(failure, after_seconds)
+
+setattr(get_time_series_daily_retry, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+def get_time_series_daily_found_default() -> Case[DailySeriesOutput]:
+    return Case.branch_result(FOUND, DailySeriesOutput(symbol='IBM', days=(DailyPrice(date='2026-10-28', open='254.00', high='256.00', low='253.00', close='255.25', volume='1200000'),)))
+
+setattr(get_time_series_daily_found_default, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+
+class Mock:
+
+    def __init__(self, connection_name: str = "alphavantage") -> None:
+        self.get_global_quote_script: Query[StockInput, GlobalQuoteOutput] = Query(GET_GLOBAL_QUOTE_DEFINITION)
+        self.get_global_quote_script.default(get_global_quote_found_default())
+        self.get_time_series_daily_script: Query[StockInput, DailySeriesOutput] = Query(GET_TIME_SERIES_DAILY_DEFINITION)
+        self.get_time_series_daily_script.default(get_time_series_daily_found_default())
+        self._connection = new_connection_with_operations(
+            get_global_quote=self.get_global_quote_script,
+            get_time_series_daily=self.get_time_series_daily_script,
+            reference=ConnectionRef(CONNECTOR_ID, connection_name),
+        )
+
+    def connection(self) -> Connection:
+        return self._connection
+
+setattr(Mock, '__module__', "dex_connectors.alphavantage.alphavantagemock")
+
+__all__ = [
+    "Mock",
+    "get_global_quote_found",
+    "get_global_quote_not_found",
+    "get_global_quote_provider_rejected",
+    "get_global_quote_invalid_response",
+    "get_global_quote_defect",
+    "get_global_quote_retry",
+    "get_global_quote_found_default",
+    "get_time_series_daily_found",
+    "get_time_series_daily_not_found",
+    "get_time_series_daily_provider_rejected",
+    "get_time_series_daily_invalid_response",
+    "get_time_series_daily_defect",
+    "get_time_series_daily_retry",
+    "get_time_series_daily_found_default",
+]