BVh BbdZddlZddlZddlZddlmZddlmZddlmZddlmZGddejZ Gd d e Z Gd d ejd d ZGdde ZGdde ZGdde ZGddeej$ZGddeej(Zy)z3A node transformer that includes utilities for SCT.N)anno)parser)pretty_printer) templatesceZdZdZdZdZdZy) AnalysisLevelrN)__name__ __module__ __qualname__NONEACTIVITY DEFINEDNESSLIVENESS\/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/autograph/pyct/transformer.pyrrs $ (+ (rrceZdZdZdZy)ContextaContains information about a source code transformation. This object is mutable, and is updated during conversion. Not thread safe. Attributes: info: EntityInfo, immutable. namer: naming.Namer. current_origin: origin_info.OriginInfo, holds the OriginInfo of the last AST node to be processed successfully. Useful for error handling. user: An user-supplied context object. The object is opaque to the infrastructure, but will pe passed through to all custom transformations. c<||_||_d|_||_yN)infonamercurrent_originuser)selfrr user_contexts r__init__zContext.__init__3sDIDJDDIrN)r r r__doc__r rrrrr%s  rrceZdZdZy) EntityInfoaContains information about a Python entity. Immutable. Examples of entities include functions and classes. Attributes: name: The name that identifies this entity. source_code: The entity's source code. source_file: The entity's source file. future_features: Tuple[Text], the future features that this entity was compiled with. See https://docs.python.org/2/reference/simple_stmts.html#future. namespace: Dict[str, ], containing symbols visible to the entity (excluding parameters). N)r r rr!rrrr#r#;s  rr#)name source_code source_filefuture_features namespacecpeZdZdZdZdZdZdZdZe dZ e dZ e d Z d Z d Zd Zy ) _StateStackaTemplated context manager. This class provides syntactic sugar for a stack of objects of known type. It allows accessing attributes of the object at the top of the stack directly against this object, which allows for very terse syntax. For example, this code: stack = _StateStack(Foo) stack.enter() stack.bar Is equivalent to: stack = [] stack.append(Foo()) foo = stack[-1] foo.bar See _State for more on how this is used. Attributes: type: Any, the type of objects that this stack holds level: int, the current stack depth stack: List[Any], the actual stack value: Any, the instance of the object at the top of the stack ctj|d|tj|dgt|ds|jyy)Ntype_stackno_root)object __setattr__hasattrenter)rtype_s rr z_StateStack.__init__ps@ tVU+ tXr* 5) $ jjl %rc&|j|Sr)r2rs r __enter__z_StateStack.__enter__xsJJL Krc$|jyr)exit)rexc_type exc_value tracebacks r__exit__z_StateStack.__exit__|s IIKrcV|jj|jyr)r-appendr,r5s rr2z_StateStack.entersKKtyy{#rc8|jjyr)r-popr5s rr8z_StateStack.exitsKKOOrc|jSrr-r5s rstackz_StateStack.stacks ;;rc,t|jSr)lenr-r5s rlevelz_StateStack.levels t{{ rc |jdSNrBr5s rvaluez_StateStack.values ;;r?rc,t|jSr)iterr-r5s r__iter__z_StateStack.__iter__s  rc4t|jd|SrH)getattrr-rkeys r __getattr__z_StateStack.__getattr__s 4;;r?C ((rc8t|jd||yrH)setattrr-)rrQrJs rr0z_StateStack.__setattr__s DKKOS%(rN)r r rr!r r6r<r2r8propertyrCrFrJrMrRr0rrrr*r*Ssk8$      ))rr*ceZdZdZdZdZy)_StateaSyntactic sugar for accessing an instance of a StateStack context manager. This structure offers syntactic sugar over a dict of stacks of objects of known type. These structures are useful to keep state during AST walks. Multiple different scopes can be tracked in parallel. For example: s = _State() s[foo].enter() s[bar].enter() # this will not affect s[foo] Element access has special semantics: * keys are a data type * element values are _StateStack(type=key) objects * missing elements are automatically added, similarly to defaultdict For example, the following block : _State s s[Foo] Is equivalent to: s = {} if Foo not in s: s[Foo] = Foo() s[Foo] See Base for how it's used. ci|_yr)_valuer5s rr z_State.__init__s DKrcl||jvrt||j|<|j|Sr)rYr*rPs r __getitem__z_State.__getitem__s0 $++$S)dkk# ;;s rN)r r rr!r r[rrrrWrWs>rrWc*eZdZdZdZdZdZddZy)NodeStateTrackera<Base class for general-purpose Python code transformation. This abstract class provides helpful functions, like state tracking within the scope of arbitrary node, helpers for processing code blocks, debugging, mapping of transformed code to original code, and others. Scope-local state tracking: to keep state across nodes, at the level of (possibly nested) scopes, use enter/exit_local_scope and set/get_local. You must call enter/exit_local_scope manually, but the transformer detects when they are not properly paired. The transformer allows keeping state across calls that is local to arbitrary nodes and their descendants, using the self.state attribute. Multiple independent scopes are allowed and automatically constructed. For example, to keep track of the `If` node that encloses any `Name` node, one can write: ``` class FooType(object): def __init__(self): self.foo_property = None class DummyTransformer(NodeStateTracker, ast.NodeTransformer): def visit_If(self, node): self.state[FooType].enter() self.state[FooType].foo_property = node node = self.veneric_visit(node) self.state[FooType].exit() return node def visit_Name(self, node): self.state[FooType].foo_property # will hold the innermost enclosing if ``` Alternatively, the `enter()`/`exit()` calls can be managed by a `with` statement: ``` def visit_If(self, node): with self.state[FooType] as foo: foo.foo_property = node return self.generic_visit(node) ``` cLd|_d|_||_t|_y)zjInitialize the transformer. Subclasses should call this. Args: ctx: A Context object. rN)_lineno _col_offsetctxrWstate)rras rr zNodeStateTracker.__init__s%DLDDHDJrcD ttj||S)z3Helper method useful for debugging. Prints the AST.)printrfmtrnodes r debug_printzNodeStateTracker.debug_print s N  t $% KrcD ttj||S)z;Helper method useful for debugging. Prints the AST as code.)rdrunparserfs rdebug_print_srcz NodeStateTracker.debug_print_srcs FNN4 ! KrNc|yg}|}|D]n}|r||j|}|r|r ||\}}nd}|r9t|ttfr|j |n|j ||m|}p|S)a%A more powerful version of generic_visit for statement blocks. An example of a block is the body of an if statement. This function allows specifying a postprocessing callback (the after_visit argument) argument which can be used to move nodes to a new destination. This is done by after_visit by returning a non-null second return value, e.g. return new_node, new_destination. For example, a transformer could perform the following move: foo() bar() baz() foo() if cond: bar() baz() The above could be done with a postprocessor of this kind: def after_visit(node): if node_is_function_call(bar): new_container_node = build_cond() new_container_node.body.append(node) return new_container_node, new_container_node.body else: # Once we set a new destination, all subsequent items will be # moved to it, so we don't need to explicitly handle baz. return node, None Args: nodes: enumerable of AST node objects. If None, the function returns None. before_visit: optional callable that is called before visiting each item in nodes after_visit: optional callable that takes in an AST node and returns a tuple (new_node, new_destination). It is called after visiting each item in nodes. Is used in the same was as the visit_* methods: new_node will replace the node; if not None, new_destination must be a list, and subsequent nodes will be placed in this list instead of the list returned by visit_block. Returns: A list of AST node objects containing the transformed items from nodes, except those nodes that have been relocated using after_visit. N)visit isinstancelisttupleextendr>) rnodes before_visit after_visitresultsnode_destinationrg replacementnew_destinations r visit_blockzNodeStateTracker.visit_blocks` } G+ JJt$k '2;'?$ _  kD%= 1  ! !+ .  ! !+ .  $*)+* Nr)NN)r r rr!r rhrkryrrrr]r]s.d&  Jrr]c.eZdZdZdZdZfdZxZS)BasezBase class for general-purpose Python-to-Python code transformation. This is an extension of ast.NodeTransformer that provides the additional functions offered by NodeStateTracker. c6d}tj|||S)Nz target = expression )target expression)rreplace)rr}r~templates rcreate_assignmentzBase.create_assignmentks H   Xf LLrct|ttfs|f}|D]}t|tjtj frt t|jD]}|j|}t|tjtj fr|j|}n*tj||tj}|j||||||y)aApplies a function to each individual assignment. This function can process a possibly-unpacked (e.g. a, b = c, d) assignment. It tries to break down the unpacking if possible. In effect, it has the same effect as passing the assigned values in SSA form to apply_fn. Examples: The following will result in apply_fn(a, c), apply_fn(b, d): a, b = c, d The following will result in apply_fn(a, c[0]), apply_fn(b, c[1]): a, b = c The following will result in apply_fn(a, (b, c)): a = b, c It uses the visitor pattern to allow subclasses to process single assignments individually. Args: targets: list, tuple of or individual AST node. Should be used with the targets field of an ast.Assign node. values: an AST node. apply_fn: a function of a single argument, which will be called with the respective nodes of each single assignment. The signature is apply_fn(target, value), no return value. )raN) rnrorpgastTupleListrangerEelts SubscriptStoreapply_to_single_assignments)rtargetsvaluesapply_fnr}i target_elvalue_els rrz Base.apply_to_single_assignmentsrs@ ge} - g ! FTZZ3 4s6;;'( JAkk!n) TYY 7 8{{1~H~~faTZZ\BH  * *9h I  J   !rc t|tjs%djt |}t |t j|t jjr|S|jj}t j|t jjr=t j|t jj|j_ t|tj}|r |j}t t"|K|}|rrt|tjrX|jurJt|jt&t(tj*tj,fr |j}||ur|t j|t jj|}||}t|t&t(fr|}n|f}|D]`} t j| t jjr2t j.| t jj|b||j_ |S#||j_ wxYw)Nzjinvalid value for "node": expected "ast.AST", got "{}"; to visit lists of nodes, use "visit_block" insteaddefault)rnrASTformatr, ValueErrorrhasannoBasicSKIP_PROCESSINGrarORIGINgetannoExprrJsuperr{rmrorpAssign AugAssignsetanno) rrgmsg parent_originprocessing_expr_nodeentry_expr_valueresultinherited_originnodes_to_adjustn __class__s rrmz Base.visits dDHH % @AGdB  sO ||D$**445 kHH++M ||D$**++, $ T4::3D3D Edhh!.'dii8 ::T4&t,f :fdii#@ <</ / fllUDKK@ B<<& t  2<< $**##]<  '"/ u .$O%iO" Ca<<4::#4#45ll1djj//1AB C!.dhh M!.dhhs3D8I0,1I00J)r r rr!rrrm __classcell__rs@rr{r{ds M-!^66rr{cBeZdZdZfdZdZedZfdZxZ S) CodeGeneratoraBBase class for general-purpose Python-to-string code transformation. Similar to Base, but outputs arbitrary strings instead of a Python AST. This uses the same visitor mechanism that the standard NodeVisitor uses, meaning that subclasses write handlers for the different kinds of nodes. New code is generated using the emit method, which appends to a code buffer that can be afterwards obtained from code_buffer. Example: class SimpleCodeGen(CodeGenerator): def visitIf(self, node): self.emit('if ') self.visit(node.test) self.emit(' { ') self.visit(node.body) self.emit(' } else { ') self.visit(node.orelse) self.emit(' } ') node = ast.parse(...) gen = SimpleCodeGen() gen.visit(node) # gen.code_buffer contains the resulting code cHtt| |d|_i|_y)N)rrr _output_code source_map)rrars rr zCodeGenerator.__init__s! -',DDOrc.|xj|z c_yrr)rcodes remitzCodeGenerator.emitsrc|jSrrr5s r code_bufferzCodeGenerator.code_buffers   rctj|tjjry|jj }t |j}tj|tjjr=tj|tjj|j_ tt|3|}t |j}||z rCtj|tjj|}|||j||f<|||j_S#||j_wxYw)Nr)rrrrrarrErrrrrrmr)rrgr eof_beforeret eof_afterrrs rrmzCodeGenerator.visits ||D$**445 HH++MT&&'J ||D$**++, $ T4::3D3D Edhh . - ,T 2cd''(i i << $**##]<  '5E$//:y1 2  -dhh dhhs A1E E) r r rr!r rrUrrmrrs@rrrs08   ..rr)r! collectionsenumr tensorflow.python.autograph.pyctrrrrIntEnumrr/r namedtupler#r*rWr]NodeTransformerr{ NodeVisitorrrrrrs: 13;6DLLf,KNP0E)&E)P&V&R\v\@s T11sl@.$d&6&6@.r