g3fiQFddlmZddlZddlZddlZddlmZmZmZddl m Z ddl m Z m Z mZmZmZmZmZddlmZddlmZddlmZdd lmZdd lmZmZdd lmZm Z dd l!m"Z"dd l#m$Z$ddl%m&Z&m'Z'ddl(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:ddl;mZ>m?Z?dZ@Gdde e+e-fZAe d"dddd d#dZBed$dZBed%dZB d"dddd d&dZBedZCedZDGd d!e e<ZEy)') 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 entrypointcFeZdZddd ddZddZd dZd dZy) _TaskFunctionN) cache_policynamec|Gt|dr4tj|j|j}||_|}n||_||_||_||_tj||y)N__func__) hasattr functoolspartialr3__self____name__func retry_policyr0update_wrapper)selfr9r:r0r1instance_methods U/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/langgraph/func/__init__.py__init__z_TaskFunction.__init__/sm  tZ(#,"3"3DMM4=="Q+/(&!%  ((  t,cbt|jg||j|jd|S)N)r:r0)rr9r:r0)r<argskwargss r>__call__z_TaskFunction.__call__GsA II   ****    r@c||j0|jtt|jxsdffyyzClear the cache for this task.N __dynamic__)r0clearrr!r9r<caches r> clear_cachez_TaskFunction.clear_cachePs5    ( KK/:dii+@+QMRT U )r@cK|j8|jtt|jxsdffd{yy7wrF)r0aclearrr!r9rIs r> aclear_cachez_TaskFunction.aclear_cacheUsK    (,,!:dii#8#IMJL   ) s?A AA ) r9*Callable[P, Awaitable[T]] | Callable[P, T]r:zSequence[RetryPolicy]r0,CachePolicy[Callable[P, str | bytes]] | Noner1 str | NonereturnNone)rBzP.argsrCzP.kwargsrRzSyncAsyncFuture[T])rJrrRrS)r8 __module__ __qualname__r?rDrKrNr@r>r/r/.sR FJ -8-, - C -  - -0 V r@r/)r1r:r0c yNrV)__func_or_none__r1r:r0rCs r>r,r,]sr@cyrXrVrYs r>r,r,ksNQr@cyrXrVr[s r>r,r,osCFr@c |jdtx}tur tjdtd||}|dnt |t r|fn| dfd }|||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 stacklevelrVc"t|S)N)r:r0r1)r/)r9r0r1retry_policiess r> decoratorztask..decorators ~Lt  r@)r9rOrRzCallable[P, SyncAsyncFuture[T]])getrwarningswarnr* isinstancer')rYr1r:r0rCr^rfres ` ` @r>r,r,ssVGW--g= [0   L    lK 0_   8 ( #)** r@RSceZdZdZ d ddZed ieGddeee fZ d dZ y) 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 |jdtx}tur5tjdtd|t t t|}|jdtx} tur*tjdtd| t d| }||_ ||_ ||_ ||_ ||_ ||_y) z$Initialize the entrypoint decorator. config_schemazW`config_schema` is deprecated and will be removed. Please use `context_schema` instead.r`raNr^r_z#RetryPolicy | Sequence[RetryPolicy])rgrrhrir+r typer)r* checkpointerstorerJr0r:context_schema) r<rqrrrJrsr0r:rCror^s r>r?zentrypoint.__init__s$ZZA AM' Q MMi4  %!%d8nm!DZZ1 1E' A MM_4  ##$I5Q (  ((,r@c(eZdZUdZded< ded<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 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) ``` rkvaluerlsaveN)r8rTrU__doc____annotations__rVr@r>finalrus >T r@rzcLtj|stj|r tdt |}d}tj |}t t|jjd}|s td|j|jtjjur|j|jnt}dd}dd}tt} } |jtjjur|jt j"ur tx} } n|t%|j} | t j"urGt'|j} t)| dk7r t+dt'|j\} } n|jx} } t-|j.t1|t2gt2t5t7t8| t7t:| gg it2t=|t8t?| t8t:t?| t:it2t8t8|d |j@|jB|jD|jF|jHxsd |jJ 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 parametercRt|tjr |jS|S)zEExtract the return_ value the entrypoint.final object or passthrough.)rjr-rzrvrvs 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.)rjr-rzrwr~s r>_pluck_save_valuez.entrypoint.__call__.._pluck_save_values !+E:3C3C!D5:: O% Or@r`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)boundtriggerschannelswritersTrV) nodesrinput_channelsoutput_channelsstream_channels stream_mode stream_eagerrqrrrJr0r:rs)rvrrRr)&inspectisgeneratorfunctionisasyncgenfunctionNotImplementedErrorr signaturenextiter parameterskeys ValueError annotation Signatureemptyrreturn_annotationr-rzr r len TypeErrorrr8r"rr#r$rrrrrqrrrJr0r:rs) r<r9rrsigfirst_parameter_name input_typerr output_type save_typeorigintype_annotationss r>rDzentrypoint.__call__sT  & &t ,0J0J40P%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..?  r@)NNNNNN)rqzBaseCheckpointSaver | NonerrzBaseStore | NonerJzBaseCache | Nonersztype[ContextT] | Noner0zCachePolicy | Noner:*RetryPolicy | Sequence[RetryPolicy] | NonerCUnpack[DeprecatedKwargs]rRrSrV)r9zCallable[..., Any]rRr) r8rTrUrxr?rr%r rkrlrzrDrVr@r>r-r-scN48"&"&04+/CG"-0"- "- "- . "- ) "-A"-+"- "-H& 1 & & P\ r@r-rX) rYrSr1rQr:rr0rPrCrrRzKCallable[[Callable[P, Awaitable[T]] | Callable[P, T]], _TaskFunction[P, T]])rYzCallable[P, Awaitable[T]]rR_TaskFunction[P, T])rYzCallable[P, T]rRr) rYz1Callable[P, Awaitable[T]] | Callable[P, T] | Noner1rQr:rr0rPrCrrRzaCallable[[Callable[P, Awaitable[T]] | Callable[P, T]], _TaskFunction[P, T]] | _TaskFunction[P, T])F __future__rr5rrhcollections.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,rkrlr-rVr@r>rs"99!+9*$DA=3*#.CLL%W ,GAqDM,^ ! ?CAE    =  ?  '     Q Q F FKOf?CAE fGf f= f ? f ' ffR CL CLO "O r@