BVh[DdZddlZddlZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZd ZGd deZGddeZGddeZy)z2Generic source code transformation infrastructure.N)cache) inspect_utils)loader)naming) origin_info)parser) templates) transformer) ag_loggingc g}|D]*}d} |jtj| |,|r> return entity return inner_factory The lexical scoping is created using dummy symbol declarations which create local variables in the body of the outer factory, so that the Python parser correctly marks them as free non-global variables upon load (that is, it creates cell slots for each symbol. These symbols are initialized with None, but their values are not expected to be used; instead, the caller is expected to replace them with the cells of the source entity. For more details, see: https://docs.python.org/3/reference/executionmodel.html#binding-of-names Args: nodes: Tuple[ast.AST], the source code to wrap. entity_name: Union[Text, ast.AST], the name of the principal entity that `nodes` define. inner_factory_name: Text, the name of the inner factory. outer_factory_name: Text, the name of the outer factory. closure_vars: Iterable[Text], names of the closure variables for the inner factory. factory_args: Iterable[Text], names of additional arguments for the inner factory. Useful to configure variables that the converted code can use. Typically, these are modules. future_features: Iterable[Text], names of future statements to associate the code with. Returns: ast.AST z var_name = None )var_name __future__N)nameasnamer)modulenameslevelctx annotation type_commentz future_imports def outer_factory_name(): dummy_closure_defs def inner_factory_name(factory_args): entity_defs return entity_name return inner_factory_name )dummy_closure_defs entity_defs entity_name factory_argsfuture_importsinner_factory_nameouter_factory_name)extendr replacegast ImportFromaliasNameParam) nodesrrr closure_varsrfuture_featuresrr templaterrs [/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/autograph/pyct/transpiler.py_wrap_into_factoryr+"sJNhHi//8LM N __>MNdtzztD1NN N  ii$**,4dK, (   +#++ --'O s C 62Cc0eZdZdZdZ ddZ ddZy)_PythonFnFactoryz3Helper object that wraps a Python function factory.cX||_||_||_d|_d|_d|_y)a4Creates a new factory for a Python function. Args: name: The function name. freevars: The list of non-global free variables for the function. extra_locals: Dict[Text, Any], names and values for custom variables that are accessible to the generated code as local variables. N)_name _freevars _extra_locals_unbound_factoryr source_map)selfrfreevars extra_localss r*__init__z_PythonFnFactory.__init__s0DJDN%D DDKDOc v|j td|j|d}|j|d}t||j|||j |j j|}tj|d\}}}t||} | |_||_ ||_ y)zInitializes a function.Nz2double initialization; create a new object insteadT)include_source_map) r2 ValueError new_symbolr+r/r0r1keysrload_astgetattrrr3) r4r&namerrrr(r_r3 outer_factorys r*createz_PythonFnFactory.creates ( K LL))*>#11668/ KE#OO $(FAzF$67M)ODDK DOr8Nc |j td|jj}|j}t t |j | t fd|jD}t|t|k7r%tdj|j |tj|||jd|}|di|j} |r|| _|r|| _| S)z Creates a new function instance.zcall create firstc3(K|] }| ywNr:).0r closure_maps r* z/_PythonFnFactory.instantiate..s@" D@sz:closure mismatch, requested {}, but source function had {}r:)codeglobalsrargdefsclosure)r2r<__code__ co_freevarsdictzipr0tuplelenformattypes FunctionTyper/r1 __defaults____kwdefaults__) r4globals_rNdefaults kwdefaults factory_codefactory_freevarsfactory_closure bound_factorynew_fnrIs @r* instantiatez_PythonFnFactory.instantiates  $ * ++((11L#//s4>>734K@&2&>&>@@O ?s7|+  F M Mnn. 0 11&&  ZZ !M 0T// 0F$f(f Mr8) inner_factoryrCr:)NN)__name__ __module__ __qualname____doc__r7rDrbr:r8r*r-r-s';(!0 / !4 ! "r8r-c4eZdZdZdZdZdZdZdZdZ y) GenericTranspileraA generic transpiler for Python functions. Its interface is the `transform` API, which can process Python function objects. Internally, it handles parsing. Users typically subclass this, customizing the `transform_ast` method. The output of transformed_ast is returned directly by `transform`. Existing methods like `transform_function` may also be overloaded. Example: class MyTransformer(GenericTranspiler): def transform_ast(self, node, ctx): result = <> return result transformer = MyTransformer() result = transformer.transform(f, ...) # result is the output ct|tjryt|tjr |jSt dj |)zEReturns a name for the output function. Subclasses may override this.lamzUnknown node type {}) isinstancer!Lambda FunctionDefrr<rU)r4nodes r*get_transformed_namez&GenericTranspiler.get_transformed_namesD$ $  D$** + YY +2248 99r8ctd)zPerforms an actual transformation of a function's AST. Subclasses must implement this method, and do not usually call it. Args: node: One or more ast.AST nodes representing the AST to be transformed. ctx: transformer.Context. subclasses must override thisNotImplementedError)r4rors r* transform_astzGenericTranspiler.transform_ast = >>r8ctj|stj|r|j||St dj t |)aTransforms a Python object. Users typically call this method. Args: obj: A Python object, function, type, etc. user_context: An opaque object (may be None) that is forwarded to transform_ast, through the ctx.user attribute. Returns: The result of calling transform_function. Raises: NotImplementedError: if the type of obj is not handled. zNon-function: {})inspect isfunctionismethodtransform_functionrtrUtype)r4obj user_contexts r* transformzGenericTranspiler.transform sM#'"2"23"7  $ $S, 77 077S B CCr8c,|j}tt|jD]$}t j d|j|<&t |jD]*\}}| t j d|j|<,|S)z@Erase arg default expressions, which would otherwise be unbound.None)argsrangerTr[rparse_expression enumerate kw_defaults)r4rorids r*_erase_arg_defaultsz%GenericTranspiler._erase_arg_defaultss 99D 3t}}% &9008dmmA9$**+>1 $55f=> Kr8cg}|jjD]:}tj|r |j |j ||<|S#t $rYJwxYw)asTransforms a module. Subclasses may override this method. The return value is opaque. The method receives the original AST. The result is passed as-is to the output of `transform`. Args: mod: A Python module. user_context: An opaque object (may be None) that is forwarded to transform_ast, through the ctx.user attribute. Returns: List[Tuple[Any, Any]]. By default it returns the output of transform_ast, evaluated on each supported member, other than modules, together with a `transformer.Context` containing information about the transformation process. )__dict__valuesrxismoduleappendrrt)r4modr~resultmembers r*transform_modulez"GenericTranspiler.transform_module(sm$F,,%%'    & !  dnnV\:;   M!   s!A A('A(ctj|}tj||\}}t j dd||t j|||tj|}tj|}|j|j|d}tj||d||} tj| ||} |j!|}|j#|| } | | fS)a5Transforms a function. Subclasses may override this method. The return value is opaque. The method receives the original AST. The result is passed as-is to the output of `transform`. Args: fn: A function or lambda. user_context: An opaque object (may be None) that is forwarded to transform_ast, through the ctx.user attribute. Returns: Tuple[Any, Any]. By default it returns the output of transform_ast, together with a `transformer.Context` containing information about the transformation process. r(zSource code of %s: %s r:z )r source_code source_filer( namespace)rgetfutureimportsr parse_entitylogginglogrresolve_entity getnamespacerNamerr=rpr EntityInfoContextrru) r4fnr~r(rosourcerrAnew_name entity_infocontextrs r*r{z$GenericTranspiler.transform_functionDs"$44R8O&&r?KLD& KK/V<tVR0**2.I LL #E 9 9$ ?DH((  ' K !!+ulCG  # #D )D   g .F 7?r8N) rdrerfrgrprurrrr{r:r8r*riris&.: ?D(8%r8ric:eZdZdZdZdZdZdZfdZxZ S)PyToPyaA generic Python-to-Python transpiler. Its `transform` method offers a function-in, function-out interface. Internally, it takes care of parsing, caching and loading of the translated code. Users typically subclass this, overriding `transform_ast`. Usually, instances of this class are singletons, since each instance manages its own cache. The caching can be controlled by overriding `get_caching_key`. Example: class MyTransformer(PyToPy): def transform_ast(self, node, ctx): node = <> return node transformer = MyTransformer() new_f, module, source_map = transformer.transform_function(f, ...) # new_f is a function with signature identical to f The transformed function has access to the same namespace as the original function. To allow access to internal APIs, users may inject additional symbols by overriding `get_extra_locals`. chtj|_tj|_yrG) threadingRLock _cache_lockrCodeObjectCache_cacher4s r*r7zPyToPy.__init__s! (D'')DKr8ctd)zReturns extra static local variables to be made to transformed code. Subclasses must override this. Returns: extra_locals: A Dict[Text, Any] containing additional variables to make available to the transformed code. rrrsrs r*get_extra_localszPyToPy.get_extra_localsrvr8ctd)ayReturns a unique key to use for caching. Subclasses must override this. Calls made to `transform_function` with functions that have the same code object and caching key will return a cached instance on subsequent invocations. Args: user_context: The context object which was passed to `transform`. Returns: extra_locals: A hashable. rrrs)r4r~s r*get_caching_keyzPyToPy.get_caching_keys = >>r8c\|j||}tjdd||||S)NrzCache hit for %s subkey %s: %s)rrr)r4r cache_subkeycached_factorys r*_cached_factoryzPyToPy._cached_factorys2[[_\2N KK3R r8c |j|}|jj||r|j||}n|j5|jj||r|j||}nt j dd||tt|'||\}}t|tjrVtjtj|jj tj"ddg|}n|jj |_t j$dr+t j dd|t'j(|t+|jj |j,j.|j1}|j3||j4|jj6||j||<dddj9|j:|j<xsd |j>tA|d d }||jB|jDfS#1swYdxYw) a#Transforms a function. See GenericTranspiler.transform_function. This overload wraps the parent's `transform_function`, adding caching and facilities to instantiate the output as a Python object. It also adds facilities to make new symbols available to the generated Python code, visible as local variables - see `get_extra_locals`. Args: fn: A function or lambda. user_context: An opaque object (may be None) that is forwarded to transform_ast, through the ctx.user attribute. Returns: A tuple: * A function or lambda with the same signature and closure as `fn` * The temporary module into which the transformed function was loaded * The source map as a Dict[origin_info.LineLocation, origin_info.OriginInfo] z%s is not cached for subkey %sNr)targetsvaluezTransformed %s: %s rr:rY)rZrNr[r\)#rrhasrrrrsuperrr{rlr!rmAssignr$inforStore has_verbosityrunparser-rOrPrrDrAr(rb __globals__ __closure__rXr@rr3) r4rr~rfactoryr&rtransformed_fn __class__s r*r{zPyToPy.transform_functions('' 5L {{r<($$R6g   2 ;;??2| ,((\:' ++a92| LVT=b,O*% t{{ +KKII  JJL#'%) +EEJ  " "1 % KK4b&..:O P$hhmmR[[44d6K6K6MO' ..SYY0H0H  J*1$++b/, '=2@(($"2/6 )8N 7>>7+=+= ==K22s F2I$$I-) rdrerfrgr7rrrr{ __classcell__)rs@r*rrls(:* ??" @>@>r8r)rgrxrrVr! tensorflow.python.autograph.pyctrrrrrrr r !tensorflow.python.autograph.utilsr rr+objectr-rirr:r8r*rse9 2:338368Cj-ZMvM`JJZD> D>r8