MKiQVSSKJr SSKrSSKrSSKrSSKJrJrJr SSK J r SSK J r J r JrJrJrJrJr SSKJr SSKJr SSKJr SS KJr SS KJrJr SS KJrJ r SS K!J"r" SS K#J$r$ SSK%J&r&J'r' SSK(J)r) SSK*J+r+J,r,J-r-J.r.J/r/J0r0 SSK1J2r2 SSK3J4r4J5r5 SSK6J7r7J8r8J9r9J:r: SSK;Jr>J?r? Sr@"SS\ \+\-45rA\S"SSSS.S#Sjjj5rB\S$Sj5rB\S%Sj5rBS"SSSS.S&SjjjrB\"S5rC\"S5rD"S S!\ \<5rEg)') annotationsN) AwaitableCallableSequence) dataclass)AnyGenericTypeVarcastget_args get_originoverload) BaseCache)BaseCheckpointSaver) BaseStore)Unpack)CACHE_NS_WRITESPREVIOUS)MISSINGDeprecatedKwargs)EphemeralValue) LastValue)ENDSTART)Pregel)PSyncAsyncFutureTcallget_runnable_for_entrypoint identifier) PregelNode) ChannelWriteChannelWriteEntry) _DC_KWARGS CachePolicy RetryPolicy StreamMode)ContextT)LangGraphDeprecatedSinceV05LangGraphDeprecatedSinceV10)task entrypointcX\rSrSrSSS.S SjjrS SjrS SjrS SjrSrg) _TaskFunction.N) cache_policynamecUbK[US5(a4[R"URUR5nXElUnOXAlXlX lX0l[R"X5 g)N__func__) hasattr functoolspartialr4__self____name__func retry_policyr1update_wrapper)selfr:r;r1r2instance_methods Y/var/www/html/dynamic-report/venv/lib/python3.13/site-packages/langgraph/func/__init__.py__init___TaskFunction.__init__/sd  tZ((#,"3"3DMM4=="Q+/(&!%  ((  ,cb[UR/UQ7URURS.UD6$)N)r;r1)rr:r;r1)r=argskwargss r?__call___TaskFunction.__call__GsA II   ****    rBcURb5UR[[UR5=(d S445 ggzClear the cache for this task.N __dynamic__)r1clearrr!r:r=caches r? clear_cache_TaskFunction.clear_cachePs5    ( KK/:dii+@+QMRT U )rBc# URb=UR[[UR5=(d S445IShvN ggN7frI)r1aclearrr!r:rLs r? aclear_cache_TaskFunction.aclear_cacheUsJ    (,,!:dii#8#IMJL   ) sAAAA)r1r:r;) r:*Callable[P, Awaitable[T]] | Callable[P, T]r;zSequence[RetryPolicy]r1,CachePolicy[Callable[P, str | bytes]] | Noner2 str | NonereturnNone)rDzP.argsrEzP.kwargsrWzSyncAsyncFuture[T])rMrrWrX) r9 __module__ __qualname____firstlineno__r@rFrNrR__static_attributes__rBr?r/r/.sR FJ -8-, - C -  - -0 V rBr/)r2r;r1c gNr])__func_or_none__r2r;r1rEs r?r,r,]srBcgr_r]r`s r?r,r,ksNQrBcgr_r]rbs r?r,r,osCFrBc ^^^URS[5=n[La[R"S[SS9 UcUnUcSO[ U[ 5(aU4OUmSUUU4SjjnUbU"U5$U$)aDefine a LangGraph task using the `task` decorator. !!! important "Requires python 3.11 or higher for async functions" The `task` decorator supports both sync and async functions. To use async functions, ensure that you are using Python 3.11 or higher. Tasks can only be called from within an [`entrypoint`][langgraph.func.entrypoint] or from within a `StateGraph`. A task can be called like a regular function with the following differences: - When a checkpointer is enabled, the function inputs and outputs must be serializable. - The decorated function can only be called from within an entrypoint or `StateGraph`. - Calling the function produces a future. This makes it easy to parallelize tasks. Args: name: An optional name for the task. If not provided, the function name will be used. retry_policy: An optional retry policy (or list of policies) to use for the task in case of a failure. cache_policy: An optional cache policy to use for the task. This allows caching of the task results. Returns: A callable function when used as a decorator. Example: Sync Task ```python from langgraph.func import entrypoint, task @task def add_one_task(a: int) -> int: return a + 1 @entrypoint() def add_one(numbers: list[int]) -> list[int]: futures = [add_one_task(n) for n in numbers] results = [f.result() for f in futures] return results # Call the entrypoint add_one.invoke([1, 2, 3]) # Returns [2, 3, 4] ``` Example: Async Task ```python import asyncio from langgraph.func import entrypoint, task @task async def add_one_task(a: int) -> int: return a + 1 @entrypoint() async def add_one(numbers: list[int]) -> list[int]: futures = [add_one_task(n) for n in numbers] return asyncio.gather(*futures) # Call the entrypoint await add_one.ainvoke([1, 2, 3]) # Returns [2, 3, 4] ``` retryM`retry` is deprecated and will be removed. Please use `retry_policy` instead.category stacklevelr]c>[UTTTS9$)N)r;r1r2)r/)r:r1r2retry_policiess r? decoratortask..decorators ~Lt  rB)r:rTrWzCallable[P, SyncAsyncFuture[T]])getrwarningswarnr* isinstancer')r`r2r;r1rErermrls ` ` @r?r,r,ssVGW--g= [0   L    lK 0 0_   8 (  #)** rBRSc\rSrSrSrS S Sjjr\"S 0\D6"SS\\ \ 455r S Sjr Sr g) r-aDefine a LangGraph workflow using the `entrypoint` decorator. ### Function signature The decorated function must accept a **single parameter**, which serves as the input to the function. This input parameter can be of any type. Use a dictionary to pass **multiple parameters** to the function. ### Injectable parameters The decorated function can request access to additional parameters that will be injected automatically at run time. These parameters include: | Parameter | Description | |------------------|------------------------------------------------------------------------------------------------------| | **`config`** | A configuration object (aka `RunnableConfig`) that holds run-time configuration values. | | **`previous`** | The previous return value for the given thread (available only when a checkpointer is provided). | | **`runtime`** | A `Runtime` object that contains information about the current run, including context, store, writer | The entrypoint decorator can be applied to sync functions or async functions. ### State management The **`previous`** parameter can be used to access the return value of the previous invocation of the entrypoint on the same thread id. This value is only available when a checkpointer is provided. If you want **`previous`** to be different from the return value, you can use the `entrypoint.final` object to return a value while saving a different value to the checkpoint. Args: checkpointer: Specify a checkpointer to create a workflow that can persist its state across runs. store: A generalized key-value store. Some implementations may support semantic search capabilities through an optional `index` configuration. cache: A cache to use for caching the results of the workflow. context_schema: Specifies the schema for the context object that will be passed to the workflow. cache_policy: A cache policy to use for caching the results of the workflow. retry_policy: A retry policy (or list of policies) to use for the workflow in case of a failure. !!! warning "`config_schema` Deprecated" The `config_schema` parameter is deprecated in v0.6.0 and support will be removed in v2.0.0. Please use `context_schema` instead to specify the schema for run-scoped context. Example: Using entrypoint and tasks ```python import time from langgraph.func import entrypoint, task from langgraph.types import interrupt, Command from langgraph.checkpoint.memory import InMemorySaver @task def compose_essay(topic: str) -> str: time.sleep(1.0) # Simulate slow operation return f"An essay about {topic}" @entrypoint(checkpointer=InMemorySaver()) def review_workflow(topic: str) -> dict: """Manages the workflow for generating and reviewing an essay. The workflow includes: 1. Generating an essay about the given topic. 2. Interrupting the workflow for human review of the generated essay. Upon resuming the workflow, compose_essay task will not be re-executed as its result is cached by the checkpointer. Args: topic: The subject of the essay. Returns: dict: A dictionary containing the generated essay and the human review. """ essay_future = compose_essay(topic) essay = essay_future.result() human_review = interrupt({ "question": "Please provide a review", "essay": essay }) return { "essay": essay, "review": human_review, } # Example configuration for the workflow config = { "configurable": { "thread_id": "some_thread" } } # Topic for the essay topic = "cats" # Stream the workflow to generate the essay and await human review for result in review_workflow.stream(topic, config): print(result) # Example human review provided after the interrupt human_review = "This essay is great." # Resume the workflow with the provided human review for result in review_workflow.stream(Command(resume=human_review), config): print(result) ``` Example: Accessing the previous return value When a checkpointer is enabled the function can access the previous return value of the previous invocation on the same thread id. ```python from typing import Optional from langgraph.checkpoint.memory import MemorySaver from langgraph.func import entrypoint @entrypoint(checkpointer=InMemorySaver()) def my_workflow(input_data: str, previous: Optional[str] = None) -> str: return "world" config = {"configurable": {"thread_id": "some_thread"}} my_workflow.invoke("hello", config) ``` Example: Using `entrypoint.final` to save a value The `entrypoint.final` object allows you to return a value while saving a different value to the checkpoint. This value will be accessible in the next invocation of the entrypoint via the `previous` parameter, as long as the same thread id is used. ```python from typing import Any from langgraph.checkpoint.memory import MemorySaver from langgraph.func import entrypoint @entrypoint(checkpointer=InMemorySaver()) def my_workflow( number: int, *, previous: Any = None, ) -> entrypoint.final[int, int]: previous = previous or 0 # This will return the previous value to the caller, saving # 2 * number to the checkpoint, which will be used in the next invocation # for the `previous` parameter. return entrypoint.final(value=previous, save=2 * number) config = {"configurable": {"thread_id": "some_thread"}} my_workflow.invoke(3, config) # 0 (previous was None) my_workflow.invoke(1, config) # 6 (previous was 3 * 2 from the previous invocation) ``` Nc URS[5=n[La4[R"S[SS9 Uc[ [ [U5nURS[5=n [La)[R"S[SS9 Uc [ SU 5nXl X l X0l XPl X`l X@lg) z$Initialize the entrypoint decorator. config_schemazW`config_schema` is deprecated and will be removed. Please use `context_schema` instead.rgrhNrerfz#RetryPolicy | Sequence[RetryPolicy])rorrprqr+r typer)r* checkpointerstorerMr1r;context_schema) r=rzr{rMr|r1r;rErxres r?r@entrypoint.__init__s$ZZA AM' Q MMi4  %!%d8nm!DZZ1 1E' A MM_4  ##$I5Q (  ((,rBc0\rSrSr%SrS\S'S\S'Srg) entrypoint.finaliaA primitive that can be returned from an entrypoint. This primitive allows to save a value to the checkpointer distinct from the return value from the entrypoint. Example: Decoupling the return value and the save value ```python from langgraph.checkpoint.memory import InMemorySaver from langgraph.func import entrypoint @entrypoint(checkpointer=InMemorySaver()) def my_workflow( number: int, *, previous: Any = None, ) -> entrypoint.final[int, int]: previous = previous or 0 # This will return the previous value to the caller, saving # 2 * number to the checkpoint, which will be used in the next invocation # for the `previous` parameter. return entrypoint.final(value=previous, save=2 * number) config = {"configurable": {"thread_id": "1"}} my_workflow.invoke(3, config) # 0 (previous was None) my_workflow.invoke(1, config) # 6 (previous was 3 * 2 from the previous invocation) ``` rsvaluertsaver]N)r9rYrZr[__doc____annotations__r\r]rBr?finalrs >T rBrch[R"U5(d"U5(a [S5e[ U5nSn[R "U5n[ [URR55S5nU(d [S5eURUR[RRLaURURO[nSSjnSSjn[[pUR[RRLaUR[ R"La[=pO|[%UR5n U [ R"LaG['UR5n [)U 5S:wa [+S5e['UR5upO UR=p[-UR.[1U[2/[2[5[7[8US 9[7[:US 9/5/S 90[2[=U5[8[?U [85[:[?U [:50[2[8[8US UR@URBURDURFURH=(d S URJS 9 $)zConvert a function into a Pregel graph. Args: func: The function to convert. Support both sync and async functions. Returns: A Pregel graph. z3Generators are not supported in the Functional API.updatesNz4Entrypoint function must have at least one parameterc\[U[R5(a UR$U$)zEExtract the return_ value the entrypoint.final object or passthrough.)rrr-rrrs r?_pluck_return_value0entrypoint.__call__.._pluck_return_values#",UJ4D4D"E"E5;; P5 PrBc\[U[R5(a UR$U$)z?Get save value from the entrypoint.final object or passthrough.)rrr-rrrs r?_pluck_save_value.entrypoint.__call__.._pluck_save_values#!+E:3C3C!D!D5:: O% OrBrgzPlease an annotation for both the return_ and the save values.For example, `-> entrypoint.final[int, str]` would assign a return_ a type of `int` and save the type `str`.)mapper)boundtriggerschannelswritersTr]) nodesrinput_channelsoutput_channelsstream_channels stream_mode stream_eagerrzr{rMr1r;r|)rrrWr)&inspectisgeneratorfunctionisasyncgenfunctionNotImplementedErrorr signaturenextiter parameterskeys ValueError annotation Signatureemptyrreturn_annotationr-rr r len TypeErrorrr9r"rr#r$rrrrrzr{rMr1r;r|) r=r:rrsigfirst_parameter_name input_typerr output_type save_typeorigintype_annotationss r?rFentrypoint.__call__sV  & &t , ,0J0J40P0P%E ,D1"+ %#D)<)<)>$?F#ST T~~23>>$$**+ NN/ 0 ; ;  Q P"%cY  (9(9(?(? ?%%)9)99*-- i#C$9$9:Z---'/0E0E'F$+,1'O .6c6K6K-L*K.1.C.CCK z#W"$ 1#>Q R 1(CT U  ~j1Y{C0)Ix8 !#**********0b..?  rB)rMr1rzr|r;r{)NNNNNN)rzzBaseCheckpointSaver | Noner{zBaseStore | NonerMzBaseCache | Noner|ztype[ContextT] | Noner1zCachePolicy | Noner;*RetryPolicy | Sequence[RetryPolicy] | NonerEUnpack[DeprecatedKwargs]rWrXr])r:zCallable[..., Any]rWr)r9rYrZr[rr@rr%r rsrtrrFr\r]rBr?r-r-scN48"&"&04+/CG"-0"- "- "- . "- ) "-A"-+"- "-H& 1 & & P\ rBr-r_) r`rXr2rVr;rr1rUrErrWzKCallable[[Callable[P, Awaitable[T]] | Callable[P, T]], _TaskFunction[P, T]])r`zCallable[P, Awaitable[T]]rW_TaskFunction[P, T])r`zCallable[P, T]rWr) r`z1Callable[P, Awaitable[T]] | Callable[P, T] | Noner2rVr;rr1rUrErrWzaCallable[[Callable[P, Awaitable[T]] | Callable[P, T]], _TaskFunction[P, T]] | _TaskFunction[P, T])F __future__rr6rrpcollections.abcrrr dataclassesrtypingrr r r r r rlanggraph.cache.baserlanggraph.checkpoint.baserlanggraph.store.basertyping_extensionsrlanggraph._internal._constantsrrlanggraph._internal._typingrr"langgraph.channels.ephemeral_valuerlanggraph.channels.last_valuerlanggraph.constantsrrlanggraph.pregelrlanggraph.pregel._callrrrrr r!langgraph.pregel._readr"langgraph.pregel._writer#r$langgraph.typesr%r&r'r(langgraph.typingr)langgraph.warningsr*r+__all__r/r,rsrtr-r]rBr?rs"99!+9*$DA=3*#.CLL%W ,GAqDM,^ ! ?CAE    =  ?  '     Q Q F FKOf?CAE fGf f= f ? f ' ffR CL CLO "O rB