(GgJAddlZddlZddlZddlZddlmZddlmZm Z m Z m Z m Z m Z mZmZmZmZddlmZddlmZddlmZddlmZmZmZmZddlmZdd lm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z&dd l'm(Z(m)Z)dd l*m+Z+dd l,m-Z-m.Z.m/Z/edddde e0de e.de ee e e e"fe e e"ffge e e!e"fffdZ1edee e e e"fe e e"ffde e e!e"ffdZ1 ddddde ee e e e"fe e e"ffde e0de e.dee ee e e e"fe e e"ffge e e!e"ffe e e!e"fffdZ1e dZ2e dZ3GddZ4y)N) dataclass) Any AwaitableCallableGenericOptionalTypeVarUnionget_args get_originoverload)EphemeralValue) LastValue)BaseCheckpointSaver)ENDPREVIOUSSTART TAG_HIDDEN)Pregel)PSyncAsyncFutureTcallget_runnable_for_entrypoint) PregelNode) ChannelWriteChannelWriteEntry) BaseStore) _DC_KWARGS RetryPolicy StreamModenameretryr#r$returncyNr"s t/home/kushmeetdev/apache_webroot/langgraph_flaskproject/venv/lib/python3.12/site-packages/langgraph/func/__init__.pytaskr*%s__func_or_none__cyr'r()r,s r)r*r*0s'*r+c Fdtttttftttffdtttt j jtftttjtffffd }|||S|S)aKDefine 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: retry: An optional retry policy to use for the task in case of a failure. Returns: A callable function when used as a decorator. Example: Sync Task ```python from langgraph.func import entrypoint, task @task def add_one(a: int) -> int: return a + 1 @entrypoint() def add_one(numbers: list[int]) -> list[int]: futures = [add_one(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(a: int) -> int: return a + 1 @entrypoint() async def add_one(numbers: list[int]) -> list[int]: futures = [add_one(n) for n in numbers] return asyncio.gather(*futures) # Call the entrypoint await add_one.ainvoke([1, 2, 3]) # Returns [2, 3, 4] ``` funcr%c(Gt|dr4tj|j|j}|_|}n|_tjt |}tj|ddtj||S)N__func__)r$_is_pregel_taskT) hasattr functoolspartialr1__self____name__robject __setattr__update_wrapper)r/instance_method call_funcr#r$s r) decoratorztask..decorator{s  tZ(#,"3"3DMM4=="Q+/(&!% %%dD> 9&7>'' 488r+) r rrrr concurrentfuturesFutureasyncio)r,r#r$r=s `` r)r*r*6sJ9HQ ! _-x1~=>9 J&&--a0018Aw~~a?P str: time.sleep(1.0) # Simulate slow operation return f"An essay about {topic}" @entrypoint(checkpointer=MemorySaver()) 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 (str): 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 langgraph.checkpoint.memory import MemorySaver from langgraph.func import entrypoint @entrypoint(checkpointer=MemorySaver()) def my_workflow(input_data: str, previous: Optional[str] = None) -> str: return "world" config = { "configurable": { "thread_id": "some_thread" } } my_workflow.invoke("hello") ``` 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 langgraph.checkpoint.memory import MemorySaver from langgraph.func import entrypoint @entrypoint(checkpointer=MemorySaver()) 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 checkpointerstore config_schemar%c.||_||_||_y)z$Initialize the entrypoint decorator.N)rFrGrH)selfrFrGrHs r)__init__zentrypoint.__init__7s) *r+c(eZdZUdZeed< eed<y)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 MemorySaver from langgraph.func import entrypoint @entrypoint(checkpointer=MemorySaver()) 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) ``` valuesaveN)r7 __module__ __qualname____doc__rB__annotations__rCr(r+r)finalrMBs :R r+rTr/.cBtj|stj|r tdt |}d}tj |}t t|jjd}|s td|j|jtjjur|j|jnt}dtdtfd}dtdtfd}tt} } |jtjjur|jt j"ur tx} } n|t%|j} | t j"urGt'|j} t)| d k7r t+d t'|j\} } n|jx} } t-|j.t1|t2gt2gt5t7t8| t7t:| gt<g g it2t?|t8tA| t8t:tA| t:it2t8t8|d|jB|jD|jF 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 parameterrNr%cRt|tjr |jS|S)zEExtract the return_ value the entrypoint.final object or passthrough.) isinstancerErTrNrNs r)_pluck_return_valuez0entrypoint.__call__.._pluck_return_values ",UJ4D4D"E5;; P5 Pr+cRt|tjr |jS|S)z?Get save value from the entrypoint.final object or passthrough.)rXrErTrOrYs r)_pluck_save_valuez.entrypoint.__call__.._pluck_save_values !+E:3C3C!D5:: O% Or+zPlease 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)tags)boundtriggerschannelswritersT) nodesrbinput_channelsoutput_channelsstream_channels stream_mode stream_eagerrFrG config_type)$inspectisgeneratorfunctionisasyncgenfunctionNotImplementedErrorr signaturenextiter parameterskeys ValueError annotation Signatureemptyrreturn_annotationrErTr r len TypeErrorrr7rrrrrrrrrrFrGrH) rJr/r`rhsigfirst_parameter_name input_typerZr\ output_type save_typeorigintype_annotationss r)__call__zentrypoint.__call__is_  & &t ,0J0J40P%E ,D1"+ %#D)<)<)>$?F#ST T~~23>>$$**+ NN/ 0 ; ;  Qs Qs Q PS PS P"%cY  (9(9(?(? ?%%)9)99*-- i#C$9$9:Z---'/0E0E'F$+,1'O .6c6K6K-L*K.1.C.CCK) z#W#W$ 1#>Q R 1(CT U#-  "~j1Y{C0)Ix8 !#******;  r+)NNNr()r7rPrQrRrrrtyperrKrrrrBrCrTrrrr(r+r)rErEsVt7;%)-1 +23 + " + S * +  +$ 1 $ $ LZ Xc3h/Z FZ r+rEr')5rAconcurrent.futuresr>r4rk dataclassesrtypingrrrrrr r r r r "langgraph.channels.ephemeral_valuerlanggraph.channels.last_valuerlanggraph.checkpoint.baserlanggraph.constantsrrrrlanggraph.pregelrlanggraph.pregel.callrrrrrlanggraph.pregel.readrlanggraph.pregel.writerrlanggraph.store.baserlanggraph.typesrr r!strr*rBrCrEr(r+r)rs!   >39@@#-B*?? #' 3- K  8Ay|O $hq!tn 456 Q" "#%   *HQ ! _5x1~EF* a##$* * TX]#' ]uXa1o%>A%NOP] 3-] K ]   x9Q<((1a4.8 9:OA&&' ) Q" "# % ]@ CL CLe e r+