} i,T^ddlmZddlZddlZddlZddlmZmZmZddl m Z ddl m Z m Z mZmZmZmZmZddlmZddlmZddlmZdd lmZdd lmZdd lmZmZdd l m!Z!m"Z"dd l#m$Z$ddl%m&Z&ddl'm(Z(m)Z)ddl*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2ddl3m4Z4ddl5m6Z6m7Z7ddl8m9Z9m:Z:m;Z;mZ>ddl?m@Z@mAZAdZBGdde e-e/fZCe d4ddddd5d'ZDed6d*ZDed7d,ZD d4ddddd8d/ZDed0ZEed1ZFGd2d3e e>ZGdS)9) annotationsN) AwaitableCallableSequence) dataclass)AnyGenericTypeVarcastget_args get_originoverload) BaseCache)BaseCheckpointSaver) BaseStore)Unpack)_serde)CACHE_NS_WRITESPREVIOUS)MISSINGDeprecatedKwargs)EphemeralValue) LastValue)ENDSTART)Pregel)PSyncAsyncFutureTcallget_runnable_for_entrypoint identifier) PregelNode) ChannelWriteChannelWriteEntry) _DC_KWARGS CachePolicy RetryPolicy StreamMode)ContextT)LangGraphDeprecatedSinceV05LangGraphDeprecatedSinceV10)task entrypointc6eZdZddddd ZddZddZddZdS) _TaskFunctionN) cache_policynamefunc*Callable[P, Awaitable[T]] | Callable[P, T] retry_policySequence[RetryPolicy]r1,CachePolicy[Callable[P, str | bytes]] | Noner2 str | NonereturnNonec|@t|dr)tj|j|j}||_|}n||_||_||_||_tj ||dS)N__func__) hasattr functoolspartialr<__self____name__r3r5r1update_wrapper)selfr3r5r1r2instance_methods C:\Users\Dell Inspiron 16\Desktop\tws\AgrotaPowerBi\back-agrota-powerbi\mcp-client-agrota\venv\Lib\site-packages\langgraph/func/__init__.py__init__z_TaskFunction.__init__0s|  tZ(( %#,"3DM4="Q"Q+/(&!%  (( t,,,,,argsP.argskwargsP.kwargsSyncAsyncFuture[T]cFt|jg|R|j|jd|S)N)r5r1)r r3r5r1)rCrHrJs rE__call__z_TaskFunction.__call__HsH I    **      rGcachercz|j3|tt|jpdffdSdSzClear the cache for this task.N __dynamic__)r1clearrr"r3rCrOs rE clear_cachez_TaskFunction.clear_cacheQsB   ( KK/:di+@+@+QMRT U U U U U ) (rGcK|j9|tt|jpdffd{VdSdSrQ)r1aclearrr"r3rTs rE aclear_cachez_TaskFunction.aclear_cacheVso   (,,!:di#8#8#IMJL          ) (rG) r3r4r5r6r1r7r2r8r9r:)rHrIrJrKr9rL)rOrr9r:)rA __module__ __qualname__rFrNrUrXrGrEr0r0/s| FJ ------0    VVVV rGr0)r2r5r1__func_or_none__r:r2r8r5*RetryPolicy | Sequence[RetryPolicy] | Noner1r7rJUnpack[DeprecatedKwargs]r9KCallable[[Callable[P, Awaitable[T]] | Callable[P, T]], _TaskFunction[P, T]]c dSNr[)r\r2r5r1rJs rEr-r-^s 3rGCallable[P, Awaitable[T]]_TaskFunction[P, T]cdSrar[r\s rEr-r-lsNQcrGCallable[P, T]cdSrar[res rEr-r-psCF3rG1Callable[P, Awaitable[T]] | Callable[P, T] | NoneaCallable[[Callable[P, Awaitable[T]] | Callable[P, T]], _TaskFunction[P, T]] | _TaskFunction[P, T]c |dtx}tur tjdtd||}|dnt |t r|fn|d fd }| ||S|S) aSDefine 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 stacklevelNr[r3r4r9Callable[P, SyncAsyncFuture[T]]c*t|S)N)r5r1r2)r0)r3r1r2retry_policiess rE decoratorztask..decorators% ~Lt    rG)r3r4r9rq)getrwarningswarnr+ isinstancer()r\r2r5r1rJrkrtrss ` ` @rEr-r-tsVGW---g== [0      L    lK 0 0l__          #y)*** rGRScxeZdZdZ dddZedieGddeee fZ ddZ dS)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) ``` N checkpointerBaseCheckpointSaver | NonestoreBaseStore | NonerOBaseCache | Nonecontext_schematype[ContextT] | Noner1CachePolicy | Noner5r]rJr^r9r:c |dtx}tur>tjdtd| t t t|}|dtx} tur.tjdtd|t d| }||_ ||_ ||_ ||_ ||_ ||_dS) z$Initialize the entrypoint decorator. config_schemazW`config_schema` is deprecated and will be removed. Please use `context_schema` instead.rmrnNrkrlz#RetryPolicy | Sequence[RetryPolicy])rurrvrwr,r typer*r+r|r~rOr1r5r) rCr|r~rOrr1r5rJrrks rErFzentrypoint.__init__s$ZZAA AM' Q Q Mi4     %!%d8nm!D!DZZ11 1E' A A M_4     ##$I5QQ (  ((,rGc*eZdZUdZded< ded<dS)entrypoint.finalaA 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) ``` ryvaluerzsaveN)rArYrZ__doc____annotations__r[rGrEfinalrs7  > T  rGrr3Callable[..., Any]rctj|stj|rtdt |}d}tj|}t t|j d}|std|j|j tj j ur|j|j nt}dd}dd }tt} } |jtj j ur|jt jur tx} } nyt%|j} | t jurNt'|j} t)| d krt+d t'|j\} } n |jx} } t-|jt1|t2gt2t5t7t8| t7t:| gg it2t=|t8t?| t8t:t?| t:it2t8t8|d|j |j!|j"|j#|j$pd|j% } tLj'rVtMj(|| | g|j%|j%gngz| j)}|| _*tMj+| j || _ | S)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 parameterrrr9cHt|tjr|jn|S)zEExtract the return_ value the entrypoint.final object or passthrough.)rxr.rrrs rE_pluck_return_valuez0entrypoint.__call__.._pluck_return_values ",UJ4D"E"EP5;;5 PrGcHt|tjr|jn|S)z?Get save value from the entrypoint.final object or passthrough.)rxr.rrrs rE_pluck_save_valuez.entrypoint.__call__.._pluck_save_values !+E:3C!D!DO5::% OrGrmzPlease 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_eagerr|r~rOr1r5r)schemasr)rrr9r),inspectisgeneratorfunctionisasyncgenfunctionNotImplementedErrorr! signaturenextiter parameterskeys ValueError annotation Signatureemptyrreturn_annotationr.rr r len TypeErrorrrAr#rr$r%rrrrr|r~rOr1r5rrSTRICT_MSGPACK_ENABLEDbuild_serde_allowlistr_serde_allowlistapply_checkpointer_allowlist)rCr3rrsigfirst_parameter_name input_typerr output_type save_typeorigintype_annotationsgraphserde_allowlists rErNzentrypoint.__call__s-  &t , , 0J40P0P %E ,D11"+ %%#D)<)<)>)>$?$?FF# USTT T~23>$*++ N/ 0 ; ;  Q Q Q Q P P P P"%cY  (9(? ? ?%)999*-- ii#C$9::Z---'/0E'F'F$+,,11'O .6c6K-L-L*K.1.CCK)17 z#W"$ 1#>Q R R R 1(CT U U U    ~j11Y{C00)Ix88 !#*****0b.? 2 2 2 B  ( $:#[)<,0,?,KD'((QSUO &5E "!'!D"O""E  rG)NNNNNN)r|r}r~rrOrrrr1rr5r]rJr^r9r:r[)r3rr9r) rArYrZrrFrr&r ryrzrrNr[rGrEr.r.sccN48"&"&04+/CG"-"-"-"-"-HY& & & & & 1 & & & PggggggrGr.ra) r\r:r2r8r5r]r1r7rJr^r9r_)r\rbr9rc)r\rfr9rc) r\rhr2r8r5r]r1r7rJr^r9ri)H __future__rr>rrvcollections.abcrrr dataclassesrtypingrr r r r r rlanggraph.cache.baserlanggraph.checkpoint.baserlanggraph.store.basertyping_extensionsrlanggraph._internalrlanggraph._internal._constantsrrlanggraph._internal._typingrr"langgraph.channels.ephemeral_valuerlanggraph.channels.last_valuerlanggraph.constantsrrlanggraph.pregelrlanggraph.pregel._callrrrr r!r"langgraph.pregel._readr#langgraph.pregel._writer$r%langgraph.typesr&r'r(r)langgraph.typingr*langgraph.warningsr+r,__all__r0r-ryrzr.r[rGrErs""""""9999999999!!!!!!+*****999999******$$$$$$&&&&&&DDDDDDDDAAAAAAAA======333333********######.-----CCCCCCCCLLLLLLLLLLLL%%%%%%WWWWWWWW ,,,,,GAqDM,,,^ ! ?CAE        QQQ Q FFF FKOf?CAE ffffffR GCLL GCLLZZZZZ"ZZZZZrG