braintrust 0.3.14__py3-none-any.whl → 0.4.0__py3-none-any.whl

braintrust/audit.py

@@ -5,7 +5,7 @@ Utilities for working with audit headers.
 import base64
 import gzip
 import json
-from typing import List, TypedDict
+from typing import TypedDict
 
 
 class AuditResource(TypedDict):
@@ -14,7 +14,7 @@ class AuditResource(TypedDict):
     name: str
 
 
-def parse_audit_resources(hdr: str) -> List[AuditResource]:
+def parse_audit_resources(hdr: str) -> list[AuditResource]:
     j = json.loads(hdr)
     if j["v"] == 1:
         return json.loads(gzip.decompress(base64.b64decode(j["p"])))

braintrust/cli/eval.py

@@ -6,7 +6,6 @@ import os
 import sys
 from dataclasses import dataclass, field
 from threading import Lock
-from typing import Dict, List, Optional, Union
 
 from .. import login
 from ..framework import (
@@ -70,7 +69,7 @@ class EvaluatorOpts:
     no_progress_bars: bool
     terminate_on_failure: bool
     watch: bool
-    filters: List[str]
+    filters: list[str]
     list: bool
     jsonl: bool
 
@@ -79,13 +78,13 @@ class EvaluatorOpts:
 class LoadedEvaluator:
     handle: FileHandle
     evaluator: Evaluator
-    reporter: Optional[Union[ReporterDef, str]] = None
+    reporter: ReporterDef | str | None = None
 
 
 @dataclass
 class EvaluatorState:
-    evaluators: List[LoadedEvaluator] = field(default_factory=list)
-    reporters: Dict[str, ReporterDef] = field(default_factory=dict)
+    evaluators: list[LoadedEvaluator] = field(default_factory=list)
+    reporters: dict[str, ReporterDef] = field(default_factory=dict)
 
 
 def update_evaluators(eval_state: EvaluatorState, handles, terminate_on_failure):
@@ -157,7 +156,7 @@ async def run_evaluator_task(evaluator, position, opts: EvaluatorOpts):
             experiment.flush()
 
 
-def resolve_reporter(reporter: Optional[Union[ReporterDef, str]], reporters: Dict[str, ReporterDef]) -> ReporterDef:
+def resolve_reporter(reporter: ReporterDef | str | None, reporters: dict[str, ReporterDef]) -> ReporterDef:
     if isinstance(reporter, str):
         if reporter not in reporters:
             raise ValueError(f"Reporter {reporter} not found")
@@ -179,7 +178,7 @@ def add_report(eval_reports, reporter, report):
     eval_reports[reporter.name]["results"].append(report)
 
 
-async def run_once(handles: List[FileHandle], evaluator_opts: EvaluatorOpts) -> bool:
+async def run_once(handles: list[FileHandle], evaluator_opts: EvaluatorOpts) -> bool:
     objects = EvaluatorState()
     update_evaluators(objects, handles, terminate_on_failure=evaluator_opts.terminate_on_failure)
 

braintrust/cli/push.py

@@ -13,7 +13,7 @@ import sys
 import tempfile
 import textwrap
 import zipfile
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 import requests
 from braintrust.framework import _set_lazy_load
@@ -24,7 +24,7 @@ from ..generated_types import IfExists
 from ..util import add_azure_blob_headers
 
 
-def _pkg_install_arg(pkg) -> Optional[str]:
+def _pkg_install_arg(pkg) -> str | None:
     try:
         dist = importlib.metadata.distribution(pkg)
         direct_url = dist._path / "direct_url.json"  # type: ignore
@@ -73,11 +73,11 @@ class _ProjectRootImporter(importlib.abc.MetaPathFinder):
         self._project_root, self._path_rest = sys.path[0], sys.path[1:]
         self._sources = []
 
-    def _under_project_root(self, path: List[str]) -> bool:
+    def _under_project_root(self, path: list[str]) -> bool:
         """Returns true if all paths in `path` are under the project root."""
         return all(p.startswith(self._project_root) for p in path)
 
-    def _under_rest(self, path: List[str]) -> bool:
+    def _under_rest(self, path: list[str]) -> bool:
         """Returns true if any path in `path` is under one of the remaining paths in `sys.path`."""
         return any(p.startswith(pr) for p in path for pr in self._path_rest)
 
@@ -94,11 +94,11 @@ class _ProjectRootImporter(importlib.abc.MetaPathFinder):
             self._sources.append(spec.origin)
         return spec
 
-    def sources(self) -> List[str]:
+    def sources(self) -> list[str]:
         return self._sources
 
 
-def _import_module(name: str, path: str) -> List[str]:
+def _import_module(name: str, path: str) -> list[str]:
     """Imports the module and returns the list of source files
     of all modules imported in the process.
 
@@ -120,7 +120,7 @@ def _py_version() -> str:
     return f"{sys.version_info.major}.{sys.version_info.minor}"
 
 
-def _run_install(install_args: List[str], packages_dir: str):
+def _run_install(install_args: list[str], packages_dir: str):
     subprocess.run(
         [
             "uv",
@@ -138,7 +138,7 @@ def _run_install(install_args: List[str], packages_dir: str):
     )
 
 
-def _upload_bundle(entry_module_name: str, sources: List[str], requirements: Optional[str]) -> str:
+def _upload_bundle(entry_module_name: str, sources: list[str], requirements: str | None) -> str:
     _check_uv()
 
     resp = proxy_conn().post_json(
@@ -212,7 +212,7 @@ def _upload_bundle(entry_module_name: str, sources: List[str], requirements: Opt
 
 
 def _collect_function_function_defs(
-    project_ids: ProjectIdCache, functions: List[Dict[str, Any]], bundle_id: str, if_exists: IfExists
+    project_ids: ProjectIdCache, functions: list[dict[str, Any]], bundle_id: str, if_exists: IfExists
 ) -> None:
     for i, f in enumerate(global_.functions):
         source = inspect.getsource(f.handler)
@@ -262,7 +262,7 @@ def _collect_function_function_defs(
 
 
 def _collect_prompt_function_defs(
-    project_ids: ProjectIdCache, functions: List[Dict[str, Any]], if_exists: IfExists
+    project_ids: ProjectIdCache, functions: list[dict[str, Any]], if_exists: IfExists
 ) -> None:
     for p in global_.prompts:
         functions.append(p.to_function_definition(if_exists, project_ids))
@@ -300,7 +300,7 @@ def run(args):
         raise
 
     project_ids = ProjectIdCache()
-    functions: List[Dict[str, Any]] = []
+    functions: list[dict[str, Any]] = []
     if len(global_.functions) > 0:
         bundle_id = _upload_bundle(module_name, sources, args.requirements)
         _collect_function_function_defs(project_ids, functions, bundle_id, args.if_exists)

braintrust/conftest.py

@@ -36,6 +36,7 @@ def override_app_url_for_tests():
 @pytest.fixture(autouse=True)
 def setup_braintrust():
     os.environ.setdefault("GOOGLE_API_KEY", os.getenv("GEMINI_API_KEY", "your_google_api_key_here"))
+    os.environ.setdefault("OPENAI_API_KEY", "sk-test-dummy-api-key-for-vcr-tests")
 
 
 @pytest.fixture(autouse=True)

braintrust/context.py

@@ -5,12 +5,13 @@ import os
 from abc import ABC, abstractmethod
 from contextvars import ContextVar
 from dataclasses import dataclass
-from typing import Any, List, Optional
+from typing import Any
 
 
 @dataclass
 class SpanInfo:
     """Information about a span in the context."""
+
     trace_id: str
     span_id: str
     span_object: Any = None
@@ -19,7 +20,7 @@ class SpanInfo:
 @dataclass
 class ParentSpanIds:
     root_span_id: str
-    span_parents: List[str]
+    span_parents: list[str]
 
 
 class ContextManager(ABC):
@@ -30,7 +31,7 @@ class ContextManager(ABC):
     """
 
     @abstractmethod
-    def get_current_span_info(self) -> Optional[Any]:
+    def get_current_span_info(self) -> Any | None:
         """Get information about the currently active span.
 
         Returns:
@@ -40,7 +41,7 @@ class ContextManager(ABC):
         pass
 
     @abstractmethod
-    def get_parent_span_ids(self) -> Optional[ParentSpanIds]:
+    def get_parent_span_ids(self) -> ParentSpanIds | None:
         """Get parent span IDs for creating a new Braintrust span.
 
         Returns:
@@ -75,32 +76,25 @@ class BraintrustContextManager(ContextManager):
     """Braintrust-only context manager using contextvars when OTEL is not available."""
 
     def __init__(self):
-        self._current_span: ContextVar[Optional[Any]] = ContextVar('braintrust_current_span', default=None)
+        self._current_span: ContextVar[Any | None] = ContextVar("braintrust_current_span", default=None)
 
-    def get_current_span_info(self) -> Optional[SpanInfo]:
+    def get_current_span_info(self) -> SpanInfo | None:
         """Get information about the currently active span."""
         current_span = self._current_span.get()
         if not current_span:
             return None
 
         # Return SpanInfo for BT spans
-        return SpanInfo(
-            trace_id=current_span.root_span_id,
-            span_id=current_span.span_id,
-            span_object=current_span
-        )
+        return SpanInfo(trace_id=current_span.root_span_id, span_id=current_span.span_id, span_object=current_span)
 
-    def get_parent_span_ids(self) -> Optional[ParentSpanIds]:
+    def get_parent_span_ids(self) -> ParentSpanIds | None:
         """Get parent information for creating a new Braintrust span."""
         current_span = self._current_span.get()
         if not current_span:
             return None
 
         # If current span is a BT span, use it as parent
-        return ParentSpanIds(
-            root_span_id=current_span.root_span_id,
-            span_parents=[current_span.span_id]
-        )
+        return ParentSpanIds(root_span_id=current_span.root_span_id, span_parents=[current_span.span_id])
 
     def set_current_span(self, span_object: Any) -> Any:
         """Set the current active span."""
@@ -123,9 +117,10 @@ def get_context_manager() -> ContextManager:
     """
 
     # Check if OTEL should be explicitly enabled via environment variable
-    if os.environ.get('BRAINTRUST_OTEL_COMPAT', '').lower() in ('1', 'true', 'yes'):
+    if os.environ.get("BRAINTRUST_OTEL_COMPAT", "").lower() in ("1", "true", "yes"):
         try:
             from braintrust.otel.context import ContextManager as OtelContextManager
+
             return OtelContextManager()
         except ImportError:
             logging.warning("OTEL not available, falling back to Braintrust-only version")

braintrust/contrib/temporal/__init__.py

@@ -80,7 +80,8 @@ The integration will automatically:
 """
 
 import dataclasses
-from typing import Any, Dict, Mapping, Optional, Type
+from collections.abc import Mapping
+from typing import Any
 
 import braintrust
 import temporalio.activity
@@ -129,7 +130,7 @@ class BraintrustInterceptor(temporalio.client.Interceptor, temporalio.worker.Int
     - Ensures replay safety (no duplicate spans during workflow replay)
     """
 
-    def __init__(self, logger: Optional[Any] = None) -> None:
+    def __init__(self, logger: Any | None = None) -> None:
         """Initialize interceptor.
 
         Args:
@@ -142,7 +143,7 @@ class BraintrustInterceptor(temporalio.client.Interceptor, temporalio.worker.Int
             braintrust.logger._state._override_bg_logger.logger = logger
         self._logger = braintrust.current_logger()
 
-    def _get_logger(self) -> Optional[Any]:
+    def _get_logger(self) -> Any | None:
         """Get logger for creating spans.
 
         Sets thread-local override if background logger provided (for testing),
@@ -152,9 +153,7 @@ class BraintrustInterceptor(temporalio.client.Interceptor, temporalio.worker.Int
             braintrust.logger._state._override_bg_logger.logger = self._bg_logger
         return self._logger
 
-    def intercept_client(
-        self, next: temporalio.client.OutboundInterceptor
-    ) -> temporalio.client.OutboundInterceptor:
+    def intercept_client(self, next: temporalio.client.OutboundInterceptor) -> temporalio.client.OutboundInterceptor:
         """Intercept client calls to propagate span context to workflows."""
         return _BraintrustClientOutboundInterceptor(next, self)
 
@@ -166,14 +165,14 @@ class BraintrustInterceptor(temporalio.client.Interceptor, temporalio.worker.Int
 
     def workflow_interceptor_class(
         self, input: temporalio.worker.WorkflowInterceptorClassInput
-    ) -> Optional[Type["BraintrustWorkflowInboundInterceptor"]]:
+    ) -> type["BraintrustWorkflowInboundInterceptor"] | None:
         """Return workflow interceptor class to propagate context to activities."""
         input.unsafe_extern_functions["__braintrust_get_logger"] = self._get_logger
         return BraintrustWorkflowInboundInterceptor
 
     def _span_context_to_headers(
         self,
-        span_context: Dict[str, Any],
+        span_context: dict[str, Any],
         headers: Mapping[str, temporalio.api.common.v1.Payload],
     ) -> Mapping[str, temporalio.api.common.v1.Payload]:
         """Add span context to headers."""
@@ -188,7 +187,7 @@ class BraintrustInterceptor(temporalio.client.Interceptor, temporalio.worker.Int
 
     def _span_context_from_headers(
         self, headers: Mapping[str, temporalio.api.common.v1.Payload]
-    ) -> Optional[Dict[str, Any]]:
+    ) -> dict[str, Any] | None:
         """Extract span context from headers."""
         if _HEADER_KEY not in headers:
             return None
@@ -204,9 +203,7 @@ class BraintrustInterceptor(temporalio.client.Interceptor, temporalio.worker.Int
 class _BraintrustClientOutboundInterceptor(temporalio.client.OutboundInterceptor):
     """Client interceptor that propagates span context to workflows."""
 
-    def __init__(
-        self, next: temporalio.client.OutboundInterceptor, root: BraintrustInterceptor
-    ) -> None:
+    def __init__(self, next: temporalio.client.OutboundInterceptor, root: BraintrustInterceptor) -> None:
         super().__init__(next)
         self.root = root
 
@@ -233,9 +230,7 @@ class _BraintrustActivityInboundInterceptor(temporalio.worker.ActivityInboundInt
         super().__init__(next)
         self.root = root
 
-    async def execute_activity(
-        self, input: temporalio.worker.ExecuteActivityInput
-    ) -> Any:
+    async def execute_activity(self, input: temporalio.worker.ExecuteActivityInput) -> Any:
         info = temporalio.activity.info()
 
         # Extract parent span context from headers
@@ -281,14 +276,12 @@ class BraintrustWorkflowInboundInterceptor(temporalio.worker.WorkflowInboundInte
     def __init__(self, next: temporalio.worker.WorkflowInboundInterceptor) -> None:
         super().__init__(next)
         self.payload_converter = temporalio.converter.PayloadConverter.default
-        self._parent_span_context: Optional[Dict[str, Any]] = None
+        self._parent_span_context: dict[str, Any] | None = None
 
     def init(self, outbound: temporalio.worker.WorkflowOutboundInterceptor) -> None:
         super().init(_BraintrustWorkflowOutboundInterceptor(outbound, self))
 
-    async def execute_workflow(
-        self, input: temporalio.worker.ExecuteWorkflowInput
-    ) -> Any:
+    async def execute_workflow(self, input: temporalio.worker.ExecuteWorkflowInput) -> Any:
         # Extract parent span context from workflow headers (set by client)
         parent_span_context = None
         if _HEADER_KEY in input.headers:
@@ -342,9 +335,7 @@ class BraintrustWorkflowInboundInterceptor(temporalio.worker.WorkflowInboundInte
                     span.end()
 
 
-class _BraintrustWorkflowOutboundInterceptor(
-    temporalio.worker.WorkflowOutboundInterceptor
-):
+class _BraintrustWorkflowOutboundInterceptor(temporalio.worker.WorkflowOutboundInterceptor):
     """Outbound workflow interceptor that propagates span context to activities."""
 
     def __init__(
@@ -371,9 +362,7 @@ class _BraintrustWorkflowOutboundInterceptor(
                 return {**headers, _HEADER_KEY: payloads[0]}
         return headers
 
-    def start_activity(
-        self, input: temporalio.worker.StartActivityInput
-    ) -> temporalio.workflow.ActivityHandle:
+    def start_activity(self, input: temporalio.worker.StartActivityInput) -> temporalio.workflow.ActivityHandle:
         input.headers = self._add_span_context_to_headers(input.headers)
         return super().start_activity(input)
 
@@ -390,7 +379,7 @@ class _BraintrustWorkflowOutboundInterceptor(
         return super().start_child_workflow(input)
 
 
-def _modify_workflow_runner(existing: Optional[WorkflowRunner]) -> Optional[WorkflowRunner]:
+def _modify_workflow_runner(existing: WorkflowRunner | None) -> WorkflowRunner | None:
     """Add braintrust to sandbox passthrough modules."""
     if isinstance(existing, SandboxedWorkflowRunner):
         new_restrictions = existing.restrictions.with_passthrough_modules("braintrust")
@@ -420,7 +409,7 @@ class BraintrustPlugin(SimplePlugin):
     Requires temporalio >= 1.19.0.
     """
 
-    def __init__(self, logger: Optional[Any] = None) -> None:
+    def __init__(self, logger: Any | None = None) -> None:
         """Initialize the Braintrust plugin.
 
         Args:

braintrust/contrib/temporal/test_temporal.py

@@ -279,11 +279,15 @@ class TestBraintrustPluginIntegration:
 
             # Verify workflow span was created
             workflow_spans = [s for s in spans if "temporal.workflow" in s.get("span_attributes", {}).get("name", "")]
-            assert len(workflow_spans) > 0, f"Expected workflow span to be created. Span names: {[s.get('span_attributes', {}).get('name', 'unknown') for s in spans]}"
+            assert len(workflow_spans) > 0, (
+                f"Expected workflow span to be created. Span names: {[s.get('span_attributes', {}).get('name', 'unknown') for s in spans]}"
+            )
 
             # Verify activity span was created
             activity_spans = [s for s in spans if "temporal.activity" in s.get("span_attributes", {}).get("name", "")]
-            assert len(activity_spans) > 0, f"Expected activity span to be created. Span names: {[s.get('span_attributes', {}).get('name', 'unknown') for s in spans]}"
+            assert len(activity_spans) > 0, (
+                f"Expected activity span to be created. Span names: {[s.get('span_attributes', {}).get('name', 'unknown') for s in spans]}"
+            )
 
     @pytest.mark.asyncio
     async def test_plugin_context_propagation(self, temporal_env, memory_logger):
@@ -498,5 +502,6 @@ class TestBraintrustPluginIntegration:
         # Verify parent-child relationship: workflow should have client span as parent
         workflow_span = workflow_spans[0]
         client_span = client_spans[0]
-        assert workflow_span.get("root_span_id") == client_span.get("root_span_id"), \
+        assert workflow_span.get("root_span_id") == client_span.get("root_span_id"), (
             "Workflow span should be in same trace as client span"
+        )

braintrust/devserver/auth.py

@@ -1,5 +1,5 @@
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from typing import Awaitable, Callable, Dict, Optional
 
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.requests import Request
@@ -15,14 +15,14 @@ BRAINTRUST_PROJECT_ID_HEADER = "x-bt-project-id"
 
 @dataclass
 class RequestContext:
-    app_origin: Optional[str]
-    token: Optional[str]
-    org_name: Optional[str]
-    project_id: Optional[str]
-    state: Optional[BraintrustState]
+    app_origin: str | None
+    token: str | None
+    org_name: str | None
+    project_id: str | None
+    state: BraintrustState | None
 
 
-def extract_allowed_origin(origin: Optional[str]) -> Optional[str]:
+def extract_allowed_origin(origin: str | None) -> str | None:
     """Extract and validate the origin header."""
     # This should use the same check_origin logic from cors.py
     from .cors import check_origin
@@ -32,7 +32,7 @@ def extract_allowed_origin(origin: Optional[str]) -> Optional[str]:
     return None
 
 
-def parse_braintrust_auth_header(headers: Dict[str, str]) -> Optional[str]:
+def parse_braintrust_auth_header(headers: dict[str, str]) -> str | None:
     """Parse the authorization token from headers."""
     # Check x-bt-auth-token first
     token = headers.get(BRAINTRUST_AUTH_TOKEN_HEADER)

braintrust/devserver/cache.py

@@ -1,7 +1,6 @@
 """LRU cache implementation for the dev server."""
 
 import json
-from typing import Dict, Optional
 
 from ..logger import BraintrustState, login_to_state
 
@@ -11,10 +10,10 @@ class LRUCache:
 
     def __init__(self, max_size: int = 32):
         self.max_size = max_size
-        self.cache: Dict[str, BraintrustState] = {}
+        self.cache: dict[str, BraintrustState] = {}
         self.access_order: list[str] = []
 
-    def get(self, key: str) -> Optional[BraintrustState]:
+    def get(self, key: str) -> BraintrustState | None:
         """Get a value from the cache, updating access order."""
         if key in self.cache:
             # Move to end to mark as recently used
@@ -41,7 +40,7 @@ class LRUCache:
 _login_cache = LRUCache(max_size=32)  # TODO: Make this configurable
 
 
-async def cached_login(api_key: str, app_url: str, org_name: Optional[str] = None) -> BraintrustState:
+async def cached_login(api_key: str, app_url: str, org_name: str | None = None) -> BraintrustState:
     """Login with caching to avoid repeated API calls."""
     cache_key = json.dumps({"api_key": api_key, "app_url": app_url, "org_name": org_name})
 

braintrust/devserver/cors.py

@@ -1,9 +1,10 @@
 import os
 import re
-from typing import Any, Awaitable, Callable, Dict, List, Union
+from collections.abc import Awaitable, Callable
+from typing import Any
 
 # CORS configuration
-ALLOWED_ORIGINS: List[Union[str, re.Pattern]] = [
+ALLOWED_ORIGINS: list[str | re.Pattern] = [
     "https://www.braintrust.dev",
     "https://www.braintrustdata.com",
     re.compile(r"https://.*\.preview\.braintrust\.dev"),
@@ -70,9 +71,9 @@ def create_cors_middleware() -> type:
 
         async def __call__(
             self,
-            scope: Dict[str, Any],
-            receive: Callable[[], Awaitable[Dict[str, Any]]],
-            send: Callable[[Dict[str, Any]], Awaitable[None]],
+            scope: dict[str, Any],
+            receive: Callable[[], Awaitable[dict[str, Any]]],
+            send: Callable[[dict[str, Any]], Awaitable[None]],
         ) -> None:
             if scope["type"] == "http":
                 headers = dict(scope["headers"])
@@ -81,7 +82,7 @@ def create_cors_middleware() -> type:
                 # Handle OPTIONS requests
                 if scope["method"] == "OPTIONS":
 
-                    async def send_options_wrapper(message: Dict[str, Any]) -> None:
+                    async def send_options_wrapper(message: dict[str, Any]) -> None:
                         if message["type"] == "http.response.start":
                             headers_dict = dict(message.get("headers", []))
 
@@ -120,7 +121,7 @@ def create_cors_middleware() -> type:
                     return
 
                 # For other requests, add CORS headers if origin is valid
-                async def send_wrapper(message: Dict[str, Any]) -> None:
+                async def send_wrapper(message: dict[str, Any]) -> None:
                     if message["type"] == "http.response.start" and origin and check_origin(origin):
                         headers_dict = dict(message.get("headers", []))
 

braintrust/devserver/dataset.py

@@ -1,11 +1,11 @@
-from typing import Any, Dict, Union
+from typing import Any
 
 from braintrust import init_dataset
 from braintrust._generated_types import RunEvalData, RunEvalData1, RunEvalData2
 from braintrust.logger import BraintrustState
 
 
-async def get_dataset_by_id(state: BraintrustState, dataset_id: str) -> Dict[str, str]:
+async def get_dataset_by_id(state: BraintrustState, dataset_id: str) -> dict[str, str]:
     """Fetch dataset information by ID."""
     # Make API call to get dataset info
     conn = state.api_conn()
@@ -23,9 +23,7 @@ async def get_dataset_by_id(state: BraintrustState, dataset_id: str) -> Dict[str
 
 
 # NOTE: To make this performant, we'll have to make these functions work with async i/o
-async def get_dataset(
-    state: BraintrustState, data: Union[RunEvalData, RunEvalData1, RunEvalData2, Dict[str, Any]]
-) -> Any:
+async def get_dataset(state: BraintrustState, data: RunEvalData | RunEvalData1 | RunEvalData2 | dict[str, Any]) -> Any:
     """
     Get dataset from various data sources.
 

braintrust/devserver/eval_hooks.py

@@ -7,7 +7,8 @@ for reporting progress during evaluation execution.
 
 import asyncio
 import json
-from typing import Any, Callable, Dict, Optional
+from collections.abc import Callable
+from typing import Any
 
 
 class EvalHooks:
@@ -15,13 +16,13 @@ class EvalHooks:
 
     def __init__(
         self,
-        report_progress: Optional[Callable[[Dict[str, Any]], None]] = None,
-        parameters: Optional[Dict[str, Any]] = None,
+        report_progress: Callable[[dict[str, Any]], None] | None = None,
+        parameters: dict[str, Any] | None = None,
     ):
         self._report_progress = report_progress
         self.parameters = parameters or {}
 
-    def report_progress(self, event: Dict[str, Any]) -> None:
+    def report_progress(self, event: dict[str, Any]) -> None:
         """Report progress during task execution."""
         if self._report_progress:
             self._report_progress(event)
@@ -45,7 +46,7 @@ class SSEQueue:
     """Simple wrapper around asyncio.Queue for SSE events."""
 
     def __init__(self):
-        self.queue: asyncio.Queue[Optional[str]] = asyncio.Queue()
+        self.queue: asyncio.Queue[str | None] = asyncio.Queue()
 
     async def put_event(self, event: str, data: Any) -> None:
         """Add an SSE event to the queue."""
@@ -56,6 +57,6 @@ class SSEQueue:
         """Signal end of stream."""
         await self.queue.put(None)
 
-    async def get(self) -> Optional[str]:
+    async def get(self) -> str | None:
         """Get the next event from the queue."""
         return await self.queue.get()