+ Q(i':Rt^RIHt^RIHtHt^RIHtHt^RI H t H t ] 'd^RI H t ]R.]]]] 3,R,,3,t]R.]]]] 3,R,,3,t!RR 4t!R R ]4t!R R ]4tRRltR#)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]NcH]tRt^=tRtRRlt]RRl4tRRltRt R #) 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 V^8dQhRRRR/#)fn LifespanFnreturnNone)formats"]/Users/agent/.openclaw/workspace/venv/lib/python3.14/site-packages/fastmcp/server/lifespan.py __annotate__Lifespan.__annotate__Ds:$c WnR#)zInitialize a Lifespan wrapper. Args: fn: An async generator function that takes a FastMCP server and yields a dict for the lifespan context. N_fnselfrs&&r__init__Lifespan.__init__Ds rc V^8dQhRRRR/#rserverr rzAsyncIterator[dict[str, Any]]r)rs"rrrNs 7 7\ 76S 7rc "\VP4!V4;_uu_4GRjxL pVeTM/5xRRR4GRjxL R#L!L +GRjxL 'giR#;i5izExecute the lifespan as an async context manager. Args: server: The FastMCP server instance. Yields: The lifespan context dict. N)rrrr"results&& r__call__Lifespan.__call__MsA'txx0888F".&B 6988888sI(A-A A- A A-AA-A-A* A A* "A* $ A-c V^8dQhRRRR/#)rotherr rComposedLifespanr)rs"rrrZs--H-)9-rc \V\4'g#\R\V4P R24h\ W4#)zCompose 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__r+)rr*s&&r__or__Lifespan.__or__ZsJ%**/U 0D0D/EFQR  ,,rrN) r0 __module__ __qualname____firstlineno____doc__rrr'r1__static_attributes__rrrr r =s*  7 7--rr cH]tRt^nt$RtR]R&RRlt]RRl4tRt R #) ContextManagerLifespanzLifespan wrapper for already-wrapped context manager functions. Use this for functions already decorated with @asynccontextmanager. LifespanContextManagerFnrc V^8dQhRRRR/#)rrr:rrr)rs"rr#ContextManagerLifespan.__annotate__vs3rc WnR#)z3Initialize with a context manager factory function.Nrrs&&rrContextManagerLifespan.__init__vsrc V^8dQhRRRR/#r!r)rs"rrr<{s 7 7\ 76S 7rc "VPV4;_uu_4GRjxL pVeTM/5xRRR4GRjxL R#L!L +GRjxL 'giR#;i5ir$rr%s&& rr'ContextManagerLifespan.__call__zs<88F###v".&B 6$#####sGA#AA# A A#AA#A#A A A A  A#rN) r0r3r4r5r6__annotations__rrr'r7rrrr9r9ns( "! 7 7rr9c<]tRt^tRtRRlt]RRl4tRtR#)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$V^8dQhRRRRRR/#)rleftr rightrrr)rs"rrComposedLifespan.__annotate__s!  X h 4 rc WnW nR#)zwInitialize a composed lifespan. Args: left: The first lifespan to enter. right: The second lifespan to enter. N_left_right)rrErFs&&&rrComposedLifespan.__init__s  rc V^8dQhRRRR/#r!r)rs"rrrGs 2 2\ 26S 2rc  j"VPV4;_uu_4GRjxL pVPV4;_uu_4GRjxL p/VCVC5xRRR4GRjxL RRR4GRjxL R#LQL1L +GRjxL 'giL1;iL( +GRjxL 'giR#;i5i)zExecute both lifespans, merging their results. Args: server: The FastMCP server instance. Yields: The merged lifespan context dict from both lifespans. NrI)rr" left_result right_results&& rr'ComposedLifespan.__call__sm JJv   + KK   <1[1L1 1            sB3A2B3BA4 B A8  BA6B B3+B,B34B6B8B >B? B B BB3B0 B B0 (B0 * B3rIN) r0r3r4r5r6rrr'r7rrrr+r+s   2 2rr+c V^8dQhRRRR/#)rrrrr r)rs"rrrsrc\V4#)apDecorator 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&rlifespanrTs4 B<r)r6 __future__rcollections.abcrr contextlibrrtypingrrfastmcp.server.serverr dictstrrr:r r9r+rTrrrr\s*X#3G%-~& d38nt6K(LL M #1$sCx.42GHH .-.-b7X76 2x 2Fr