BVh@dZddlZddlZddlZddlZddlZddlZddlZddlm Z ddlm Z ddl m Z ddl m Z ddl mZddl mZdd l mZdd l mZdd l mZdd l mZdd l mZddl mZddl mZddl mZddl mZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl"m#Z#ddl$m%Z%ddl$m&Z&ddl$m'Z'ddl$m(Z(ddl$m)Z)ddl$m*Z*ddl$m+Z+dd l$m,Z,dd!l-m.Z.dd"l-m/Z/dd#l0m1Z2dd$l3m4Z4dd%l5m6Z6dd&l7m8Z8dd'l7m9Z9dd(l7m:Z:dd)l;mZMet|}t|tjrrt j |j }|j}t|j}|dk(r||j|j||jS|tjtt t"tj$tj&fvr||jSt(t*|[|}||St#|jS)N)selfnode_defopmessage)type issubclassr%OpErrorr'getfullargspec__init__ get_messagetupleargsrDrEexperimental_payloadsr PyCTErrorr6r=r?InaccessibleTensorErrorOperatorNotAllowedInGraphErrorsuperrAcreate_exception)rC source_errorpreferred_type init_argspecrF init_argsexc __class__s r3rTz_ErrorMetadata.create_exception^s,'N.+"5"56 ..~/F/FGl  "g ))*i ; ;l33\__g*@@B B F,,no(+*M*M'FFH HD,,. //  6| DC  j ((* ++r2)r8r9r:r;rT __classcell__rZs@r3rArA[s:,,r2rAcbt|dryt|dd}|j}|@tjdd|ddj |j j|}nd}tjtjd dd}t||||t|_y) z:Augments an error with the metadata necessary for rewrite.ag_pass_throughNag_error_metadataz Caught error in user callable %sTexc_infoz{}: {})hasattrgetattr ag_source_maplogginglogformatrZr8 traceback extract_tbsysrbrA__file__r_)efmetadata source_maprFcause_tbs r3_attach_error_metadatars}s Q!" Q+T 2(*  KK5q4Hooakk22A6GG  ! !#,,."3 4QR 8(&x7J'/1!r2c(eZdZdZfdZdZxZS)StackTraceMapperz1Remaps generated code to code it originated from.cRt||j|_d|_yN)rSrKrf _source_map _cached_map)rC converted_fnrZs r3rKzStackTraceMapper.__init__s& G#11DDr2c|j |jS|jj}i}|jj D]U\}}|j j |j j|jf||j |jf<W|j D]\}}|\}}} tj||} | |jvrJ|j| }|j j |j j|jf||<{|||<||_|S)N)filenamelineno) ryparentget_effective_source_maprxitemslocr|r} function_namer LineLocation) rC parent_mapeffective_source_maproriginkeyvaluer|r}_ value_locs r3rz)StackTraceMapper.get_effective_source_maps: #   557J''--/P V:@**:M:M:@**:K:K:@:N:N:PCLL#**56P !&&(* U!h**HVLi d&& &!!),%+ZZ%8%8&**:K:K%+%9%9%;S!%*S!*,D r2)r8r9r:r;rKrr[r\s@r3rurus9 r2rucDeZdZdZfdZfdZdZdZdZdZ xZ S)PyToTFz%The TensorFlow AutoGraph transformer.c8tt| d|_yrw)rSrrK _extra_locals)rCrZs r3rKzPyToTF.__init__s &$ "Dr2c0dtt| |zS)Ntf__)rSrget_transformed_name)rCnoderZs r3rzPyToTF.get_transformed_names E&$urt3j@|S|rt3jB||i|St3jB||St jD|rt ||||S|jFs#t jH|rt ||||S|jJst ||||S tMjN|stMjP|r@|}|}tS|d d} | t| tTjVr | jX} | f|z}nXt[|dr3t[|j\dr|j\j^}|f|z}n|}tadtc|zt[|ds%tjdd|t ||||St[|jjdr>|jjjldk(r%tjdd|t ||||S tojp|} ts|| } tjtdr tw| ||ty| 5t{j|5 | | |i|} n| |} dddddd S#td$r=} tjdddtgrti||||| cYd} ~ Sd} ~ wwxYw#td$r=} tjdd|dtgrti||||| cYd} ~ Sd} ~ wwxYw#td$r} t| | d} ~ wwxYw#1swYxYw#1swY SxYw)aConverts a function call inline. For internal use only. Note: The argument list is optimized for readability of generated code, which may look like this: ag__.converted_call(f, (arg1, arg2), None, fscope) ag__.converted_call(f, (), dict(arg1=val1, **kwargs), fscope) ag__.converted_call(f, (arg1, arg2) + varargs, dict(**kwargs), lscope) Args: f: The function to convert. args: Tuple, the original positional arguments of f kwargs: Optional[Dict], the original keyword arguments of f caller_fn_scope: Optional[function_wrappers.FunctionScope], the function scope of the converted function in which this call was originally made. options: Optional[converter.ConversionOptions], conversion options. If not specified, the value of caller_fn_scope.callopts is used. Either options or caller_fn_scope must be present. Returns: Any, the result of executing a possibly-converted `f` with the given arguments. r`z/Converted call: %s args: %s kwargs: %s Nz3either caller_fn_scope or options must have a valuerczAllowlisted %s: from cacheFz1Allowlisted: %s: AutoGraph is disabled in contextz+Permanently allowed: %s: AutoGraph artifactz)Forwarding call of partial %s with %s %s )caller_fn_scoper__self__rZ__call__zunknown callable type "%s"zError transforming entity %sTrarz'Permanently allowed: %s: native binding co_filenamezz-Permanently allowed: %s: dynamic code (exec?)r)@rgrhrcalloptsris_in_allowlist_cache_call_unconvertedrcontrol_status_ctxstatusStatusDISABLEDr isinstance functoolspartialkeywordscopyrrNconverted_callfuncr isbuiltinevalreval_in_original_contextrSsuper_in_original_contextglobalsglobals_in_original_contextlocalslocals_in_original_context overload_ofis_unsupporteduser_requestedis_allowlistedinternal_convert_user_coderr isfunctionrer$TfMethodTargettargetrdrZrNotImplementedErrorrG Exceptionr4_fall_back_unconvertedrrrProgramContextr has_verbosity _log_callargsrur(CurrentModuleFilterrs)rorNkwargsrr new_kwargsnew_args target_entityeffective_argsf_selfrnr converted_fresults r3rr's4 ++aEq$ _ L MM&&G%%a1 KK/3 Qfgu ==  ''6==+A+AA KKFJ Qfgu ==1 KK@!D Qfg 669$$%Jzz::??$j vv}H KKA1h  '  QDy  1 1!T? KKEz  2 21dO LLG|  4 4_ EEF{  3 3O DD '[ $ $Q ' 8 88 '[ $ $Q ' ..q! Qfg 66   J$=$=a$@ Qfg 66  + + Qfg 66?g003mnq*d+f   f.== >==& ^3 K WQ[[*%E kk**mtd{nm  > ?* ? KK1=4P*, !!T67A >> ?  Q ,      -sCRASU2U4T(U S2SSS T%(2T T% T%( U1 T>>UUU UUTc|rtj||tj|r@t |j t jr|j j||S|||i|S||S)z>Calls the original function without converting with AutoGraph.) rcache_allowlistedrrrrr$rcall)rorNrr update_caches r3rrsl  G, q-<<= ::??4 ((  d f  D/r2cnd}t|tjr)tjr|t j ||d|nct|tjr/tj||s3t j ||d|nd}t j ||||t||||S)zAFalls back to calling the function unconverted, in case of error.zAutoGraph could not transform %s and will run it as-is. %sCause: %s To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convertzPlease report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. ) rrInaccessibleSourceCodeErrorrINSPECT_SOURCE_SUPPORTEDrgwarningUnsupportedLanguageElementErrorrrr)rorNrrrYwarning_templatefile_bug_messages r3rrs3 V778 && oo&2s3#v==>  + +Aw 7 oo&2s3 % OO$a)93? 1dFG 44r2z!__internal__.autograph.tf_convert)v1Fct|r|S|}tj|\}}|jtj j k(rtd||}nt|jtj jk(rt}nF|jtj jk(r|rtd||}nt}nJd||}|rtj|||}t|S)a Decorator that applies AutoGraph to a function. Use in internal APIs. This API is suitable for high order functions internal to the TensorFlow API, and more generally any function to which AutoGraph is not applied. Guidance: `convert` was a decorator meant for use directly by developers, but most of today's uses go through `tf.function`. `tf_convert` is to be called from high order functions internal to TF. By default, all the internal TensorFlow functions are skipped when AutoGraph processes the code. This may lead to user-supplied functions to be incorrectly skipped as well. `tf_convert` helps avoid that. See the following example for more details. ``` =====tf_internal_module.py===== def unconverted(input_fn): return input_fn() def converted(input_fn): return tf.__internal__.autograph.tf_convert( input_fn, ctx=tf.__internal__.autograph.control_status_ctx())() ======user_module.py====== @tf.function def foo(input_fn) return unconverted(input_fn) @tf.function def bar(input_fn) return converted(input_fn) @tf.function(autograph=False) def baz(input_fn) return converted(input_fn) ``` The `foo` method above will execute the `input_fn` without autograph conversion, while the `bar` method will run an autographed `input_fn`. The `baz` method will run an unconverted `input_fn`, since `tf_convert` respect the control status context. Note that both methods in `tf_internal_module` are skipped by autograph when tracing the `tf.function`. The configuration of whether a module/package should be skipped by autograph is controlled in tensorflow/python/autograph/core/config.py. Args: f: Callable. ctx: ag_ctx.ControlStatusCtx, the Autograph context in which `f` is used. convert_by_default: bool, whether to use AutoGraph when the context doesn't specify. user_requested: bool, whether to ignore the conversion allowlist. See ConversionOptions.user_requested. Returns: Either `f or the converted version of `f`. T) recursiverconversion_ctxz(This switch contains all possible cases!)rr&unwraprrrENABLEDconvertrdo_not_convert UNSPECIFIED'call_with_unspecified_conversion_statusrewrapr)rorconvert_by_defaultr f_wrapper decoratorswrapper_factorywrappers r3 tf_convertr!s~1 H)%%a(-*a ZZ6==(((~cKO zzV]]+++$O zzV]]...Mo@o<<<5 A '!!)Q8G G $$r2cfd}tjstjrtj|}t |S)zGDecorator that resets the conversion context to the unspecified status.ctjtjj5|i|cdddS#1swYyxYwN)r)rControlStatusCtxrrrNrrs r3r z8call_with_unspecified_conversion_status..wrapperRs=   (A(A B# 4 "6 "### AA )rrrrupdate_wrapperrrr s` r3rrOsB# !1!1$!7&&w5G G $$r2cltjdd||jtjdd||j|t j |g|i|}nt j |g|}dj d|jD}tjdd||y)zLogging helper.rczDefaults of %s : %szKW defaults of %s : %sN c3FK|]\}}dj||yw)z {}: {}N)ri).0kvs r3 z _log_callargs..fs&!>$(Aql!Q!>s!zCalling %s with %s )rgrh __defaults____kwdefaults__r' getcallargsjoinr)rorNrcallargsformatted_callargss r3rr\s ++a&1>>: ++a)1a.>.>? %%a9$9&9H%%a/$/Hyy!>,4NN,<!>> ++a(!-?@r2z%autograph.experimental.do_not_convertctSfd}tjstjrt j |}t |S)a}Decorator that suppresses the conversion of a function. Args: func: function to decorate. Returns: If `func` is not None, returns a `Callable` which is equivalent to `func`, but is not converted by AutoGraph. If `func` is None, returns a decorator that, when invoked with a single `func` argument, returns a `Callable` equivalent to the above case. ctjtjj5|i|cdddS#1swYyxYwr$)rr%rrr&s r3r zdo_not_convert..wrappers=   (>(> ?# 4 "6 "###r')rrrrrr(rr)s` r3rrpsO \ # !1!1$!7&&w5G G $$r2cfd}|S)aDecorator that compiles a function to use TensorFlow ops. The decorator is dynamic - it recompiles the target whenever the decorated function is called. This means the parameter values are known at conversion. It also means that repeated calls with different types of parameters will be correctly processed. Args: recursive: bool, whether to recursively convert any functions or classes that the converted function may use. optional_features: converted.Feature, allows toggling optional or experimental features. When set to None, only the core features are enabled. user_requested: bool, whether this is a function that the user explicitly asked to be converted. See ConversionOptions.user_requested. conversion_ctx: Optional ag_ctx.ControlStatusCtx, the Autograph context in which `f` is used. Returns: Callable, a decorator that converts the given function into an equivalent function that uses TensorFlow ops. cfd}tjstjrtj|}t j |}t|S)zDecorator implementation.ctj} 5t|||cdddS#1swYyxYw#t$r-}t |dr|j j |d}~wwxYw)z.Wrapper that calls the converted version of f.rroptional_featuresrNr_)rrrrrdr_ to_exception) rNrrrnrror=rrs r3r z+convert..decorator..wrappers++'-/g  B4A B B B  1) *##003 3  s.A6 A?AA A8 (A33A8)rrrrr(r&make_decoratorr)ror decorated_wrapperrr=rrs` r3 decoratorzconvert..decorators[  ! 0 0 3((!4g$33Aw? / 00r2r1)rr=rrrAs```` r3rrs610 r2zautograph.to_graphc v tjtj|d|}tt ||S#t t tttf$rW}tjdd|dtdj||jjt!|d}~wwxYw) aConverts a Python entity into a TensorFlow graph. Also see: `tf.autograph.to_code`, `tf.function`. Unlike `tf.function`, `to_graph` is a low-level transpiler that converts Python code to TensorFlow graph code. It does not implement any caching, variable management or create any actual ops, and is best used where greater control over the generated TensorFlow graph is desired. Another difference from `tf.function` is that `to_graph` will not wrap the graph into a TensorFlow function or a Python callable. Internally, `tf.function` uses `to_graph`. Example usage: >>> def f(x): ... if x > 0: ... y = x * x ... else: ... y = -x ... return y ... >>> converted_f = to_graph(f) >>> x = tf.constant(2) >>> converted_f(x) # converted_foo is like a TensorFlow Op. Supported Python entities include: * functions * classes * object methods Functions are converted into new functions with converted code. Classes are converted by generating a new class whose methods use converted code. Methods are converted into unbound function that have an additional first argument called `self`. For a tutorial, see the [tf.function and AutoGraph guide](https://www.tensorflow.org/guide/function). For more detailed information, see the [AutoGraph reference documentation](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/autograph/g3doc/reference/index.md). Args: entity: Python callable or class to convert. recursive: Whether to recursively convert any functions that the converted function may call. experimental_optional_features: `None`, a tuple of, or a single `tf.autograph.experimental.Feature` value. Returns: Same as `entity`, the converted Python function or class. Raises: ValueError: If the entity could not be converted. Tr<rr`zError converting %srazconverting {}: {}: {}N)rrrrrrAttributeErrorKeyError NameErrorAssertionErrorrgerrorr=rirZr8str)rrexperimental_optional_featuresrrns r3to_graphrJsv /**++<>?K ofkB CC nh > J/ MM!*FTB 188 $$c!f. ///sAAB8!AB33B8c"~~t|||S)aConverts a Python entity into a TensorFlow graph. Also see: `tf.autograph.to_code`, `tf.function`. Unlike `tf.function`, `to_graph` is a low-level transpiler that converts Python code to TensorFlow graph code. It does not implement any caching, variable management or create any actual ops, and is best used where greater control over the generated TensorFlow graph is desired. Another difference from `tf.function` is that `to_graph` will not wrap the graph into a TensorFlow function or a Python callable. Internally, `tf.function` uses `to_graph`. _Example Usage_ ```python def foo(x): if x > 0: y = x * x else: y = -x return y converted_foo = to_graph(foo) x = tf.constant(1) y = converted_foo(x) # converted_foo is a TensorFlow Op-like. assert is_tensor(y) ``` Supported Python entities include: * functions * classes * object methods Functions are converted into new functions with converted code. Classes are converted by generating a new class whose methods use converted code. Methods are converted into unbound function that have an additional first argument called `self`. Args: entity: Python callable or class to convert. recursive: Whether to recursively convert any functions that the converted function may call. arg_values: Deprecated. arg_types: Deprecated. experimental_optional_features: `None`, a tuple of, or a single `tf.autograph.experimental.Feature` value. Returns: Same as `entity`, the converted Python function or class. Raises: ValueError: If the entity could not be converted. rrI)rJ)rr arg_values arg_typesrIs r3 to_graph_v1rO s#~  %C EEr2zautograph.to_codec$~~~t|||S)aReturns the source code generated by AutoGraph, as a string. Example usage: >>> def f(x): ... if x < 0: ... x = -x ... return x >>> tf.autograph.to_code(f) "...def tf__f(x):..." Also see: `tf.autograph.to_graph`. Note: If a function has been decorated with `tf.function`, pass its underlying Python function, rather than the callable that `tf.function creates: >>> @tf.function ... def f(x): ... if x < 0: ... x = -x ... return x >>> tf.autograph.to_code(f.python_function) "...def tf__f(x):..." Args: entity: Python callable or class. recursive: Whether to recursively convert any functions that the converted function may call. arg_values: Deprecated. arg_types: Deprecated. indentation: Deprecated. experimental_optional_features: `None`, a tuple of, or a single `tf.autograph.experimental.Feature` value. Returns: The converted code as string. rL)to_code)rrrMrN indentationrIs r3 to_code_v1rSRs&Z  %C EEr2cntjt|||}tj|S)apReturns the source code generated by AutoGraph, as a string. Example usage: >>> def f(x): ... if x < 0: ... x = -x ... return x >>> tf.autograph.to_code(f) "...def tf__f(x):..." Also see: `tf.autograph.to_graph`. Note: If a function has been decorated with `tf.function`, pass its underlying Python function, rather than the callable that `tf.function creates: >>> @tf.function ... def f(x): ... if x < 0: ... x = -x ... return x >>> tf.autograph.to_code(f.python_function) "...def tf__f(x):..." Args: entity: Python callable or class to convert. recursive: Whether to recursively convert any functions that the converted function may call. experimental_optional_features: `None`, a tuple of, or a single `tf.autograph.experimental.Feature` value. Returns: The converted code as string. rL)r' getsourcerJtextwrapdedent)rrrIsources r3rQrQs9J    )GI J&   r2rw)NN)T)TF)TN)TNNN)TNNz N)Yr;rrrr.rlrVrjtensorflow.python.autographrr&tensorflow.python.autograph.convertersrrrrr r r r r rrrr tensorflow.python.autograph.corerrrr tensorflow.python.autograph.implr tensorflow.python.autograph.langr%tensorflow.python.autograph.operatorsr tensorflow.python.autograph.pyctrrrrrrrr 0tensorflow.python.autograph.pyct.static_analysisr!r"!tensorflow.python.autograph.utilsr#rg,tensorflow.python.eager.polymorphic_functionr$tensorflow.python.frameworkr%tensorflow.python.utilr&r'r( tensorflow.python.util.tf_exportr)r4rPr6r=r?ErrorMetadataBaserArsruPyToPyrrrrrrrr!rrrNullCtxrrJrOrSrQrr1r2r3ris(K 1-:C=JF?=<8FD9<36>I7>=1083:877EQCI3/-+6EV%% n > ,[22,D1(! x00! RGZ  GT.-Wt 5< .26^%7^%B % A( 23%4%6")6>>+3n B'D/(D/N #$%/3 CE&CEL "#$.2 2E%2Ej 2&)!')!Xh r2