%`iR ddlZddlZddlmZmZmZmZmZmZm Z m Z m Z m Z m Z mZ ddlmZmZn#e$r ddlmZmZYnwxYwddlmcmZddlmcmZddlZddlmZmZmZmZddlm Z ddl!m"Z"ddl#m$Z$ddl%m&Z&dd l'm(Z(dd l)m*Z*m+Z+m,Z,dd l-m.Z.dd l/m0Z0m1Z1m2Z2dd l3m4Z4m5Z5ddlm6Z6m7Z7m8Z8m9Z9ddl:m;Z;mZ>m?Z?ddl@mAZAddlBmCZCmDZDddlEmFZFmGZGmHZHer ejIeJZKdZLe dZMe deNeMfZOe dZPedZQe dZRe dZSe dZTe dZUe dZVe dZWe dZXe dZYe d ZZe d!Z[Gd"d#eePZ\Gd$d%eePeRfZ]Gd&d'eePeReSfZ^Gd(d)eePeReSeTfZ_Gd*d+eePeReSeTeUfZ`Gd,d-eePeReSeTeUeVfZaGd.d/eePeReSeTeUeVeWfZbGd0d1eePeReSeTeUeVeWeXfZcGd2d3eePeReSeTeUeVeWeXeYf ZdGd4d5eePeReSeTeUeVeWeXeYeZf ZeGd6d7eePeReSeTeUeVeWeXeYeZe[f Zfed8eeeRgePfd9e]ePeRffd:Zged8eeeReSgePfd9e^ePeReSffd;Zged8eeeReSeTgePfd9e_ePeReSeTffd<Zged8eeeReSeTeUgePfd9e`ePeReSeTeUffd=Zged8eeeReSeTeUeVgePfd9eaePeReSeTeUeVffd>Zged8eeeReSeTeUeVeWgePfd9ebePeReSeTeUeVeWffd?Zged8eeeReSeTeUeVeWeXgePfd9ecePeReSeTeUeVeWeXffd@Zged8eeeReSeTeUeVeWeXeYg ePfd9edePeReSeTeUeVeWeXeYf fdAZged8eeeReSeTeUeVeWeXeYeZg ePfd9eeePeReSeTeUeVeWeXeYeZf fdBZged8eeeReSeTeUeVeWeXeYeZe[g ePfd9efePeReSeTeUeVeWeXeYeZe[f fdCZged8eegePfd9e\ePfdDZgeddddddddEdFe e ehe dGfdHe eidIe ehdJe e ejekelfdKe ehdLe ejdMe e.d9eeeeeQfePfgeffdNZge?e+dOZgGdPdQZme?GdRdSZnGdTdUeoZpGdVdWZqe?GdXdYerZsdZZte?Gd[d\eeMZue?Gd]d^eeMZvd_Zwd`Zxe?daZydS)bN) TYPE_CHECKINGAnyCallableDictGenericListLiteralOptionalTupleTypeVarUnionoverload) Concatenate ParamSpec) ActorClassIDLanguage ObjectRefcross_language)ray_option_utils)DEFAULT_MAX_CONCURRENCY_ASYNC))_warn_if_using_deprecated_placement_group)has_async_methods)wrap_auto_init)client_mode_convert_actorclient_mode_hookclient_mode_should_convert)TensorTransportEnum)is_class_methodis_function_or_methodis_static_method)get_runtime_env_info#parse_runtime_env_for_task_or_actor)STREAMING_GENERATOR_RETURNObjectRefGeneratorPythonFunctionDescriptor(raise_sys_exit_with_custom_error_message)ActorAlreadyExistsErrorAsyncioActorExit) DeveloperAPI PublicAPI)+_configure_placement_group_based_on_context) PlacementGroupSchedulingStrategySchedulingStrategyT)_inject_tracing_into_class_tracing_actor_creation _tracing_actor_method_invocationTzActorHandle[T]_Ret_P_T0_T1_T2_T3_T4_T5_T6_T7_T8_T9c"eZdZddZdefdZdS)_RemoteMethodNoArgsreturnObjectRef[_Ret]cdSNselfs ]/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/ray/actor.pyremotez_RemoteMethodNoArgs.remote^ cdSrCrDrEs rGbindz_RemoteMethodNoArgs.bindarIrJN)r@rA)__name__ __module__ __qualname__rHrrLrDrJrGr?r?]sC     c      rJr?c&eZdZddZdedefdZdS) _RemoteMethod0_RemoteMethod0__arg0Union[_T0, ObjectRef[_T0]]r@rAcdSrCrDrFrRs rGrHz_RemoteMethod0.remotefrIrJcdSrCrDrUs rGrLz_RemoteMethod0.bindirIrJN)rRrSr@rA)rMrNrOrHr4rrLrDrJrGrQrQesJ     3 3      rJrQc6eZdZ d dZdededefdZd S) _RemoteMethod1_RemoteMethod1__arg0rS_RemoteMethod1__arg1Union[_T1, ObjectRef[_T1]]r@rAcdSrCrDrFrYrZs rGrHz_RemoteMethod1.remoten  rJcdSrCrDr]s rGrLz_RemoteMethod1.bindsrIrJN)rYrSrZr[r@rA)rMrNrOrHr4r5rrLrDrJrGrXrXmsi 2 eZdZ d d Zdedededefd Zd S) _RemoteMethod2_RemoteMethod2__arg0rS_RemoteMethod2__arg1r[_RemoteMethod2__arg2Union[_T2, ObjectRef[_T2]]r@rAcdSrCrDrFrbrcrds rGrHz_RemoteMethod2.remotexs rJcdSrCrDrgs rGrLz_RemoteMethod2.bindrIrJN)rbrSrcr[rdrer@rA) rMrNrOrHr4r5r6rrLrDrJrGraraws~ , - -        3  S S      rJrac FeZdZ dd Zdedededed ef d Z d S)_RemoteMethod3_RemoteMethod3__arg0rS_RemoteMethod3__arg1r[_RemoteMethod3__arg2re_RemoteMethod3__arg3Union[_T3, ObjectRef[_T3]]r@rAcdSrCrDrFrkrlrmrns rGrHz_RemoteMethod3.remotes  rJcdSrCrDrqs rGrLz_RemoteMethod3.bindrIrJN) rkrSrlr[rmrernror@rA) rMrNrOrHr4r5r6r7rrLrDrJrGrjrjs , - -  -        3  S # #      rJrjc NeZdZ dd Zdedededed ed e f dZ dS)_RemoteMethod4_RemoteMethod4__arg0rS_RemoteMethod4__arg1r[_RemoteMethod4__arg2re_RemoteMethod4__arg3ro_RemoteMethod4__arg4Union[_T4, ObjectRef[_T4]]r@rAcdSrCrDrFrurvrwrxrys rGrHz_RemoteMethod4.remotes  rJcdSrCrDr|s rGrLz_RemoteMethod4.bindr^rJN) rurSrvr[rwrerxroryrzr@rA) rMrNrOrHr4r5r6r7r8rrLrDrJrGrtrts , - -  -  -         #& 03 =@ JM       rJrtcVeZdZ ddZdedededed ed e d e fdZ dS)_RemoteMethod5_RemoteMethod5__arg0rS_RemoteMethod5__arg1r[_RemoteMethod5__arg2re_RemoteMethod5__arg3ro_RemoteMethod5__arg4rz_RemoteMethod5__arg5Union[_T5, ObjectRef[_T5]]r@rAcdSrCrDrFrrrrrrs rGrHz_RemoteMethod5.remote  rJcdSrCrDrs rGrLz_RemoteMethod5.bindrrJN)rrSrr[rrerrorrzrrr@rA) rMrNrOrHr4r5r6r7r8r9rrLrDrJrGrrs  ,  -  -  -  -  -                              rJrc^eZdZ ddZdedededed ed e d e de fdZ dS)_RemoteMethod6_RemoteMethod6__arg0rS_RemoteMethod6__arg1r[_RemoteMethod6__arg2re_RemoteMethod6__arg3ro_RemoteMethod6__arg4rz_RemoteMethod6__arg5r_RemoteMethod6__arg6Union[_T6, ObjectRef[_T6]]r@rAcdSrCrDrFrrrrrrrs rGrHz_RemoteMethod6.remote  rJcdSrCrDrs rGrLz_RemoteMethod6.bindrrJN)rrSrr[rrerrorrzrrrrr@rA) rMrNrOrHr4r5r6r7r8r9r:rrLrDrJrGrrs  ,  -  -  -  -  -  -                                rJrcfeZdZ ddZdedededed ed e d e de de fdZ dS)_RemoteMethod7_RemoteMethod7__arg0rS_RemoteMethod7__arg1r[_RemoteMethod7__arg2re_RemoteMethod7__arg3ro_RemoteMethod7__arg4rz_RemoteMethod7__arg5r_RemoteMethod7__arg6r_RemoteMethod7__arg7Union[_T7, ObjectRef[_T7]]r@rAc dSrCrD rFrrrrrrrrs rGrHz_RemoteMethod7.remote  rJc dSrCrDrs rGrLz_RemoteMethod7.bindrrJN)rrSrr[rrerrorrzrrrrrrr@rA)rMrNrOrHr4r5r6r7r8r9r:r;rrLrDrJrGrrs  ,  -  -  -  -  -  -  -                                  rJrcneZdZ ddZdedededed ed e d e de de de fdZdS)_RemoteMethod8_RemoteMethod8__arg0rS_RemoteMethod8__arg1r[_RemoteMethod8__arg2re_RemoteMethod8__arg3ro_RemoteMethod8__arg4rz_RemoteMethod8__arg5r_RemoteMethod8__arg6r_RemoteMethod8__arg7r_RemoteMethod8__arg8Union[_T8, ObjectRef[_T8]]r@rAc dSrCrD rFrrrrrrrrrs rGrHz_RemoteMethod8.remote  rJc dSrCrDrs rGrLz_RemoteMethod8.bindrrJN)rrSrr[rrerrorrzrrrrrrrrr@rA)rMrNrOrHr4r5r6r7r8r9r:r;r<rrLrDrJrGrrs  ,  -  -  -  -  -  -  -  -                                    rJrcveZdZ ddZdedededed ed e d e de de de defdZdS)_RemoteMethod9_RemoteMethod9__arg0rS_RemoteMethod9__arg1r[_RemoteMethod9__arg2re_RemoteMethod9__arg3ro_RemoteMethod9__arg4rz_RemoteMethod9__arg5r_RemoteMethod9__arg6r_RemoteMethod9__arg7r_RemoteMethod9__arg8r_RemoteMethod9__arg9Union[_T9, ObjectRef[_T9]]r@rAc dSrCrD rFrrrrrrrrrrs rGrHz_RemoteMethod9.remote  rJc dSrCrDrs rGrLz_RemoteMethod9.bindrrJN)rrSrr[rrerrorrzrrrrrrrrrrr@rA)rMrNrOrHr4r5r6r7r8r9r:r;r<r=rrLrDrJrGrrs  ,  -  -  -  -  -  -  -  -  -                                      rJr__methodr@cdSrCrDrs rGmethodr/ CrJcdSrCrDrs rGrr6rrJcdSrCrDrs rGrr=rrJcdSrCrDrs rGrrDrrJcdSrCrDrs rGrrKrrJcdSrCrDrs rGrrRrrJcdSrCrDrs rGrrYrrJcdSrCrDrs rGrr`rrJcdSrCrDrs rGrrgrrJcdSrCrDrs rGrrnrrJcdSrCrDrs rGrrurrJ num_returnsconcurrency_groupmax_task_retriesretry_exceptions#_generator_backpressure_num_objectsenable_task_eventstensor_transportr streamingrrrrrrcdSrCrDrs rGrr|s CrJcbgd}dtttfffd }t|dkr9t |dr$tdkr||dSd|d}t|dks J|D]}d|d |}||vs J||S) a Annotate an actor method. .. code-block:: python @ray.remote class Foo: @ray.method(num_returns=2) def bar(self): return 1, 2 f = Foo.remote() _, _ = f.bar.remote() Args: num_returns: The number of object refs that should be returned by invocations of this actor method. The default value is 1 for a normal actor task and "streaming" for an actor generator task (a function that yields objects instead of returning them). max_task_retries: How many times to retry an actor task if the task fails due to a runtime error, e.g., the actor has died. The default value is 0. If set to -1, the system will retry the failed task until the task succeeds, or the actor has reached its max_restarts limit. If set to `n > 0`, the system will retry the failed task up to n times, after which the task will throw a `RayActorError` exception upon :obj:`ray.get`. Note that Python exceptions may trigger retries *only if* `retry_exceptions` is set for the method, in that case when `max_task_retries` runs out the task will rethrow the exception from the task. You can override this number with the method's `max_task_retries` option in `@ray.method` decorator or in `.option()`. retry_exceptions: Boolean of whether to retry all Python exceptions, or a list of allowlist exceptions to retry. The default value is False (only retry tasks upon system failures and if max_task_retries is set) concurrency_group: The name of the concurrency group to use for the actor method. By default, the actor is single-threaded and runs all actor tasks on the same thread. See :ref:`Defining Concurrency Groups `. tensor_transport: [Alpha] The tensor transport protocol to use for the actor method. The valid values are "OBJECT_STORE" (default), "NCCL", "GLOO", or "NIXL" (case-insensitive). If a non-object store transport is specified, Ray will store a *reference* instead of a copy of any torch.Tensors found inside values returned by this task, and the tensors will be sent directly to other tasks using the specified transport. NCCL and GLOO transports require first creating a collective with the involved actors using :func:`ray.experimental.collective.create_collective_group`. See :ref:`Ray Direct Transport (RDT) ` for more details. rrc,dvr d|_dvr d|_dvr d|_dvr d|_dvr d|_dvrd d|_dvr d}dd lm}||}||_|S) Nrrrrrrrr'normalize_and_validate_tensor_transport) __ray_num_returns____ray_max_task_retries____ray_retry_exceptions____ray_concurrency_group__*__ray_generator_backpressure_num_objects____ray_enable_task_events__(ray.experimental.gpu_object_manager.utilr__ray_tensor_transport__)rrrkwargss rGannotate_methodzmethod..annotate_methods F " ")/ )>F &  ' '.45G.HF +  ' '.45G.HF + & ( (/56I/JF , 0F : :@F5AF = 6 ) )f5I.J.V067K0LF -  ' '%&89        GFGWXX .>F + rJrzjThe @ray.method decorator must be applied using no arguments or at least one of the arguments in the list z+, for example '@ray.method(num_returns=2)'.z-Unexpected keyword argument to @ray.method: 'z''. The supported keyword arguments are )rr3r2lencallable)argsr valid_kwargsr error_stringkeykey_error_strings ` rGrrspLT 26 4yyA~~(47++~F q0@0@tAw''' (2> ( ( ( t99>>><>>>55 >C > >/; > > l"""$4"""" rJceZdZdZ ddedeeeedfdedee e e fde d ed e d ee d ee ejd eefdZddZdS)_ActorMethodMetadataaA container for the metadata required to invoke an actor method. This class intentionally does *not* hold a reference to the `ActorHandle`, as that causes a circular reference that delays `ActorHandle` destruction until the Python GC runs. Instead, it can be used as a factory to lazily generate `ActorMethod` instances that can be used to submit actor tasks for this method. N method_namerrrr is_generator"generator_backpressure_num_objectsr decorator signaturerc ||_||rd}n tj}||_||_||_||_||_||_||_ | |_ | |_ dS)aInitialize an _ActorMethodMetadata. Args: method_name: The name of the actor method. num_returns: The default number of return values that the method invocation should return. If None is given, it uses DEFAULT_ACTOR_METHOD_NUM_RETURN_VALS for a normal actor task and "streaming" for a generator task (when `is_generator` is True). max_task_retries: Number of retries on method failure. retry_exceptions: Boolean or list/tuple of exceptions to retry. is_generator: True if the method is a generator. generator_backpressure_num_objects: Generator-only config for backpressure. enable_task_events: True if task events are enabled for this method. decorator: Optional decorator for the method invocation. signature: The signature of the actor method. tensor_transport: The tensor transport protocol to use for the actor method. Nr) _method_name ray_constants$DEFAULT_ACTOR_METHOD_NUM_RETURN_VALS _num_returns_max_task_retries_retry_exceptions _is_generatorr_enable_task_events _decorator _signature_tensor_transport) rFrrrrrrrrrrs rG__init__z_ActorMethodMetadata.__init__sx<(   Q) +P '!1!1)3U0#5 ##!1rJ actor_handle ActorHandler@ ActorMethodc t||j|j|j|j|j|j|j|j|j |j  S)z\ Produce a bound ActorMethod that holds a strong reference to actor_handle. )rrr) rrrrrrrrrr r )rFr s rGrLz_ActorMethodMetadata.bind6sX       "  "    4  $oo!3    rJNNN)r r r@r)rMrNrO__doc__strr r intr boollisttuplerrinspect Parameterr rLrDrJrGrrs$$(7;*..2.2.2eC)=$=>?.2 .2  dE 12 .2  .2-0.2!.2C=.2D!234.2#3-.2.2.2.2`      rJrceZdZdZ ddeeeedfdedeee e fdeded ed ee e j d eefd Zd ZedZdZdZee ddededffdZee dd eefdZdZdZdS)rzA class used to invoke an actor method. Note: This class should not be instantiated directly. Instead, it should only be used as a return value from the `@ray.method` decorator. Nrrrrrrrrrc  ||_||_||_|j|rd|_ntj|_||_||_||_||_||_ | |_ | |_ | tj j} | |_dS)aInitialize an ActorMethod. Args: actor: The actor instance this method belongs to. method_name: The name of the actor method. num_returns: The default number of return values that the method invocation should return. If None is given, it uses DEFAULT_ACTOR_METHOD_NUM_RETURN_VALS for a normal actor task and "streaming" for a generator task (when `is_generator` is True). max_task_retries: Number of retries on method failure. retry_exceptions: Boolean of whether you want to retry all user-raised exceptions, or a list of allowlist exceptions to retry. is_generator: True if a given method is a Python generator. generator_backpressure_num_objects: Generator-only config. If a number of unconsumed objects reach this threshold, a actor task stop pausing. enable_task_events: True if task events is enabled, i.e., task events from the actor should be reported. Defaults to True. decorator: An optional decorator that should be applied to the actor method invocation. signature: The signature of the actor method. It is None only when cross language feature is used. tensor_transport: The tensor transport protocol to use for the actor method. Nr)_actorrrrrrrrrrr rr OBJECT_STOREnamer ) rFactorrrrrrrrrrrs rGr zActorMethod.__init__SsL ''   $ W$/!!$1$V!!1!1)3U0#5 # $  #2?D !1rJcBtd|jd|jd)NzDActor methods cannot be called directly. Instead of running 'object.z()', try 'object. .remote()'.) TypeErrorrrFrrs rG__call__zActorMethod.__call__s> 6"&"3 6 6( 6 6 6   rJc.|||S)a Bind arguments to the actor method for Ray DAG building. This method generates and returns an intermediate representation (IR) node that indicates the actor method will be called with the given arguments at execution time. This method is used in both :ref:`Ray DAG ` and :ref:`Ray Compiled Graph ` for building a DAG. _bindr"s rGrLzActorMethod.bindszz$'''rJc.|||SrC_remoter"s rGrHzActorMethod.remotes||D&)))rJc |dd}|ddlm}||}|d<Gfdd}|S)aConvenience method for executing an actor method call with options. Same arguments as func._remote(), but returns a wrapped function that a non-underscore .remote() can be called on. Examples: # The following two calls are equivalent. >>> actor.my_method._remote(args=[x, y], name="foo", num_returns=2) >>> actor.my_method.options(name="foo", num_returns=2).remote(x, y) rNrrc8eZdZfdZefdZdS)(ActorMethod.options..FuncWrapperc$jd||dSNrrrDr(rFrrfunc_clsoptionss rGrHz/ActorMethod.options..FuncWrapper.remotes#'x'LT&LLGLLLrJc$jd||dSr.r%r0s rGrLz-ActorMethod.options..FuncWrapper.binds"%x~J4JJ'JJJrJNrMrNrOrHr)rL)r1r2srG FuncWrapperr,sk M M M M M M K K K K K\ K K KrJr5)getrr)rFr2rrr5r1s ` @rGr2zActorMethod.optionss";;'94@@  '       GFGWXX *:G& ' K K K K K K K K K K K{}}rJr@ray.dag.ClassMethodNode)r8.c dddlm}m}m} m} m} ||||d} |j} | td| | | d|| ji}| xjdz c_|j Jd tj |j ||n#t$r}|j }t|dkr&|djdkr|dt#j| }tt'|d |jd |d |d |d dd}~wwxYw| |j||| |}|jdkrmg}t-|jD]G}| d|||ft/t/|d| | i}||Ht3|S|S)Nr)BIND_INDEX_KEYIS_CLASS_METHOD_OUTPUT_KEYPARENT_CLASS_NODE_KEYPREV_CLASS_METHOD_CALL_KEYClassMethodNode)rrrrzLost reference to actorrz,self._signature should be set for .bind API._ray_trace_ctx) parametersz. The function `z` has a signature `z:`, but the given arguments to `bind` doesn't match. args: z . kwargs: .)other_args_to_resolve return_idx_T)ray.dag.class_noder:r;r<r=r>r RuntimeError_ray_dag_bind_indexr r validate_argsr!copyrrpopr Signaturerrrrangedictappendr)rFrrrrrrr:r;r<r=r>r2rrCesignature_copynode output_nodesi output_nodes rGr&zActorMethod._binds              &!23V     =899 9 "5 & E5!  !!Q&!! O ' ' 9 ( ' '   #DOT6 B B B B   !_1133N>""Q&&>"+=+BFV+V+V""2&&&$..IIINq66::4+<::":: $::06:::        "7      a  24L4+,, 1 1-o%!%%1IFFFF/7LeT  ##K0000&& &KsA99 D BDD c   jjdj j j j t jjkrdkrtd dj j std dtj jjj} | j stj d d|pg}|pi}  f d } j| } | ||} t jjkrPt'| t(sJ| }tj jjj} | |j | S) Nrrz)Currently, methods with tensor_transport=z} only support 1 return value. Please make sure the actor method is decorated with `@ray.method(num_returns=1)` (the default).z3Currently, methods with .options(tensor_transport="z") are not supported when enable_tensor_transport=False. Please set @ray.remote(enable_tensor_transport=True) on the actor class definition.z does not have tensor transport z available. If using a collective-based transport ("nccl" or "gloo"), please create a communicator with `ray.experimental.collective.create_collective_group` before calling actor tasks with non-default tensor_transport.c  j}|tdtjjjj}|||| j ||    S)Nz{Lost reference to actor. Actor handles must be stored as variables, e.g. `actor = MyActor.remote()` before calling methods.) rrrrrrconcurrency_group_namerrr) rrFray_privateworker global_workergpu_object_manager#trigger_out_of_band_tensor_transfer_actor_method_callr) rr dst_actorr\rrrrrrrrFrs rG invocationz'ActorMethod._remote..invocationYs I "R"%!4!B!U   B B9d S S S//!'!1!1'87#5!10 rJ)rrrrrr rrr ValueErrorr_ray_enable_tensor_transportrXrYrZr[r\actor_has_tensor_transportr isinstanceradd_gpu_object_ref)rFrrrrrrrrrrr\r` object_refs object_refs` ```````` rGr)zActorMethod._remote sT  +K  ##5   #   ##5   %!%!9  . 68 0  ##5  2?D D Da v@Pvvv;;  jJZjjj"%!4!B!U %@@ - !{TTDTTTT zr2             8 ? &44J jv.. 2?D D Dk955 5 55$J!$!4!B!U   1 1DK)9   rJc |j|j|j|j|j|j|j|j|j|j d S)N) rrrrrrrrrr ) rrrrrrrrrr rEs rG __getstate__zActorMethod.__getstate__sK[,, $ 6 $ 6 .262Z"&":!%!7   rJc ||d|d|d|d|d|d|d|d|d |d  dS) Nrrrrrrrrrr )r )rFstates rG __setstate__zActorMethod.__setstate__sv 'N - - $ % $ % . ! 6 7 & ' +  % & rJr)NNr7NNN NNr7NNNNNNN)rMrNrOrr r rr rrrrrrrr r#r)rLrHr2rr0r r&r)rirlrDrJrGrrKs 7;*.B2B2eC)=$=>? B2  B2  dE 12 B2B2-0B2!B2D!234B2#3-B2B2B2B2H    ( (\ (***B% ,0LL (%0N*OO PLLL&%^L\% ,0*.aa#3-aaa&%^aF          rJrcHeZdZdZiZdZedZedZdS)_ActorClassMethodMetadataaMetadata for all methods in an actor class. This data can be cached. Attributes: methods: The actor methods. decorators: Optional decorators that should be applied to the method invocation function before invoking the actor methods. These can be set by attaching the attribute "__ray_invocation_decorator__" to the actor method. signatures: The signatures of the methods. num_returns: The default number of return values for each actor method. max_task_retries: Number of retries on method failure. retry_exceptions: Boolean of whether you want to retry all user-raised exceptions, or a list of allowlist exceptions to retry, for each method. enable_task_events: True if tracing is enabled, i.e., task events from the actor should be reported. Defaults to True. cZt|j}t|d|d|d)Nz6 can not be constructed directly, instead of running 'z ()', try 'z .create()')typerMr!)rF class_names rGr z"_ActorClassMethodMetadata.__init__sN$ZZ(  + +#- + + + + +   rJc8|jdSrC)_cacheclearclss rG reset_cachez%_ActorClassMethodMetadata.reset_caches rJc|j|}||S||}tj|t }t ||_i|_i|_ i|_ i|_ i|_ i|_ i|_i|_i|_i|_t%d|D|_|D]\}}tj|}t+|pt-||}t/j|| |j |<t3|dr|j|j |<n d|j |<t3|dr|j|j |<t3|dr|j|j |<t3|dr|j|j|<t3|dr|j|j|<t3|dr|j|j|<tj |ptj!|} | |j |<t3|d r|j"|j|<t3|d r|j#|j|<||j|<|S) Nc3K|]:\}}t|dtjjtjjkV;dS)rN)getattrrrr).0_rs rG z3_ActorClassMethodMetadata.create..se0 0 6 *#05   #/4  50 0 0 0 0 0 rJ) ignore_firstrrr__ray_invocation_decorator__rrrr)$rtr6__new__r getmembersrrMmethods decorators signaturesrrrmethod_is_generatorrrconcurrency_group_for_methodsmethod_name_to_tensor_transportanyhas_tensor_transport_methodsunwraprr rextract_signaturehasattrrrrrrrisgeneratorfunctionisasyncgenfunctionrr) rwmodified_class"actor_creation_function_descriptor cached_metarF actor_methodsrris_boundrs rGcreatez _ActorClassMethodMetadata.createsjnn%GHH  " {{3*>;PQQ M**  " "#% "$24/-/*?A,-00 0 +0 0 0 - - )$19 49 4 K^F++F&v..2B 33H,5+F\,,,DOK (v455 5060J --04 -v9:: U5;5T%k2v9:: U5;5T%k2v=>> S/5/R ,v:;; 542v;<< Y7=7X' 4"64+F33 5AD $[ 1vKLL FE7v9:: 434 :> 56 rJN) rMrNrOrrtr  classmethodrxrrDrJrGroroso$F   [ff[fffrJroc"eZdZdZdedefdZdS)_ActorClassMetadataa Metadata for an actor class. Attributes: language: The actor language, e.g. Python, Java. modified_class: The original class that was decorated (with some additional methods added like __ray_terminate__). actor_creation_function_descriptor: The function descriptor for the actor creation task. class_id: The ID of this actor class. method_meta: The actor method metadata. class_name: The name of this class. num_cpus: The default number of CPUs required by the actor creation task. num_gpus: The default number of GPUs required by the actor creation task. memory: The heap memory quota for this actor. resources: The default resources required by the actor creation task. label_selector: The labels required for the node on which this actor can be scheduled on. The label selector consist of key-value pairs, where the keys are label names and the value are expressions consisting of an operator with label values or just a value to indicate equality. fallback_strategy: If specified, expresses soft constraints through a list of decorator options to fall back on when scheduling on a node. Decorator options are evaluated together during scheduling. The first satisfied dict of options is used. Currently only `label_selector` is a supported option. accelerator_type: The specified type of accelerator required for the node on which this actor runs. See :ref:`accelerator types `. runtime_env: The runtime environment for this actor. scheduling_strategy: Strategy about how to schedule this actor. last_export_cluster_and_job: A pair of the last exported cluster and job to help us to know whether this function was exported. This is an imperfect mechanism used to determine if we need to export the remote function again. It is imperfect in the sense that the actor class definition could be exported multiple times by different workers. enable_tensor_transport: Whether to enable out-of-band tensor transport for this actor. scheduling_strategyenable_tensor_transportc`||_||_||_||_|j|_|t jk|_||_||_ ||_ ||_ | |_ | |_ | |_| |_| |_||_||_||_||_||_d|_||_dSrC)languagerr method_metarrrPYTHONis_cross_languageclass_id max_restartsrnum_cpusnum_gpusmemoryobject_store_memory resourceslabel_selectorfallback_strategyaccelerator_type runtime_envconcurrency_groupsrlast_export_cluster_and_jobr)rFrrrrrrrrrrrrrrrrrrrs rGr z_ActorClassMetadata.__init__Vs,! ,2T/&<G!)X_!<  ( 0     #6 ",!2 0&"4#6 +/('>$$$rJN)rMrNrOrr-rr rDrJrGrr-sG&&P+?&1'+?("&)+?+?+?+?+?+?rJrceZdZdS)ActorClassInheritanceExceptionN)rMrNrOrDrJrGrrsDrJrci}ttjtjd}t jD]'\}}||vr|||j ||<(t|d|d<|r|ddurtdd|d<|dd}|r1|ddi|d<d|dd <d|dd <|S) NrrrFzActor class has methods with @ray.method(tensor_transport=...) decorator but @ray.remote(enable_tensor_transport=False). Either set enable_tensor_transport=True or remove the @ray.method(tensor_transport=...) decorator from the methods.Trr _ray_system_ray_system_error) setrgetfullargspecrr r actor_optionsitemsr6 default_valuer"ra)rr_filled_options arg_nameskvrs rG_process_option_dictrs9OG*+>+GHHKLLI .4466GG1 >>!.!2!21ao!F!FOA %H &&&OM" $: 4 5 > >F 6:12.112KUSSG   3T : : B46O0 1?@,-m$$$   1  urJcVtd|jjd|jjd)aIPrevents users from directly instantiating an ActorClass. This will be called instead of __init__ when 'ActorClass()' is executed because an is an object rather than a metaobject. To properly instantiated a remote actor, use 'ActorClass.remote()'. Raises: Exception: Always. z4Actors cannot be instantiated directly. Instead of 'z ()', use 'r )r!rrrr"s rGr#zActorClass.__call__sL B0; B B)4 B B B   rJc.dD]8}t|r&tdjd|d9Gfdd}djd}j|_||_||_||}tjj }t |} ttj||| fit|| j|_||_d |jvr|jj|jd <|S) N)rHr)_ray_from_modified_class_ray_from_function_descriptorzCreating an actor from class z overwrites attribute z of that classceZdZfdZdS)>ActorClass._ray_from_modified_class..DerivedActorClassc j|g|Ri|dS#t$rI}t|tr't|tsj|g|Ri|n|Yd}~dSd}~wwxYwrC)r  Exceptionrdr!r)rFrrrOrwrs rGr zGActorClass._ray_from_modified_class..DerivedActorClass.__init__s   CL777777777    "!Y// 999 0/FtFFFvFFFFGFFFFF  s A)>A$$A)N)rMrNrOr )rwrsrGDerivedActorClassrs3 rJrz ActorClass()r)rloggerwarningrMrNrOrr% from_class__ray_actor_class__rorrrrrrr_default_optionsr) rwrrr attributerrrFractor_method_metas `` rGrz#ActorClass._ray_from_modified_classs  I ~y11 ;%.;;!*;;;        ^   8^4777'5'@$%)")-& (():;;-E-P  .. . *6<<  .  !4 O  .   ! ! #0M ! ! !. D1 1 1373H3TD !- 0 rJctt}d}t||}t |||d|fit ||j|_||_d|jvr|jj |jd<|S)Nr) rrrorrrrrrr)rwrrrrFrrs rGrz(ActorClass._ray_from_function_descriptor0s!!*--5<<  .  !4   .   ! ! #0M ! ! !. D1 1 1373H3TD !- 0 rJr@c,|jd||d|jS)a3Create an actor. Args: args: These arguments are forwarded directly to the actor constructor. kwargs: These arguments are forwarded directly to the actor constructor. Returns: A handle to the newly created actor. r/rD)r)rr"s rGrHzActorClass.remoteLs&t|NfNN8MNNNrJ ActorClass[T]c *||j}|ddtj||tjdd|vrt dd<Gfdd}|S)aConfigures and overrides the actor instantiation parameters. The arguments are the same as those that can be passed to :obj:`ray.remote`. Args: num_cpus: The quantity of CPU cores to reserve for this task or for the lifetime of the actor. num_gpus: The quantity of GPUs to reserve for this task or for the lifetime of the actor. resources (Dict[str, float]): The quantity of various custom resources to reserve for this task or for the lifetime of the actor. This is a dictionary mapping strings (resource names) to floats. label_selector (Dict[str, str]): If specified, requires that the actor run on a node which meets the specified label conditions (equals, in, not in, etc.). fallback_strategy (List[Dict[str, Any]]): If specified, expresses soft constraints through a list of decorator options to fall back on when scheduling on a node. accelerator_type: If specified, requires that the task or actor run on a node with the specified type of accelerator. See :ref:`accelerator types `. memory: The heap memory request in bytes for this task/actor, rounded down to the nearest integer. object_store_memory: The object store memory request for actors only. max_restarts: This specifies the maximum number of times that the actor should be restarted when it dies unexpectedly. The minimum valid value is 0 (default), which indicates that the actor doesn't need to be restarted. A value of -1 indicates that an actor should be restarted indefinitely. max_task_retries: How many times to retry an actor task if the task fails due to a runtime error, e.g., the actor has died. The default value is 0. If set to -1, the system will retry the failed task until the task succeeds, or the actor has reached its max_restarts limit. If set to `n > 0`, the system will retry the failed task up to n times, after which the task will throw a `RayActorError` exception upon :obj:`ray.get`. Note that Python exceptions may trigger retries *only if* `retry_exceptions` is set for the method, in that case when `max_task_retries` runs out the task will rethrow the exception from the task. You can override this number with the method's `max_task_retries` option in `@ray.method` decorator or in `.option()`. max_pending_calls: Set the max number of pending calls allowed on the actor handle. When this value is exceeded, PendingCallsLimitExceeded will be raised for further tasks. Note that this limit is counted per handle. -1 means that the number of pending calls is unlimited. max_concurrency: The max number of concurrent calls to allow for this actor. This only works with direct actor calls. The max concurrency defaults to 1 for threaded execution, and 1000 for asyncio execution. Note that the execution order is not guaranteed when max_concurrency > 1. allow_out_of_order_execution: Only for *actors*. Whether Ray executes actor tasks out of order. If you're using multi-threaded (``max_concurrency > 1``) or async actors, you can't set this to False. Defaults to True if you're using multi-threaded or async actors, and False otherwise. Actor task retries are always executed out of order. name: The globally unique name for the actor, which can be used to retrieve the actor via ray.get_actor(name) as long as the actor is still alive. namespace: Override the namespace to use for the actor. By default, actors are created in an anonymous namespace. The actor can be retrieved via ray.get_actor(name=name, namespace=namespace). lifetime: Either `None`, which defaults to the actor will fate share with its creator and will be deleted once its refcount drops to zero, or "detached", which means the actor will live as a global object independent of the creator. runtime_env (Dict[str, Any]): Specifies the runtime environment for this actor or task and its children. See :ref:`runtime-environments` for detailed documentation. scheduling_strategy: Strategy about how to schedule a remote function or actor. Possible values are None: ray will figure out the scheduling strategy to use, it will either be the PlacementGroupSchedulingStrategy using parent's placement group if parent has one and has placement_group_capture_child_tasks set to true, or "DEFAULT"; "DEFAULT": default hybrid scheduling; "SPREAD": best effort spread scheduling; `PlacementGroupSchedulingStrategy`: placement group based scheduling; `NodeAffinitySchedulingStrategy`: node id based affinity scheduling. enable_task_events: True if tracing is enabled, i.e., task events from the actor should be reported. Defaults to True. Examples: .. code-block:: python @ray.remote(num_cpus=2, resources={"CustomResource": 1}) class Foo: def method(self): return 1 # Class Bar will require 1 cpu instead of 2. # It will also require no custom resources. Bar = Foo.options(num_cpus=1, resources=None) rNT) in_optionsrc8eZdZfdZefdZdS).ActorClass.options..ActorOptionWrapperc$jd||dSr.r()rFrr actor_clsupdated_optionss rGrHz5ActorClass.options..ActorOptionWrapper.remotes#(y(Ud6UU_UUUrJc@ddlm}|jj||S)z For Ray DAG building that creates static graph from decorated class or functions. r ClassNode)rErrr)rFrrrrrs rGrLz3ActorClass.options..ActorOptionWrapper.binds= 988888 y.=# rJNr4)rrsrGActorOptionWrapperrsc V V V V V V     \   rJr)rrIrJrupdate_optionsvalidate_actor_optionsr")rFrdefault_optionsrrrs @@rGr2zActorClass.optionsZsH /4466 0$777*9 ]   /DQQQQ M ) )-P ...OM *           &"!###rJNc :|d}|d}|Jt|ts tdt |d|dkrt d|$t jj ||drx t j || S#t $rT| }d |d< |j ||fi|cYS#t$rYnwxYwt j || cYSwxYw|d d|g}|i}|j}t!|j}|d |rt$n t&j|d <t+rt-|||fi|St.jD]#\} } || | j|| <$|d d|d } |d } |d} |d}|d}|d}|d}|d}|d}|d}|d}|t|t6st9|dt jjj}||j t jjj!krddl"m#}|$d|C t j || td|d|d|d|d #t $rYnwxYw| d}n!| d krd!}n| d"krd }nt d#|j t j%kr|j&r Jd$|j&s^|j'|j(krN|j)*|j|j+|j,j-.|j(|_'t j/j0|}tc|.2d%d&hs-|3d't&j4t&j5}n,|3d't&j6t&j7}i}|d(vsJ|d)kr$| }|d'xxd)z cc<|j&rtqj9|||}n(|j,j:d*}twj<|||}|duot|t6}|dkp|d+k}|r|r|rtz>d,|t|t6rht|t6r|j?}|j@}|jA}||jB}t|||||jD|-}|jEst7|||}nd.}d} | t| d d!/} i}!|jGg|_G|jGD]}"|"|jG|"gd0|!|"<|j,jHD]b}#|j,jH|#}"|"|!vsJ|j+jI}$|j+jD}%|!|"d1Jt|$|#|%c|j&rsd2}&|jLtjNkr |j+jO}&tqjP|jL|j+|&tt|t|z|_+|d3}'|'|p| d)k}'|r|'st d4| d)kr|'st d5|jRS|jL|j+|||||| |||nd||nd|t|| pd6|!p t||||d7|d8|d9|'|jU:}(trt|j+||t|jL|(|||j,jX|j,jY|j,j:|j,jZ|j,j[|j,j\|j,j]|j,j^|jU|j,j_||j+|j(d!|';})|)S)allow_out_of_order_executionzIf you're using async actors, Ray can't execute actor tasks in order. Set `allow_out_of_order_execution=True` to allow out-of-order execution.zIf you're using multi-threaded actors, Ray can't execute actor tasks in order. Set `allow_out_of_order_execution=True` to allow out-of-order execution.z{}_labelsrr) extension_dataserialized_runtime_env_infoconcurrency_groups_dictrrrlabelsrrrr)original_handler)`r6rdrr!rqrarXrYutilsvalidate_namespace get_actorrIr)r'rJrrrrr DEFAULT_MAX_CONCURRENCY_THREADEDrrrrrrr,rrZr[check_connectedmode WORKER_MODEray._common.usagerrecord_library_usage LOCAL_MODErrcurrent_cluster_and_jobfunction_actor_managerexport_actor_classrrrkeys_commonresources_from_ray_optionsr difference setdefault!DEFAULT_ACTOR_CREATION_CPU_SIMPLEDEFAULT_ACTOR_METHOD_CPU_SIMPLE$DEFAULT_ACTOR_CREATION_CPU_SPECIFIED"DEFAULT_ACTOR_METHOD_CPU_SPECIFIEDr _format_argsrr flatten_argsrrrrr-should_capture_child_tasks_in_placement_groupr+rris_emptyr!rr module_namerNr%rrCPP function_name)_get_function_descriptor_for_actor_methodr core_worker create_actorrMr_actor_launch_hookr rrrrrrrr)*rFrrrrrrmeta is_asynciorrrrrrrrrrrrrrZrrractor_method_cpuactor_placement_resources creation_argsfunction_signatureuse_placement_groupis_restartablerrcg_namerrrr func_nameractor_idr s* rGr)zActorClass._remotes $  ((!%%k22  dC(( J VT V V VWWW !HIII  L  1 1) < < <   _ - - @ @}TY???? @ @ @"/"4"4"6"6380'4<fHHHHHHH.D}TY?????? @ .555 <D >F$&t':;;   . / / 7D--"C + , & ' ' R,T4QQ=QQ Q%288:: E EDAq,00AODDM!   .555((9: ,#M2 '(9:'45S'T$.; 1/ +,,AB$^4 ();<)*=>+../CDD  &j !A/ / & 6mQ G G G$2   ;#,-9 9 9 3 3 3 3 3 3  * *6 2 2 2    di8888.HHH)HH'+HH;DHHH      HH  # #HH  ' 'HH-  ;#. ( (* G GF G G*% N  ,0N N N  ) < <#7 (--//    06/MD ,K%@@OO 9>>##$$//;P0QRR P   (W X X X,L    }I    -O  %'!6)))) q (1(8(8 % %e , , , 1 , , ,  ! U*7fMMMM!%!1!#(+++ ' #%  " *&(D #.  G#'#:7#C(*00 #G , , +I  K&D[QG55555AMK@KJ #G ,-C D K K(k:NN      !  I} ,, CQ HM;D CKK/00   3(5'8'89W'X'X$ ( /+5+L19L (  :   q )E *  %22 M  3     %  $DD"".IIB /00(C(Kt$;$Etvv/ 31 $$Y//(,,-=>>+//0CDD)E$($@13  6   7DW   # M      0   '   '   (   -   -   ?   /  (   <   3  * )E'   ,sH3C #D'-C>;D'> D D' D  D'&D'8L** L76L7cHddlm}||jj|||jS)zk For Ray DAG building that creates static graph from decorated class or functions. rr)rErrrr)rFrrrs rGrLzActorClass.bindPs< 100000y  ! 0$@U   rJ)r@r)NN)rMrNrOrr r#rrr ActorProxyr1rHr2rr/r)r)rLrDrJrGrrs   B   BB[BH[6 OA O O O OI$I$I$I$Vgg*Q-ggg^gR    \    rJrcPeZdZdZ d+deededeeefdeee ee dffd eeefd eee ee e ffd eeefd eeefd edeeefdededeefdZ dZ d,dedeedeeefdedee ee dfdede ee e fdeedeedeedeefdZded efd!Zd"Zd#Zd$Zd%Zed&Zd'Zd(Zed-defd)Zd*ZdS).r a A handle to an actor. The fields in this class are prefixed with _ray_ to hide them from the user and to avoid collision with actor method names. An ActorHandle can be created in three ways. First, by calling .remote() on an ActorClass. Second, by passing an actor handle into a task (forking the ActorHandle). Third, by directly serializing the ActorHandle (e.g., with cloudpickle). Attributes: _ray_actor_language: The actor language. _ray_actor_id: Actor ID. _ray_enable_task_events: The default value of whether task events is enabled, i.e., task events from the actor should be reported. _ray_method_is_generator: Map of method name -> if it is a generator method. _ray_method_decorators: Optional decorators for the function invocation. This can be used to change the behavior on the invocation side, whereas a regular decorator can be used to change the behavior on the execution side. _ray_method_signatures: The signatures of the actor methods. _ray_method_max_task_retries: Max number of retries on method failure. _ray_method_num_returns: The default number of return values for each method. _ray_method_retry_exceptions: The default value of boolean of whether you want to retry all user-raised exceptions, or a list of allowlist exceptions to retry. _ray_method_generator_backpressure_num_objects: Generator-only config. The max number of objects to generate before it starts pausing a generator. _ray_method_enable_task_events: The value of whether task tracing is enabled for the actor methods. This overrides the actor's default value (`_ray_enable_task_events`). _ray_method_name_to_tensor_transport: A dictionary mapping method names to their tensor transport protocol settings. The valid values are OBJECT_STORE (default), NCCL, or GLOO, and they are case-insensitive. _ray_actor_method_cpus: The number of CPUs required by actor methods. _ray_original_handle: True if this is the original actor handle for a given actor. If this is true, then the actor will be destroyed when this handle goes out of scope. _ray_weak_ref: True means that this handle does not count towards the distributed ref count for the actor, i.e. the actor may be GCed while this handle is still in scope. This is set to True if the handle was created by getting an actor by name or by getting the self handle. It is set to False if this is the original handle or if it was created by passing the original handle through task args and returns. _ray_is_cross_language: Whether this actor is cross language. _ray_actor_creation_function_descriptor: The function descriptor of the actor creation task. _ray_allow_out_of_order_execution: Whether the actor can execute tasks out of order. _ray_enable_tensor_transport: Whether tensor transport is enabled for this actor. FNrrrmethod_num_returnsrmethod_max_task_retriesmethod_retry_exceptions)method_generator_backpressure_num_objectsmethod_enable_task_eventsrractor_method_cpusweak_refrcV||_||_||_||_||_||_||_||_||_||_ ||_ | |_ | |_ | |_ | |_| |_||_||_||_|t&jk|_||_i|_d|_|js\t3|t4sJ|j}|j}|j D]}t5|||}||j|<i|_|j D]\}}tA||j !|d|j !||jpd|j !||j!||j !||j!||j|j!|||j!| |j|<dS)aInitialize an ActorHandle. Args: language: The actor language. actor_id: The ID of the actor. max_task_retries: The maximum number of times to retry a task when it fails. enable_task_events: Whether task events should be enabled for this actor. method_is_generator: Dictionary mapping method names to whether they are generator methods. method_decorators: Dictionary mapping method names to their decorators. method_signatures: Dictionary mapping method names to their signatures. method_num_returns: Dictionary mapping method names to their number of return values. method_max_task_retries: Dictionary mapping method names to their maximum task retries. method_retry_exceptions: Dictionary mapping method names to their retry exception settings. method_generator_backpressure_num_objects: Dictionary mapping method names to their generator backpressure settings. method_enable_task_events: Dictionary mapping method names to whether task events are enabled. enable_tensor_transport: Whether tensor transport is enabled for this actor. If True, then methods can be called with .options(tensor_transport=...) to specify a non-default tensor transport. method_name_to_tensor_transport: Dictionary mapping method names to their tensor transport type. actor_method_cpus: The number of CPUs required by actor methods. actor_creation_function_descriptor: The function descriptor for actor creation. cluster_and_job: The cluster and job information. original_handle: Whether this is the original actor handle. weak_ref: Whether this is a weak reference to the actor. allow_out_of_order_execution: Whether the actor can execute tasks out of order. rN) rrrrrrrrrr)"_ray_actor_language _ray_actor_id_ray_max_task_retries_ray_original_handle _ray_weak_ref_ray_enable_task_events!_ray_allow_out_of_order_execution_ray_method_is_generator_ray_method_decorators_ray_method_signatures_ray_method_num_returns_ray_method_max_task_retries_ray_method_retry_exceptions._ray_method_generator_backpressure_num_objects_ray_method_enable_task_eventsrb$_ray_method_name_to_tensor_transport_ray_actor_method_cpus_ray_cluster_and_jobrr_ray_is_cross_language'_ray_actor_creation_function_descriptor_ray_function_descriptorrGrdr%rrrr _method_shellsrrr6)rFrr*rrrmethod_decoratorsmethod_signaturesr.r/r0r1r2rrr3rcluster_and_jobrr4rrrrrfunction_descriptormethod_signatures rGr zActorHandle.__init__sd$, %%5"$3!%'9$1M.(;%&7#&7#'9$,C),C) 5 ;/H+,C)4S1&7#$3!&.(/&A# . 4)+% $% * Q24L  =HK;FJ#:??AA Q Q &>j''#>Q-k:: !-1-H-N-N-P-P   )K)/C' 8<<[$OO!%!B!F!F!;"""!%!B!F!F{!S!S!:>>{KK373f3j3j44$(#F#J#J!=$$599+FF*!%!J!N!N""#000D  , ,  rJc|jrdS tjjrNtjjj}|jr3t |dr%|j|j dSdSdSdS#t$rYdSwxYw)Nr) r:rXrYrZr[ connectedrrremove_actor_handle_referencer7AttributeErrorrFrZs rG__del__zActorHandle.__del__s    F |" Y,:#Y (F(FY&DDTEWXXXXX Y YYYYY    DD  sAA00 A>=A>r7rrrrrrrWrrc ptjjj} |pg}|pi}|jrct j| ||} t j|j|j |tt|t|z}n9|j |}|s|s|sg} ntj|||} |j|}| jtjkr|jr Jd|dkrd}n|dkrtjj}d}|d}n-t)|t*t,frt-|}d}t)|t.s Jd | d} t0j}| !| t0jjkr t0j}| j|j|j|| ||||||j||nd | | |j }|t&kr-t|d ksJ|d }tC|| St|d kr |d }nt|d krd}|S) awMethod execution stub for an actor handle. This is the function that executes when `actor.method_name.remote(*args, **kwargs)` is called. Instead of executing locally, the method is packaged as a task and scheduled to the remote actor instance. Args: method_name: The name of the actor method to execute. args: A list of arguments for the actor method. kwargs: A dictionary of keyword arguments for the actor method. name: The name to give the actor method call task. num_returns: The number of return values for the method. max_task_retries: Number of retries when method fails. retry_exceptions: Boolean of whether you want to retry all user-raised exceptions, or a list of allowlist exceptions to retry. concurrency_group_name: The name of the concurrency group to use. generator_backpressure_num_objects: The number of objects to generate before applying backpressure. enable_task_events: True if tracing is enabled, i.e., task events from the actor should be reported. tensor_transport: The tensor transport protocol to use for the actor method. Returns: object_refs: A list of object refs returned by the remote actor method. )rz>Cross language remote actor method cannot be executed locally.dynamicr?rNFTzTretry_exceptions can either be boolean or list/tuple of exception types.rJrr)"rXrYrZr[rHrrrr6rIrrr?rrrJrr_rayletr#rdrrrrrrDIRECT_TRANSPORTrsubmit_actor_taskr7rFvaluer$)rFrrrrrrrrWrrrrZ list_argsrOr%retry_exception_allowlisttensor_transport_enumrf generator_refs rGr^zActorHandle._actor_method_call"sR$2zr2  & M&3FD&III"0"Z(<c$ii#f++566 ###  "&!<[!I  U U/A U %23EtVTT "&"? "L  ;#. ( (/ P PO P P/ ) # #KK K ' '+@K$(!  #$   (4- 8 8 $(-.>(?(? %#  d   7 7 7 7 7 . 513 . 3 @  ( $7$D$III$7$H !(::  $         %  '&<&H " "c .  ! '  " 4 4 4{##q(((('NM%mV<< < {  q %a.KK    " "KrJitemr@c ||jvr |j|S|js(tdt |jdddvrGfddt }|St|tj ddd|j d|j d d S) aHandle dynamic attribute access for actor methods. This method is called when accessing attributes that don't exist as direct instance attributes. It's the core mechanism for actor method invocation. For Python actors (99% of cases): - We use strict validation: only methods in _method_shells are allowed - This prevents typos and provides clear error messages - Returns a bound ActorMethod created from the cached _ActorMethodMetadata For cross-language actors: - We can't validate method names client-side (the target language defines them) - We allow arbitrary method calls to pass through - Some Python-specific methods like `__ray_terminate__` are blocked with warnings Args: item: The attribute/method name being accessed Returns: ActorMethod: A bound method ready for .remote() calls Raises: AttributeError: For Python actors when accessing non-existent methods 'z' object has no attribute ')__ray_terminate__c$eZdZfdZfdZdS)0ActorHandle.__getattr__..FakeActorMethodcJtd)NzdActor methods cannot be called directly. Instead of running 'object.{}()', try 'object.{}.remote()'.)r!formatrFrrras rGr#z9ActorHandle.__getattr__..FakeActorMethod.__call__s1#NNTf $OOrJcDtdddS)Nz Actor method z$ is not supported by cross language.)rrris rGrHz7ActorHandle.__getattr__..FakeActorMethod.remotes1NNRRRRrJN)rMrNrOr#rH)rasrGFakeActorMethodrfsGrJrkrFr?N)rr) rKrLrHrTrqrMobjectrrrrCr6r;)rFrarks ` rG __getattr__zActorHandle.__getattr__s 4 4& & &&t,11$77 7*  ODJJ'OOOOO  ( ( (       &   #?$$ $    >    ? C CD" M M  (    rJc4|jSrC)r?r rEs rG__dir__zActorHandle.__dir__s*//111rJcVd|jjd|jdS)NzActor(z, r)rIrr _actor_idhexrEs rG__repr__zActorHandle.__repr__s? ';F ' '~!!## ' ' ' rJc*t|jSrC)hashrqrEs rG__hash__zActorHandle.__hash__sDN###rJcBt|t|kSrC)ru)rF_ActorHandle__values rG__eq__zActorHandle.__eq__sDzzT']]**rJc|jSrC)r7rEs rGrqzActorHandle._actor_ids !!rJctjjj}||j|jS)a@Get the local actor state. NOTE: this method only returns accurate actor state after a first actor method call is made against this actor handle due to https://github.com/ray-project/ray/pull/24600. Returns: ActorTableData.ActorState or None if the state is unknown. )rXrYrZr[rrget_local_actor_stater7rUs rG_get_local_statezActorHandle._get_local_states=$2   !778JKKKrJctjjj}|t |dr |j|j}nid|j d|jd|j d|j d|j d|j d|jd |jd |jd |jd |jd |jd|jd|jd|jd|jdf}g||jRS)zThis is defined in order to make pickling work. Returns: A dictionary of the information needed to reconstruct the object. ractor_languager*rrrrLrMr.r/r0r1r2rrr3rN)rXrYrZr[rrrserialize_actor_handler7r6r8rr=r>r?r@rArBrCrDrbrErFrIr:)rFrZrks rG_serialization_helperz!ActorHandle._serialization_helper sg $2   6= ) ) &==d>PQQEE$d&> 2'(B)$*B  *4+H  ()D ()D)$*F.t/P.t/P@K01T.t/P 6t7`!"()D#$9$:f%(+E0,+*+++rJctjjj}|t |dr|j|||S|j|dksJ||d|d|d|d|d|d|d |d |d |d |d |d|d|d|d|d|dS)aThis is defined in order to make pickling work. Args: state: The serialized state of the actor handle. outer_object_ref: The ObjectRef that the serialized actor handle was contained in, if any. This is used for counting references to the actor handle. weak_ref: Whether this was serialized from an actor handle with a weak ref to the actor. rr rr*rrrrLrMr.r/r0r1r2rrr3r) rXrYrZr[rrr%deserialize_and_register_actor_handler )rwrkr4outer_object_refrZs rG_deserialization_helperz#ActorHandle._deserialization_helper, s#$2   6= ) ) %KK  1U;T5UUUUU3&'j!()*++,)*)**+/0/0AB12/078)*:;/0' rJcT|\}}}tj||dffS)z:This code path is used by pickling but not by Ray forking.N)rr r)rF serializedr}r4s rG __reduce__zActorHandle.__reduce__\ s1$($>$>$@$@!Q2Z44PPPrJ)FFNrmrC)rMrNrOrr rrrrr r rrr rVrrr^rmrorsrvrypropertyrqr}rrrrrDrJrGr r ]s44R7;+xx#3- x ! x "#t)_ x!eC1E,E&F!FGx"&c3hx"&c5tU1B+C&C!Dx48S>x$(T ?x"&x*.c3hx !x()x*'/tn+xxxxt,!%BF $5904<@-1*.|||3i|S#X |  | eC)=$=>? || dE 12|!) |-5SM|%TN|#3-|||||? ? ? ? ? ? D222   $$$+++""X" L L L&,&,&,P--d---[-^QQQQQrJr ctdrSttstdGfdd}j|_j|_t t|dds d}||_|S)NrzThe @ray.remote decorator cannot be applied to old-style classes. In Python 2, you must declare the class with 'class ClassName(object):' instead of 'class ClassName:'.c&eZdZZdZdZdZdS)_modify_class..ClasscdS)NTrDrEs rG __ray_ready__z*_modify_class..Class.__ray_ready__u s4rJc||g|Ri|SrCrD)rFfnrrs rG __ray_call__z)_modify_class..Class.__ray_call__x s"2d,T,,,V,, ,rJctjjj}|jtjkr tjdSdSrC)rXrYrZr[rrr exit_actorrUs rGrdz._modify_class..Class.__ray_terminate__{ s@\(6F{cn,, $$&&&&&-,rJN)rMrNrOrrrrdrvsrGClassrr sH!    - - - ' ' ' ' 'rJrr cdSrCrDrEs rGr z_modify_class..__init__ s DrJ) r issubclassrlr!rNrMrr{r )rwrr s` rG _modify_classrd ss)**  c6 " "  H    ' ' ' ' ' ' ' ' ' '~E\EN  D!A!A B B"    " LrJct|}t|d|vr/|ddkr#t|dtj|d<t |tj|S)Nrr?) rr.minrMAX_INT64_VALUErrr from_random)rwrrs rG _make_actorr s #  Eu%%%&&  (B . .-0n-}/L--M. )  . .  ""  rJc\tjjj}|jtjkrj|jsQ|j |j rttddStd|jd)aTIntentionally exit the current actor. This API can be used only inside an actor. Use ray.kill API if you'd like to kill an actor using actor handle. When this API is called, an exception is raised and the actor will exit immediately. For asyncio actors, there may be a short delay before the actor exits if the API is called from a background task. Any queued methods will fail. Any ``atexit`` handlers installed in the actor will be run. Raises: TypeError: An exception is raised if this is a driver or this worker is not an actor. zexit_actor() is called.z0exit_actor API is called on a non-actor worker, zR. Call this API inside an actor methodsif you'd like to exit the actor gracefully.N)rXrYrZr[rrr*is_nilrset_current_actor_should_exitcurrent_actor_is_asyncior(r&r!)rZs rGrr s$\ .F {co%%fo.D.D.F.F%88:::   6 6 8 8 %"$$ $ 11JKKKKK :{ : : :   rJ)zrloggingtypingrrrrrrr r r r r rrr ImportErrortyping_extensionsray._common.signaturer rray._private.ray_constantsrYr ray._rayletrXrrrr ray._commonrray._common.ray_constantsrray._common.ray_option_utilsrray._private.async_compatrray._private.auto_init_hookrray._private.client_mode_hookrrrray._private.custom_typesrray._private.inspect_utilrrr ray._private.utilsr!r"r#r$r%r&ray.exceptionsr'r(ray.util.annotationsr)r*ray.util.placement_groupr+ray.util.scheduling_strategiesr,r-ray.util.tracing.tracing_helperr.r/r0 getLoggerrMrrr1rqr,r2r3r4r5r6r7r8r9r:r;r<r=r?rQrXrarjrtrrrrrrrrrrrrrrlrorr!rrrr rrrrDrJrGrsx                             9---------99988888888889*))))))))222222222AAAAAAAAAAAA((((((CCCCCCRRRRRR777777666666  YXXXXXXX EDDDDDDD88888888PPPPPP    8 $ $ GCLL#T!W, - wvYt__ genn genn genn genn genn genn genn genn genn genn     '$-        WT3Y'        WT3^,         WT3S01          WT3S#56         WT3S#s:;   "     WT3S#sC?@   0     WT3S#sCDE   4     WT3S#sCcIJ   8     WT3S#sCc3NO   <     WT3S#sCc3PSST   @ Sz4'(D#I   S#,-D#sN#   S#s+T12D#sC'(   S#sC0$67D#sC,-   S#sC5t;<D#sCc12   S#sCc:D@AD#sCc367   S#sCc3?EFD#sCc3;<   S#sCc3DdJKD#sCc3S@A   S#sCc3SI4OPD#sCc3S#EF   S#sCc3S#NPTTUD#sCc3S#sJK   ud{#   ?C'+&*;?9=)-6:   %W[%9 9:;  } sm  uT4%678  *2# ! 23 x CG,d234c9:      mm m`J J J J J J J J ^ S S S S S S S  S l HHHHHHHHVT?T?T?T?T?T?T?T?n      Y    $$$N i  i  i  i  i  i  i   i  X CQCQCQCQCQ'!*CQCQ CQL)))X& " "  " " " s / ??