i'dZddlmZddlmZmZddlmZmZddl m Z m Z e rddl m Z edgeeee fdzfZedgeeee fdzfZGd d ZGd d eZGd deZddZy)aComposable lifespans for FastMCP servers. This module provides a `@lifespan` decorator for creating composable server lifespans that can be combined using the `|` operator. Example: ```python from fastmcp import FastMCP from fastmcp.server.lifespan import lifespan @lifespan async def db_lifespan(server): conn = await connect_db() yield {"db": conn} await conn.close() @lifespan async def cache_lifespan(server): cache = await connect_cache() yield {"cache": cache} await cache.close() mcp = FastMCP("server", lifespan=db_lifespan | cache_lifespan) ``` To compose with existing `@asynccontextmanager` lifespans, wrap them explicitly: ```python from contextlib import asynccontextmanager from fastmcp.server.lifespan import lifespan, ContextManagerLifespan @asynccontextmanager async def legacy_lifespan(server): yield {"legacy": True} @lifespan async def new_lifespan(server): yield {"new": True} # Wrap the legacy lifespan explicitly combined = ContextManagerLifespan(legacy_lifespan) | new_lifespan ``` ) annotations) AsyncIteratorCallable)AbstractAsyncContextManagerasynccontextmanager) TYPE_CHECKINGAny)FastMCP FastMCP[Any]Nc2eZdZdZddZeddZddZy) LifespanzComposable lifespan wrapper. Wraps an async generator function and enables composition via the `|` operator. The wrapped function should yield a dict that becomes part of the lifespan context. c||_y)zInitialize a Lifespan wrapper. Args: fn: An async generator function that takes a FastMCP server and yields a dict for the lifespan context. N_fnselffns g/Users/bowang/.openclaw/workspace/ChatDev/.venv/lib/python3.12/site-packages/fastmcp/server/lifespan.py__init__zLifespan.__init__Ds cKt|j|4d{}||nidddd{y77#1d{7swYyxYwwzExecute the lifespan as an async context manager. Args: server: The FastMCP server instance. Yields: The lifespan context dict. N)rrrserverresults r__call__zLifespan.__call__MsG1&txx088F".&B 69888888sA AAA A AAAAA A AAc~t|ts"tdt|jdt ||S)aCompose with another lifespan using the | operator. Args: other: Another Lifespan instance. Returns: A ComposedLifespan that runs both lifespans. Raises: TypeError: If other is not a Lifespan instance. zCannot compose Lifespan with z@. Use @lifespan decorator or wrap with ContextManagerLifespan().) isinstancer TypeErrortype__name__ComposedLifespan)rothers r__or__zLifespan.__or__ZsI%*/U 0D0D/EFQR  e,,rN)r LifespanFnreturnNonerr r&zAsyncIterator[dict[str, Any]])r#r r&r")r! __module__ __qualname____doc__rrrr$rrr r =s%  7 7-rr c6eZdZUdZded<ddZeddZy) ContextManagerLifespanzLifespan wrapper for already-wrapped context manager functions. Use this for functions already decorated with @asynccontextmanager. LifespanContextManagerFnrc||_y)z3Initialize with a context manager factory function.Nrrs rrzContextManagerLifespan.__init__vs rcK|j|4d{}||nidddd{y77#1d{7swYyxYwwrrrs rrzContextManagerLifespan.__call__zs?88F##v".&B 6$######s<A7A ; A9AAA A A  AN)rr/r&r'r()r!r)r*r+__annotations__rrrr,rrr.r.ns( "! 7 7rr.c*eZdZdZddZeddZy)r"zTwo lifespans composed together. Enters the left lifespan first, then the right. Exits in reverse order. Results are shallow-merged into a single dict. c ||_||_y)zInitialize a composed lifespan. Args: left: The first lifespan to enter. right: The second lifespan to enter. N_left_right)rleftrights rrzComposedLifespan.__init__s  rc*K|j|4d{}|j|4d{}i||dddd{dddd{y7H707#1d{7swY)xYw7 #1d{7swYyxYww)zExecute both lifespans, merging their results. Args: server: The FastMCP server instance. Yields: The merged lifespan context dict from both lifespans. Nr5)rr left_result right_results rrzComposedLifespan.__call__so JJv  + KK  <1[1L1 1             sBA!BA>A#A> A' A> A% A> BA<B#A>%A>'A9 -A0.A9 5A><B>BB B BN)r8r r9r r&r'r()r!r)r*r+rrrr,rrr"r"s   2 2rr"ct|S)aDecorator to create a composable lifespan. Use this decorator on an async generator function to make it composable with other lifespans using the `|` operator. Example: ```python @lifespan async def my_lifespan(server): # Setup resource = await create_resource() yield {"resource": resource} # Teardown await resource.close() mcp = FastMCP("server", lifespan=my_lifespan | other_lifespan) ``` Args: fn: An async generator function that takes a FastMCP server and yields a dict for the lifespan context. Returns: A composable Lifespan wrapper. )r )rs rlifespanr>s4 B<r)rr%r&r )r+ __future__rcollections.abcrr contextlibrrtypingrr fastmcp.server.serverr dictstrr%r/r r.r"r>r,rrrFs*X#3G%-~& d38nt6K(LL M #1$sCx.42GHH .-.-b7X76 2x 2Fr