ó lQjãó¶•SrSSKJr SSKrSSKJs Jr SSK J r J r J r J r \ (aSSKJr \ Sr"SS5r\"5qS S S jjrSS jrSS jrg)z¼Runtime overrides for LangSmith. This module provides hooks to override LangSmith's default runtime behavior, primarily for environments with constrained async runtimes (e.g., Temporal). é)Ú annotationsN)Ú TYPE_CHECKINGÚAnyÚCallableÚOptional)Ú Awaitable).zAwaitable[Any]có.•\rSrSrSrSrSSSjjrSrg)ÚRuntimeOverrideséaHOverrides for LangSmith runtime behavior. This class allows overriding default async implementations for environments that don't support certain asyncio features (e.g., Temporal doesn't support ``run_in_executor``). Example: import langsmith import contextvars async def my_aio_to_thread( default_aio_to_thread, ctx, func, /, *args, **kwargs ): # Custom implementation return ctx.run(func, *args, **kwargs) langsmith.set_runtime_overrides(aio_to_thread=my_aio_to_thread) # Reset to defaults langsmith.set_runtime_overrides() ©Ú aio_to_threadNcó•Xlg)a‹Initialize runtime overrides. Args: aio_to_thread: Custom async-to-thread implementation, with signature ``async def (default_aio_to_thread, ctx, func, /, *args, **kwargs)``. ``default_aio_to_thread`` is LangSmith's default implementation, which the override can call to fall back to default behavior (e.g., when outside a constrained runtime context). ``ctx`` is the ``contextvars.Context`` LangSmith wants ``func`` to run inside; tracing state will be read back from this Context after the call. Override for runtimes like Temporal that don't support ``asyncio.run_in_executor``. Nr )Úselfr s ÚY/home/mande/repo/quber/.venv/lib/python3.13/site-packages/langsmith/_runtime_overrides.pyÚ__init__ÚRuntimeOverrides.__init__0s €ð"+Õó©N)r úOptional[AioToThread])Ú__name__Ú __module__Ú __qualname__Ú__firstlineno__Ú__doc__Ú __slots__rÚ__static_attributes__©rrr r s%†ñð0#€Ið04ð+à,÷+ð+rr có•[US9qg)aüSet LangSmith runtime overrides. This allows customizing LangSmith's async runtime behavior for environments with constrained async runtimes (e.g., Temporal, which doesn't support ``run_in_executor``). Args: aio_to_thread: Custom async function to run sync functions asynchronously. Should have signature: ``async def aio_to_thread( default_aio_to_thread, ctx, func, /, *args, **kwargs )``. ``default_aio_to_thread`` is LangSmith's default implementation, which the override can call to fall back to default behavior. The implementation must invoke ``func`` inside ``ctx`` (e.g. ``ctx.run(func, *args, **kwargs)``) so that LangSmith's tracing state, which is read back from ``ctx`` after the call, is visible to downstream code. Pass ``None`` to use the default implementation. Example: For Temporal or similar runtimes: ```python import langsmith async def temporal_aio_to_thread( default_aio_to_thread, ctx, func, /, *args, **kwargs ): # Use the default implementation when not in a workflow if not temporalio.workflow.in_workflow(): return await default_aio_to_thread(ctx, func, *args, **kwargs) with temporalio.workflow.unsafe.sandbox_unrestricted(): return ctx.run(func, *args, **kwargs) langsmith.set_runtime_overrides(aio_to_thread=temporal_aio_to_thread) ``` Reset to defaults: ```python langsmith.set_runtime_overrides() ``` r N)r Ú_runtime_overridesr s rÚset_runtime_overridesr Gs€ôb*¸ ÑFÑrcó•[$)z"Get the current runtime overrides.)rrrrÚget_runtime_overridesr"{s€ä Ðrcó&•[RSL$)aiReturn True iff an ``aio_to_thread`` override is currently installed. Callers use this to select a loop-behavior-independent path for re-entering a LangSmith-mutated Context (the explicit ``tracing_context(**get_tracing_context(ctx))`` fallback), rather than relying on ``asyncio.create_task(coro, context=ctx)`` which some custom event loops silently ignore. N)rr rrrÚ_aio_to_thread_override_activer$€s€ô × +Ñ +°4Ð 7Ð7rr)r rÚreturnÚNone)r%r )r%Úbool)rÚ __future__rÚbuiltinsÚ @py_builtinsÚ_pytest.assertion.rewriteÚ assertionÚrewriteÚ @pytest_arÚtypingrrrrÚcollections.abcrÚ AioToThreadr rr r"r$rrrÚr2soðñõ #ç„×9Ó9æÝ)ððñ€ ÷ ,+ñ,+ñ^&Ó'Ðð,0ð1GØ(ð1Gà õ1Gôhõ 8r