Add files using upload-large-folder tool

.gitattributes

@@ -196,3 +196,4 @@ SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/pl
 SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/grappler/_pywrap_tf_optimizer.so filter=lfs diff=lfs merge=lfs -text
 SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/grappler/_pywrap_tf_item.so filter=lfs diff=lfs merge=lfs -text
 SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/profiler/internal/_pywrap_profiler.so filter=lfs diff=lfs merge=lfs -text
+SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/client/_pywrap_tf_session.so filter=lfs diff=lfs merge=lfs -text

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/__init__.py

@@ -0,0 +1,57 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Conversion of eager-style Python into TensorFlow graph code.
+
+NOTE: In TensorFlow 2.0, AutoGraph is automatically applied when using
+`tf.function`. This module contains lower-level APIs for advanced use.
+
+AutoGraph transforms a subset of Python which operates on TensorFlow objects
+into equivalent TensorFlow graph code. When executing the graph, it has the same
+effect as if you ran the original code in eager mode.
+Python code which doesn't operate on TensorFlow objects remains functionally
+unchanged, but keep in mind that `tf.function` only executes such code at trace
+time, and generally will not be consistent with eager execution.
+
+For more information, see the
+[AutoGraph reference documentation](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/autograph/g3doc/reference/index.md),
+and the [tf.function guide](https://www.tensorflow.org/guide/function#autograph_transformations).
+"""
+
+from tensorflow.python.util.all_util import remove_undocumented
+
+# TODO(mdan): Revisit this list once we finalize the generated code mechanism.
+_allowed_symbols = [
+    # Main API
+    'AutoGraphError',
+    'ConversionOptions',
+    'Feature',
+    'StackTraceMapper',
+    'convert',
+    'converted_call',
+    'do_not_convert',
+    'to_code',
+    'to_graph',
+    # Overloaded operators
+    'operators',
+    # Python language "extensions"
+    'set_element_type',
+    'set_loop_options',
+    'stack',
+    'tensor_list',
+    # Utilities: to be removed
+    'utils',
+]
+
+remove_undocumented(__name__, _allowed_symbols)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/lang/directives.py

@@ -0,0 +1,94 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Directives are special no-op functions that serve as compilation markers.
+
+They provide static information like type hints, compilation and TensorFlow
+overrides.
+
+These serve as annotations in the compiled code, allowing the user some control
+over the compilation process. They have no functional role at runtime.
+"""
+
+from tensorflow.python.util.tf_export import tf_export
+
+UNSPECIFIED = object()
+
+
+def set_element_type(entity, dtype, shape=UNSPECIFIED):
+  """Indicates that the entity is expected hold items of specified type/shape.
+
+  The staged TensorFlow ops will reflect and assert this data type. Ignored
+  otherwise.
+
+  Args:
+    entity: The entity to annotate.
+    dtype: TensorFlow dtype value to assert for entity.
+    shape: Optional shape to assert for entity.
+  """
+  del entity
+  del dtype
+  del shape
+
+
+@tf_export('autograph.experimental.set_loop_options')
+def set_loop_options(
+    parallel_iterations=UNSPECIFIED,
+    swap_memory=UNSPECIFIED,
+    maximum_iterations=UNSPECIFIED,
+    shape_invariants=UNSPECIFIED):
+  """Specifies additional arguments to be passed to the enclosing while_loop.
+
+  The parameters apply to and only to the immediately enclosing loop. It only
+  has effect if the loop is staged as a TF while_loop; otherwise the parameters
+  have no effect.
+
+  Usage:
+
+    >>> @tf.function(autograph=True)
+    ... def f():
+    ...   n = 0
+    ...   for i in tf.range(10):
+    ...     tf.autograph.experimental.set_loop_options(maximum_iterations=3)
+    ...     n += 1
+    ...   return n
+
+    >>> @tf.function(autograph=True)
+    ... def f():
+    ...   v = tf.constant((0,))
+    ...   for i in tf.range(3):
+    ...     tf.autograph.experimental.set_loop_options(
+    ...         shape_invariants=[(v, tf.TensorShape([None]))]
+    ...     )
+    ...     v = tf.concat((v, [i]), 0)
+    ...   return v
+
+  Also see tf.while_loop.
+
+  Args:
+    parallel_iterations: The maximum number of iterations allowed to run in
+        parallel at any given time. Note that this does not guarantee parallel
+        execution.
+    swap_memory: Whether to store intermediate values needed for
+        gradients on the CPU instead of GPU.
+    maximum_iterations: Allows limiting the total number of iterations executed
+        by the loop.
+    shape_invariants: Allows controlling the argument with the same name passed
+        to tf.while_loop. Unlike tf.while_loop, this is a list of
+        `(tensor, shape)` pairs.
+  """
+  del parallel_iterations
+  del swap_memory
+  del maximum_iterations
+  del shape_invariants

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/lang/special_functions.py

@@ -0,0 +1,118 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Special functions that only make sense for AutoGraph.
+
+These functions are meant to ensure feature parity between Python and AutoGraph,
+so that the exact same code works in both modes. In general, AutoGraph will
+replace these calls.
+"""
+
+from tensorflow.python.autograph.operators import data_structures
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import tensor_util
+
+
+def _validate_list_constructor(elements, element_dtype, element_shape):
+  """Validates the inputs of tensor_list."""
+  if element_dtype is not None and element_shape is not None:
+    return
+  if tensor_util.is_tf_type(elements):
+    return
+  if isinstance(elements, (list, tuple)):
+    if elements:
+      return
+    else:
+      raise ValueError(
+          'element_dtype and element_shape are required when elements are'
+          ' empty')
+
+  raise ValueError(
+      'unknown type for elements: {}; only Tensor, list and tuple are'
+      ' allowed'.format(type(elements)))
+
+
+def match_staging_level(value, like_value):
+  """Casts a value to be staged at the same level as another."""
+  if tensor_util.is_tf_type(like_value):
+    return constant_op.constant(value)
+  return value
+
+
+def tensor_list(elements,
+                element_dtype=None,
+                element_shape=None,
+                use_tensor_array=False):
+  """Creates an tensor list and populates it with the given elements.
+
+  This function provides a more uniform access to tensor lists and tensor
+  arrays, and allows optional initialization.
+
+  Note: this function is a simplified wrapper. If you need greater control,
+  it is recommended to use the underlying implementation directly.
+
+  Args:
+    elements: Iterable[tf.Tensor, ...], the elements to initially fill the list
+        with
+    element_dtype: Optional[tf.DType], data type for the elements in the list;
+        required if the list is empty
+    element_shape: Optional[tf.TensorShape], shape for the elements in the list;
+        required if the list is empty
+    use_tensor_array: bool, whether to use the more compatible but restrictive
+        tf.TensorArray implementation
+  Returns:
+    Union[tf.Tensor, tf.TensorArray], the new list.
+  Raises:
+    ValueError: for invalid arguments
+  """
+  _validate_list_constructor(elements, element_dtype, element_shape)
+  if use_tensor_array:
+    return data_structures.tf_tensor_array_new(elements, element_dtype,
+                                               element_shape)
+  else:
+    return data_structures.tf_tensor_list_new(elements, element_dtype,
+                                              element_shape)
+
+
+def stack(list_or_tensor, element_dtype=None, strict=True):
+  """Stacks the input, if it admits the notion of stacking.
+
+  For example, a list of tensors can be stacked into a larger tensor. This
+  function is similar to tf.stack, but it accepts non-lists and lists of
+  non-tensors as arguments. In the latter case, the function does nothing.
+
+  Args:
+    list_or_tensor: Any
+    element_dtype: tf.DType, optional dtypedtype for the elements in the list.
+        Required if the input is stackable, and the list is untyped.
+    strict: bool, if True an error is raised if the input is not stackable.
+        Otherwise the function is a no-op.
+
+  Returns:
+    Any, if the input is stackable, the result will be a tf.Tensor. Otherwise,
+    if strict=False, the result will be list_or_tensor.
+
+  Raises:
+    ValueError: if strict=True and the input is not stackable.
+  """
+  if strict:
+    def raise_error(x):
+      raise ValueError('%s must be stackable when strict=True' % x)
+    original_call = raise_error
+  else:
+    original_call = lambda x: x
+  return data_structures.list_stack(
+      list_or_tensor,
+      data_structures.ListStackOpts(
+          element_dtype=element_dtype, original_call=original_call))

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/anno.py

@@ -0,0 +1,174 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""AST node annotation support.
+
+Adapted from Tangent.
+"""
+
+import enum
+
+# pylint:disable=g-bad-import-order
+
+import gast
+# pylint:enable=g-bad-import-order
+
+
+# TODO(mdan): Shorten the names.
+# These names are heavily used, and anno.blaa
+# TODO(mdan): Replace the attr-dict mechanism with a more typed solution.
+
+
+class NoValue(enum.Enum):
+  """Base class for different types of AST annotations."""
+
+  def of(self, node, default=None):
+    return getanno(node, self, default=default)
+
+  def add_to(self, node, value):
+    setanno(node, self, value)
+
+  def exists(self, node):
+    return hasanno(node, self)
+
+  def __repr__(self):
+    return str(self.name)
+
+
+class Basic(NoValue):
+  """Container for basic annotation keys.
+
+  The enum values are used strictly for documentation purposes.
+  """
+
+  QN = 'Qualified name, as it appeared in the code. See qual_names.py.'
+  SKIP_PROCESSING = (
+      'This node should be preserved as is and not processed any further.')
+  INDENT_BLOCK_REMAINDER = (
+      'When a node is annotated with this, the remainder of the block should'
+      ' be indented below it. The annotation contains a tuple'
+      ' (new_body, name_map), where `new_body` is the new indented block and'
+      ' `name_map` allows renaming symbols.')
+  ORIGIN = ('Information about the source code that converted code originated'
+            ' from. See origin_information.py.')
+  DIRECTIVES = ('User directives associated with a statement or a variable.'
+                ' Typically, they affect the immediately-enclosing statement.')
+
+  EXTRA_LOOP_TEST = (
+      'A special annotation containing additional test code to be executed in'
+      ' for loops.')
+
+
+class Static(NoValue):
+  """Container for static analysis annotation keys.
+
+  The enum values are used strictly for documentation purposes.
+  """
+
+  # Symbols
+  # These flags are boolean.
+  IS_PARAM = 'Symbol is a parameter to the function being analyzed.'
+
+  # Scopes
+  # Scopes are represented by objects of type activity.Scope.
+  SCOPE = 'The scope for the annotated node. See activity.py.'
+  # TODO(mdan): Drop these in favor of accessing the child's SCOPE.
+  ARGS_SCOPE = 'The scope for the argument list of a function call.'
+  COND_SCOPE = 'The scope for the test node of a conditional statement.'
+  BODY_SCOPE = (
+      'The scope for the main body of a statement (True branch for if '
+      'statements, main body for loops).')
+  ORELSE_SCOPE = (
+      'The scope for the orelse body of a statement (False branch for if '
+      'statements, orelse body for loops).')
+
+  # Static analysis annotations.
+  DEFINITIONS = (
+      'Reaching definition information. See reaching_definitions.py.')
+  ORIG_DEFINITIONS = (
+      'The value of DEFINITIONS that applied to the original code before any'
+      ' conversion.')
+  DEFINED_FNS_IN = (
+      'Local function definitions that may exist when exiting the node. See'
+      ' reaching_fndefs.py')
+  DEFINED_VARS_IN = (
+      'Symbols defined when entering the node. See reaching_definitions.py.')
+  LIVE_VARS_OUT = ('Symbols live when exiting the node. See liveness.py.')
+  LIVE_VARS_IN = ('Symbols live when entering the node. See liveness.py.')
+  TYPES = 'Static type information. See type_inference.py.'
+  CLOSURE_TYPES = 'Types of closure symbols at each detected call site.'
+  VALUE = 'Static value information. See type_inference.py.'
+
+
+FAIL = object()
+
+
+def keys(node, field_name='___pyct_anno'):
+  if not hasattr(node, field_name):
+    return frozenset()
+  return frozenset(getattr(node, field_name).keys())
+
+
+def getanno(node, key, default=FAIL, field_name='___pyct_anno'):
+  if (default is FAIL or (hasattr(node, field_name) and
+                          (key in getattr(node, field_name)))):
+    return getattr(node, field_name)[key]
+  return default
+
+
+def hasanno(node, key, field_name='___pyct_anno'):
+  return hasattr(node, field_name) and key in getattr(node, field_name)
+
+
+def setanno(node, key, value, field_name='___pyct_anno'):
+  annotations = getattr(node, field_name, {})
+  setattr(node, field_name, annotations)
+  annotations[key] = value
+
+  # So that the annotations survive gast_to_ast() and ast_to_gast()
+  if field_name not in node._fields:
+    node._fields += (field_name,)
+
+
+def delanno(node, key, field_name='___pyct_anno'):
+  annotations = getattr(node, field_name)
+  del annotations[key]
+  if not annotations:
+    delattr(node, field_name)
+    node._fields = tuple(f for f in node._fields if f != field_name)
+
+
+def copyanno(from_node, to_node, key, field_name='___pyct_anno'):
+  if hasanno(from_node, key, field_name=field_name):
+    setanno(
+        to_node,
+        key,
+        getanno(from_node, key, field_name=field_name),
+        field_name=field_name)
+
+
+def dup(node, copy_map, field_name='___pyct_anno'):
+  """Recursively copies annotations in an AST tree.
+
+  Args:
+    node: ast.AST
+    copy_map: Dict[Hashable, Hashable], maps a source anno key to a destination
+        key. All annotations with the source key will be copied to identical
+        annotations with the destination key.
+    field_name: str
+  """
+  for n in gast.walk(node):
+    for k in copy_map:
+      if hasanno(n, k, field_name):
+        setanno(n, copy_map[k], getanno(n, k, field_name), field_name)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/ast_util.py

@@ -0,0 +1,344 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""AST manipulation utilities."""
+
+import ast
+
+import gast
+
+from tensorflow.python.autograph.pyct import anno
+from tensorflow.python.autograph.pyct import parser
+from tensorflow.python.autograph.pyct import qual_names
+
+
+class CleanCopier(object):
+  """NodeTransformer-like visitor that copies an AST."""
+
+  def __init__(self, preserve_annos):
+    super(CleanCopier, self).__init__()
+    self.preserve_annos = preserve_annos
+
+  def copy(self, node):
+    """Returns a deep copy of node (excluding some fields, see copy_clean)."""
+
+    if isinstance(node, list):
+      return [self.copy(n) for n in node]
+    elif isinstance(node, tuple):
+      return tuple(self.copy(n) for n in node)
+    elif not isinstance(node, (gast.AST, ast.AST)):
+      # Assuming everything that's not an AST, list or tuple is a value type
+      # and may simply be assigned.
+      return node
+
+    assert isinstance(node, (gast.AST, ast.AST))
+
+    new_fields = {}
+    for f in node._fields:
+      if not f.startswith('__') and hasattr(node, f):
+        new_fields[f] = self.copy(getattr(node, f))
+    new_node = type(node)(**new_fields)
+
+    if self.preserve_annos:
+      for k in self.preserve_annos:
+        anno.copyanno(node, new_node, k)
+    return new_node
+
+
+def copy_clean(node, preserve_annos=None):
+  """Creates a deep copy of an AST.
+
+  The copy will not include fields that are prefixed by '__', with the
+  exception of user-specified annotations.
+
+  Args:
+    node: ast.AST
+    preserve_annos: Optional[Set[Hashable]], annotation keys to include in the
+        copy
+  Returns:
+    ast.AST
+  """
+  return CleanCopier(preserve_annos).copy(node)
+
+
+class SymbolRenamer(gast.NodeTransformer):
+  """Transformer that can rename symbols to a simple names."""
+
+  def __init__(self, name_map):
+    self.name_map = name_map
+
+  def _process_name_node(self, node):
+    qn = anno.getanno(node, anno.Basic.QN)
+    if qn in self.name_map:
+      new_node = gast.Name(
+          str(self.name_map[qn]),
+          ctx=node.ctx,
+          annotation=None,
+          type_comment=None)
+      # All annotations get carried over.
+      for k in anno.keys(node):
+        anno.copyanno(node, new_node, k)
+      return new_node
+    return self.generic_visit(node)
+
+  def _process_list_of_strings(self, names):
+    for i in range(len(names)):
+      qn = qual_names.QN(names[i])
+      if qn in self.name_map:
+        names[i] = str(self.name_map[qn])
+    return names
+
+  def visit_Nonlocal(self, node):
+    node.names = self._process_list_of_strings(node.names)
+    return node
+
+  def visit_Global(self, node):
+    node.names = self._process_list_of_strings(node.names)
+    return node
+
+  def visit_Name(self, node):
+    return self._process_name_node(node)
+
+  def visit_Attribute(self, node):
+    if anno.hasanno(node, anno.Basic.QN):
+      return self._process_name_node(node)
+    # Renaming attributes is not supported.
+    return self.generic_visit(node)
+
+  def visit_FunctionDef(self, node):
+    qn = qual_names.QN(node.name)
+    if qn in self.name_map:
+      node.name = str(self.name_map[qn])
+    return self.generic_visit(node)
+
+
+def rename_symbols(node, name_map):
+  """Renames symbols in an AST. Requires qual_names annotations."""
+  renamer = SymbolRenamer(name_map)
+  if isinstance(node, list):
+    return [renamer.visit(n) for n in node]
+  elif isinstance(node, tuple):
+    return tuple(renamer.visit(n) for n in node)
+  return renamer.visit(node)
+
+
+def keywords_to_dict(keywords):
+  """Converts a list of ast.keyword objects to a dict."""
+  keys = []
+  values = []
+  for kw in keywords:
+    keys.append(gast.Constant(kw.arg, kind=None))
+    values.append(kw.value)
+  return gast.Dict(keys=keys, values=values)
+
+
+class PatternMatcher(gast.NodeVisitor):
+  """Matches a node against a pattern represented by a node."""
+
+  def __init__(self, pattern):
+    self.pattern = pattern
+    self.pattern_stack = []
+    self.matches = True
+
+  def compare_and_visit(self, node, pattern):
+    self.pattern_stack.append(self.pattern)
+    self.pattern = pattern
+    self.generic_visit(node)
+    self.pattern = self.pattern_stack.pop()
+
+  def no_match(self):
+    self.matches = False
+    return False
+
+  def is_wildcard(self, p):
+    if isinstance(p, (list, tuple)) and len(p) == 1:
+      p, = p
+    if isinstance(p, gast.Name) and p.id == '_':
+      return True
+    if p == '_':
+      return True
+    return False
+
+  def generic_visit(self, node):
+    if not self.matches:
+      return
+
+    pattern = self.pattern
+    for f in node._fields:
+      if f.startswith('__'):
+        continue
+
+      if not hasattr(node, f):
+        if hasattr(pattern, f) and getattr(pattern, f):
+          return self.no_match()
+        else:
+          continue
+      if not hasattr(pattern, f):
+        return self.no_match()
+
+      v = getattr(node, f)
+      p = getattr(pattern, f)
+
+      if self.is_wildcard(p):
+        continue
+      if isinstance(v, (list, tuple)):
+        if not isinstance(p, (list, tuple)) or len(v) != len(p):
+          return self.no_match()
+        for v_item, p_item in zip(v, p):
+          self.compare_and_visit(v_item, p_item)
+      elif isinstance(v, (gast.AST, ast.AST)):
+        if not isinstance(v, type(p)) and not isinstance(p, type(v)):
+          return self.no_match()
+        self.compare_and_visit(v, p)
+      else:
+        # Assume everything else is a value type.
+        if v != p:
+          return self.no_match()
+
+
+def matches(node, pattern):
+  """Basic pattern matcher for AST.
+
+  The pattern may contain wildcards represented by the symbol '_'. A node
+  matches a pattern if for every node in the tree, either there is a node of
+  the same type in pattern, or a Name node with id='_'.
+
+  Args:
+    node: ast.AST
+    pattern: ast.AST
+  Returns:
+    bool
+  """
+  if isinstance(pattern, str):
+    pattern = parser.parse_str(pattern)
+
+  matcher = PatternMatcher(pattern)
+  matcher.visit(node)
+  return matcher.matches
+
+
+# TODO(mdan): Once we have error tracing, we may be able to just go to SSA.
+def apply_to_single_assignments(targets, values, apply_fn):
+  """Applies 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: Union[List[ast.AST, ...], Tuple[ast.AST, ...], ast.AST, should be
+        used with the targets field of an ast.Assign node
+    values: ast.AST
+    apply_fn: Callable[[ast.AST, ast.AST], None], called with the
+        respective nodes of each single assignment
+  """
+  if not isinstance(targets, (list, tuple)):
+    targets = (targets,)
+  for target in targets:
+    if isinstance(target, (gast.Tuple, gast.List)):
+      for i in range(len(target.elts)):
+        target_el = target.elts[i]
+        if isinstance(values, (gast.Tuple, gast.List)):
+          value_el = values.elts[i]
+        else:
+          idx = parser.parse_expression(str(i))
+          value_el = gast.Subscript(values, idx, ctx=gast.Load())
+        apply_to_single_assignments(target_el, value_el, apply_fn)
+    else:
+      apply_fn(target, values)
+
+
+def parallel_walk(node, other):
+  """Walks two ASTs in parallel.
+
+  The two trees must have identical structure.
+
+  Args:
+    node: Union[ast.AST, Iterable[ast.AST]]
+    other: Union[ast.AST, Iterable[ast.AST]]
+  Yields:
+    Tuple[ast.AST, ast.AST]
+  Raises:
+    ValueError: if the two trees don't have identical structure.
+  """
+  if isinstance(node, (list, tuple)):
+    node_stack = list(node)
+  else:
+    node_stack = [node]
+
+  if isinstance(other, (list, tuple)):
+    other_stack = list(other)
+  else:
+    other_stack = [other]
+
+  while node_stack and other_stack:
+    assert len(node_stack) == len(other_stack)
+    n = node_stack.pop()
+    o = other_stack.pop()
+
+    if ((not isinstance(n, (ast.AST, gast.AST, str)) and n is not None) or
+        (not isinstance(o, (ast.AST, gast.AST, str)) and n is not None) or
+        n.__class__.__name__ != o.__class__.__name__):
+      raise ValueError('inconsistent nodes: {} ({}) and {} ({})'.format(
+          n, n.__class__.__name__, o, o.__class__.__name__))
+
+    yield n, o
+
+    if isinstance(n, str):
+      assert isinstance(o, str), 'The check above should have ensured this'
+      continue
+    if n is None:
+      assert o is None, 'The check above should have ensured this'
+      continue
+
+    for f in n._fields:
+      n_child = getattr(n, f, None)
+      o_child = getattr(o, f, None)
+      if f.startswith('__') or n_child is None or o_child is None:
+        continue
+
+      if isinstance(n_child, (list, tuple)):
+        if (not isinstance(o_child, (list, tuple)) or
+            len(n_child) != len(o_child)):
+          raise ValueError(
+              'inconsistent values for field {}: {} and {}'.format(
+                  f, n_child, o_child))
+        node_stack.extend(n_child)
+        other_stack.extend(o_child)
+
+      elif isinstance(n_child, (gast.AST, ast.AST)):
+        node_stack.append(n_child)
+        other_stack.append(o_child)
+
+      elif n_child != o_child:
+        raise ValueError(
+            'inconsistent values for field {}: {} and {}'.format(
+                f, n_child, o_child))

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/cache.py

@@ -0,0 +1,93 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Caching utilities."""
+
+import inspect
+import weakref
+
+
+# TODO(mdan): Add a garbage collection hook for cleaning up modules.
+class _TransformedFnCache(object):
+  """Generic hierarchical cache for transformed functions.
+
+  The keys are soft references (i.e. they are discarded when the key is
+  destroyed) created from the source function by `_get_key`. The subkeys are
+  strong references and can be any value. Typically they identify different
+  kinds of transformation.
+  """
+
+  __slots__ = ('_cache',)
+
+  def __init__(self):
+    self._cache = weakref.WeakKeyDictionary()
+
+  def _get_key(self, entity):
+    raise NotImplementedError('subclasses must override')
+
+  def has(self, entity, subkey):
+    key = self._get_key(entity)
+    parent = self._cache.get(key, None)
+    if parent is None:
+      return False
+    return subkey in parent
+
+  def __getitem__(self, entity):
+    key = self._get_key(entity)
+    parent = self._cache.get(key, None)
+    if parent is None:
+      # The bucket is initialized to support this usage:
+      #   cache[key][subkey] = value
+      self._cache[key] = parent = {}
+    return parent
+
+  def __len__(self):
+    return len(self._cache)
+
+
+class CodeObjectCache(_TransformedFnCache):
+  """A function cache based on code objects.
+
+  Code objects are good proxies for the source code of a function.
+
+  This cache efficiently handles functions that share code objects, such as
+  functions defined in a loop, bound methods, etc.
+
+  The cache falls back to the function object, if it doesn't have a code object.
+  """
+
+  def _get_key(self, entity):
+    if hasattr(entity, '__code__'):
+      return entity.__code__
+    else:
+      return entity
+
+
+class UnboundInstanceCache(_TransformedFnCache):
+  """A function cache based on unbound function objects.
+
+  Using the function for the cache key allows efficient handling of object
+  methods.
+
+  Unlike the _CodeObjectCache, this discriminates between different functions
+  even if they have the same code. This is needed for decorators that may
+  masquerade as another function.
+  """
+
+  def _get_key(self, entity):
+    if inspect.ismethod(entity):
+      return entity.__func__
+    return entity
+
+

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/cfg.py

@@ -0,0 +1,976 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Control flow graph (CFG) structure for Python AST representation.
+
+The CFG is a digraph with edges representing valid control flow. Each
+node is associated with exactly one AST node, but not all AST nodes may have
+a corresponding CFG counterpart.
+
+Once built, the CFG itself is immutable, but the values it holds need not be;
+they are usually annotated with information extracted by walking the graph.
+
+Tip: Use `Graph.as_dot` to visualize the CFG using any DOT viewer.
+
+Note: the CFG tries to include all code paths that MAY be taken, with a single
+notable exception:
+ * function calls do not generate edges corresponding to exceptions they may
+   raise (i.e. a function call in the middle of a block does not return or jump
+   to any except or finally block)
+TODO(mdan): Consider adding the edges above. They'd only add ~O(n) edges.
+TODO(mdan): Alternatively, consider adding an edge from try to all its excepts.
+"""
+
+# TODO(mdan): The notion of 'statements' below is inaccurate.
+# They should rather be called 'block statements', because they include
+# statements that may have a body, e.g. if and while.
+
+import collections
+import enum
+import weakref
+
+import astunparse
+import gast
+
+from tensorflow.python.autograph.pyct import anno
+
+
+class Node(object):
+  """A node in the CFG.
+
+  Although new instances of this class are mutable, the objects that a user
+  finds in the CFG are typically not.
+
+  The nodes represent edges in the CFG graph, and maintain pointers to allow
+  efficient walking in both forward and reverse order. The following property
+  holds for all nodes: "child in node.next" iff "node in child.prev".
+
+  Attributes:
+    next: FrozenSet[Node, ...], the nodes that follow this node, in control flow
+      order
+    prev: FrozenSet[Node, ...], the nodes that precede this node, in reverse
+      control flow order
+    ast_node: ast.AST, the AST node corresponding to this CFG node
+  """
+
+  def __init__(self, next_, prev, ast_node):
+    self.next = next_
+    self.prev = prev
+    self.ast_node = ast_node
+
+  def freeze(self):
+    self.next = frozenset(self.next)
+    # Assumption: All CFG nodes have identical life spans, because the graph
+    # owns them. Nodes should never be used outside the context of an existing
+    # graph.
+    self.prev = weakref.WeakSet(self.prev)
+
+  def __repr__(self):
+    if isinstance(self.ast_node, gast.FunctionDef):
+      return 'def %s' % self.ast_node.name
+    elif isinstance(self.ast_node, gast.ClassDef):
+      return 'class %s' % self.ast_node.name
+    elif isinstance(self.ast_node, gast.withitem):
+      # TODO(xjun): remove use of astunparse
+      return astunparse.unparse(self.ast_node.context_expr).strip()
+    return astunparse.unparse(self.ast_node).strip()
+
+
+class Graph(
+    collections.namedtuple(
+        'Graph',
+        ['entry', 'exit', 'error', 'index', 'stmt_prev', 'stmt_next'])):
+  """A Control Flow Graph.
+
+  The CFG maintains an index to allow looking up a CFG node by the AST node to
+  which it is associated. The index can also be enumerated in top-down, depth
+  first order.
+
+  Walking the graph in forward or reverse order is supported by double
+  parent-child links.
+
+  Note: the error nodes are not wired to their corresponding finally guards,
+  because these are shared, and wiring them would create a reverse path from
+  normal control flow into the error nodes, which we want to avoid.
+
+  The graph also maintains edges corresponding to higher level statements
+  like for-else loops. A node is considered successor of a statement if there
+  is an edge from a node that is lexically a child of that statement to a node
+  that is not. Statement predecessors are analogously defined.
+
+  Attributes:
+    entry: Node, the entry node
+    exit: FrozenSet[Node, ...], the exit nodes
+    error: FrozenSet[Node, ...], nodes that exit due to an explicitly raised
+      error (errors propagated from function calls are not accounted)
+    index: Dict[ast.Node, Node], mapping AST nodes to the respective CFG node
+    stmt_prev: Dict[ast.Node, FrozenSet[Node, ...]], mapping statement AST nodes
+      to their predecessor CFG nodes
+    stmt_next: Dict[ast.Node, FrozenSet[Node, ...]], mapping statement AST nodes
+      to their successor CFG nodes
+  """
+
+  def __repr__(self):
+    return self.as_dot()
+
+  def as_dot(self):
+    """Print CFG in DOT format."""
+    result = 'digraph CFG {\n'
+    for node in self.index.values():
+      result += '  %s [label="%s"];\n' % (id(node), node)
+    for node in self.index.values():
+      for next_ in node.next:
+        result += '  %s -> %s;\n' % (id(node), id(next_))
+    result += '}'
+    return result
+
+
+class _WalkMode(enum.Enum):
+  FORWARD = 1
+  REVERSE = 2
+
+
+# TODO(mdan): Rename to DataFlowAnalyzer.
+# TODO(mdan): Consider specializations that use gen/kill/transfer abstractions.
+class GraphVisitor(object):
+  """Base class for a CFG visitors.
+
+  This implementation is not thread safe.
+
+  The visitor has some facilities to simplify dataflow analyses. In particular,
+  it allows revisiting the nodes at the decision of the subclass. This can be
+  used to visit the graph until the state reaches a fixed point.
+
+  For more details on dataflow analysis, see
+  https://www.seas.harvard.edu/courses/cs252/2011sp/slides/Lec02-Dataflow.pdf
+
+  Note: the literature generally suggests visiting successor nodes only when the
+  state of the current node changed, regardless of whether that successor has
+  ever been visited. This implementation visits every successor at least once.
+
+  Attributes:
+    graph: Graph
+    in_: Dict[Node, Any], stores node-keyed state during a visit
+    out: Dict[Node, Any], stores node-keyed state during a visit
+  """
+
+  def __init__(self, graph):
+    self.graph = graph
+    self.reset()
+
+  def init_state(self, node):
+    """State initialization function.
+
+    Optional to overload.
+
+    An in/out state slot will be created for each node in the graph. Subclasses
+    must overload this to control what that is initialized to.
+
+    Args:
+      node: Node
+    """
+    raise NotImplementedError('Subclasses must implement this.')
+
+  # TODO(mdan): Rename to flow?
+  def visit_node(self, node):
+    """Visitor function.
+
+    Args:
+      node: Node
+
+    Returns:
+      bool, whether the node should be revisited; subclasses can visit every
+          reachable node exactly once by always returning False
+    """
+    raise NotImplementedError('Subclasses must implement this.')
+
+  def reset(self):
+    self.in_ = {
+        node: self.init_state(node) for node in self.graph.index.values()
+    }
+    self.out = {
+        node: self.init_state(node) for node in self.graph.index.values()
+    }
+
+  def can_ignore(self, node):
+    """Returns True if the node can safely be assumed not to touch variables."""
+    ast_node = node.ast_node
+    if anno.hasanno(ast_node, anno.Basic.SKIP_PROCESSING):
+      return True
+    return isinstance(ast_node,
+                      (gast.Break, gast.Continue, gast.Raise, gast.Pass))
+
+  def _visit_internal(self, mode):
+    """Visits the CFG, breadth-first."""
+    assert mode in (_WalkMode.FORWARD, _WalkMode.REVERSE)
+    if mode == _WalkMode.FORWARD:
+      open_ = [self.graph.entry]
+    elif mode == _WalkMode.REVERSE:
+      open_ = list(self.graph.exit)
+    closed = set()
+
+    while open_:
+      node = open_.pop(0)
+      closed.add(node)
+
+      should_revisit = self.visit_node(node)
+
+      if mode == _WalkMode.FORWARD:
+        children = node.next
+      elif mode == _WalkMode.REVERSE:
+        children = node.prev
+
+      for next_ in children:
+        if should_revisit or next_ not in closed:
+          open_.append(next_)
+
+  def visit_forward(self):
+    self._visit_internal(_WalkMode.FORWARD)
+
+  def visit_reverse(self):
+    self._visit_internal(_WalkMode.REVERSE)
+
+
+class GraphBuilder(object):
+  """Builder that constructs a CFG from a given AST.
+
+  This GraphBuilder facilitates constructing the DAG that forms the CFG when
+  nodes
+  are supplied in lexical order (i.e., top-down, depth first). Under these
+  conditions, it supports building patterns found in typical structured
+  programs.
+
+  This builder ignores the flow generated by exceptions, which are assumed to
+  always be catastrophic and present purely for diagnostic purposes (e.g. to
+  print debug information). Statements like raise and try/catch sections are
+  allowed and will generate control flow edges, but ordinary statements are
+  assumed not to raise exceptions.
+
+  Finally sections are also correctly interleaved between break/continue/return
+  nodes and their subsequent statements.
+
+  Important concepts:
+   * nodes - nodes refer to CFG nodes; AST nodes are qualified explicitly
+   * leaf set - since the graph is constructed gradually, a leaf set maintains
+     the CFG nodes that will precede the node that the builder expects to
+     receive next; when an ordinary node is added, it is connected to the
+     existing leaves and it in turn becomes the new leaf
+   * jump nodes - nodes that should generate edges other than what
+     ordinary nodes would; these correspond to break, continue and return
+     statements
+   * sections - logical delimiters for subgraphs that require special
+     edges; there are various types of nodes, each admitting various
+     types of jump nodes; sections are identified by their corresponding AST
+     node
+  """
+
+  # TODO(mdan): Perhaps detail this in a markdown doc.
+  # TODO(mdan): Add exception support.
+
+  def __init__(self, parent_ast_node):
+    self.reset()
+    self.parent = parent_ast_node
+
+  def reset(self):
+    """Resets the state of this factory."""
+    self.head = None
+    self.errors = set()
+    self.node_index = {}
+
+    # TODO(mdan): Too many primitives. Use classes.
+    self.leaves = set()
+
+    # Note: This mechanism requires that nodes are added in lexical order (top
+    # to bottom, depth first).
+    self.active_stmts = set()
+    self.owners = {}  # type: Set[any]
+    self.forward_edges = set()  # type: Tuple[Node, Node] # (from, to)
+
+    self.finally_sections = {}
+    # Dict values represent (entry, exits)
+    self.finally_section_subgraphs = {
+    }  # type: Dict[ast.AST, Tuple[Node, Set[Node]]]
+    # Whether the guard section can be reached from the statement that precedes
+    # it.
+    self.finally_section_has_direct_flow = {}
+    # Finally sections that await their first node.
+    self.pending_finally_sections = set()
+
+    # Exit jumps keyed by the section they affect.
+    self.exits = {}
+
+    # The entry of loop sections, keyed by the section.
+    self.section_entry = {}
+    # Continue jumps keyed by the section they affect.
+    self.continues = {}
+
+    # Raise jumps keyed by the except section guarding them.
+    self.raises = {}
+
+    # The entry of conditional sections, keyed by the section.
+    self.cond_entry = {}
+    # Lists of leaf nodes corresponding to each branch in the section.
+    self.cond_leaves = {}
+
+  def _connect_nodes(self, first, second):
+    """Connects nodes to signify that control flows from first to second.
+
+    Args:
+      first: Union[Set[Node, ...], Node]
+      second: Node
+    """
+    if isinstance(first, Node):
+      first.next.add(second)
+      second.prev.add(first)
+      self.forward_edges.add((first, second))
+    else:
+      for node in first:
+        self._connect_nodes(node, second)
+
+  def _add_new_node(self, ast_node):
+    """Grows the graph by adding a CFG node following the current leaves."""
+    if ast_node in self.node_index:
+      raise ValueError('%s added twice' % ast_node)
+    # Assumption: All CFG nodes have identical life spans, because the graph
+    # owns them. Nodes should never be used outside the context of an existing
+    # graph.
+    node = Node(next_=set(), prev=weakref.WeakSet(), ast_node=ast_node)
+    self.node_index[ast_node] = node
+    self.owners[node] = frozenset(self.active_stmts)
+
+    if self.head is None:
+      self.head = node
+
+    for leaf in self.leaves:
+      self._connect_nodes(leaf, node)
+
+    # If any finally section awaits its first node, populate it.
+    for section_id in self.pending_finally_sections:
+      self.finally_section_subgraphs[section_id][0] = node
+    self.pending_finally_sections = set()
+
+    return node
+
+  def begin_statement(self, stmt):
+    """Marks the beginning of a statement.
+
+    Args:
+      stmt: Hashable, a key by which the statement can be identified in the
+        CFG's stmt_prev and stmt_next attributes
+    """
+    self.active_stmts.add(stmt)
+
+  def end_statement(self, stmt):
+    """Marks the end of a statement.
+
+    Args:
+      stmt: Hashable, a key by which the statement can be identified in the
+        CFG's stmt_prev and stmt_next attributes; must match a key previously
+        passed to begin_statement.
+    """
+    self.active_stmts.remove(stmt)
+
+  def add_ordinary_node(self, ast_node):
+    """Grows the graph by adding an ordinary CFG node.
+
+    Ordinary nodes are followed by the next node, in lexical order, that is,
+    they become the new leaf set.
+
+    Args:
+      ast_node: ast.AST
+
+    Returns:
+      Node
+    """
+    node = self._add_new_node(ast_node)
+    self.leaves = set((node,))
+    return node
+
+  def _add_jump_node(self, ast_node, guards):
+    """Grows the graph by adding a jump node.
+
+    Jump nodes are added to the current leaf set, and the leaf set becomes
+    empty. If the jump node is the last in a cond section, then it may be added
+    back to the leaf set by a separate mechanism.
+
+    Args:
+      ast_node: ast.AST
+      guards: Tuple[ast.AST, ...], the finally sections active for this node
+
+    Returns:
+      Node
+    """
+    node = self._add_new_node(ast_node)
+    self.leaves = set()
+    # The guards themselves may not yet be complete, and will be wired later.
+    self.finally_sections[node] = guards
+    return node
+
+  def _connect_jump_to_finally_sections(self, node):
+    """Connects a jump node to the finally sections protecting it."""
+    cursor = set((node,))
+    if node not in self.finally_sections:
+      return cursor
+    for guard_section_id in self.finally_sections[node]:
+      guard_begin, guard_ends = self.finally_section_subgraphs[guard_section_id]
+      self._connect_nodes(cursor, guard_begin)
+      cursor = guard_ends
+    del self.finally_sections[node]
+    # TODO(mdan): Should garbage-collect finally_section_subgraphs.
+    return cursor
+
+  def add_exit_node(self, ast_node, section_id, guards):
+    """Grows the graph by adding an exit node.
+
+    This node becomes an exit for the current section.
+
+    Args:
+      ast_node: ast.AST
+      section_id: Hashable, the node for which ast_node should be considered to
+        be an exit node
+      guards: Tuple[ast.AST, ...], the finally sections that guard ast_node
+
+    Returns:
+      Node
+    """
+    node = self._add_jump_node(ast_node, guards)
+    self.exits[section_id].add(node)
+    return node
+
+  def add_continue_node(self, ast_node, section_id, guards):
+    """Grows the graph by adding a reentry node.
+
+    This node causes control flow to go back to the loop section's entry.
+
+    Args:
+      ast_node: ast.AST
+      section_id: Hashable, the node for which ast_node should be considered to
+        be an exit node
+      guards: Tuple[ast.AST, ...], the finally sections that guard ast_node
+    """
+    node = self._add_jump_node(ast_node, guards)
+    self.continues[section_id].add(node)
+
+  def connect_raise_node(self, node, except_guards):
+    """Adds extra connection between a raise node and containing except guards.
+
+    The node is a graph node, not an ast node.
+
+    Args:
+      node: Node
+      except_guards: Tuple[ast.AST, ...], the except sections that guard node
+    """
+    for guard in except_guards:
+      if guard in self.raises:
+        self.raises[guard].append(node)
+      else:
+        self.raises[guard] = [node]
+
+  def enter_section(self, section_id):
+    """Enters a regular section.
+
+    Regular sections admit exit jumps, which end the section.
+
+    Args:
+      section_id: Hashable, the same node that will be used in calls to the
+        ast_node arg passed to add_exit_node
+    """
+    assert section_id not in self.exits
+    self.exits[section_id] = set()
+
+  def exit_section(self, section_id):
+    """Exits a regular section."""
+
+    # Exits are jump nodes, which may be protected.
+    for exit_ in self.exits[section_id]:
+      self.leaves |= self._connect_jump_to_finally_sections(exit_)
+
+    del self.exits[section_id]
+
+  def enter_loop_section(self, section_id, entry_node):
+    """Enters a loop section.
+
+    Loop sections define an entry node. The end of the section always flows back
+    to the entry node. These admit continue jump nodes which also flow to the
+    entry node.
+
+    Args:
+      section_id: Hashable, the same node that will be used in calls to the
+        ast_node arg passed to add_continue_node
+      entry_node: ast.AST, the entry node into the loop (e.g. the test node for
+        while loops)
+    """
+    assert section_id not in self.section_entry
+    assert section_id not in self.continues
+    self.continues[section_id] = set()
+    node = self.add_ordinary_node(entry_node)
+    self.section_entry[section_id] = node
+
+  def exit_loop_section(self, section_id):
+    """Exits a loop section."""
+    self._connect_nodes(self.leaves, self.section_entry[section_id])
+
+    # continues are jump nodes, which may be protected.
+    for reentry in self.continues[section_id]:
+      guard_ends = self._connect_jump_to_finally_sections(reentry)
+      self._connect_nodes(guard_ends, self.section_entry[section_id])
+
+    # Loop nodes always loop back.
+    self.leaves = set((self.section_entry[section_id],))
+
+    del self.continues[section_id]
+    del self.section_entry[section_id]
+
+  def enter_cond_section(self, section_id):
+    """Enters a conditional section.
+
+    Conditional sections define an entry node, and one or more branches.
+
+    Args:
+      section_id: Hashable, the same node that will be used in calls to the
+        section_id arg passed to new_cond_branch
+    """
+
+    assert section_id not in self.cond_entry
+    assert section_id not in self.cond_leaves
+    self.cond_leaves[section_id] = []
+
+  def new_cond_branch(self, section_id):
+    """Begins a new branch in a cond section."""
+    assert section_id in self.cond_leaves
+
+    if section_id in self.cond_entry:
+      # Subsequent splits move back to the split point, and memorize the
+      # current leaves.
+      self.cond_leaves[section_id].append(self.leaves)
+      self.leaves = self.cond_entry[section_id]
+    else:
+      # If this is the first time we split a section, just remember the split
+      # point.
+      self.cond_entry[section_id] = self.leaves
+
+  def exit_cond_section(self, section_id):
+    """Exits a conditional section."""
+    for split in self.cond_leaves[section_id]:
+      self.leaves |= split
+    del self.cond_entry[section_id]
+    del self.cond_leaves[section_id]
+
+  def enter_except_section(self, section_id):
+    """Enters an except section."""
+    if section_id in self.raises:
+      self.leaves.update(self.raises[section_id])
+
+  def enter_finally_section(self, section_id):
+    """Enters a finally section."""
+    # TODO(mdan): This, not the caller, should track the active sections.
+    self.finally_section_subgraphs[section_id] = [None, None]
+    if self.leaves:
+      self.finally_section_has_direct_flow[section_id] = True
+    else:
+      self.finally_section_has_direct_flow[section_id] = False
+    self.pending_finally_sections.add(section_id)
+
+  def exit_finally_section(self, section_id):
+    """Exits a finally section."""
+    assert section_id not in self.pending_finally_sections, 'Empty finally?'
+    self.finally_section_subgraphs[section_id][1] = self.leaves
+    # If the guard can only be reached by a jump, then it will not flow
+    # into the statement that follows it.
+    if not self.finally_section_has_direct_flow[section_id]:
+      self.leaves = set()
+    del self.finally_section_has_direct_flow[section_id]
+
+  def build(self):
+    """Returns the CFG accumulated so far and resets the builder.
+
+    Returns:
+      Graph
+    """
+    # Freeze the nodes.
+    for node in self.node_index.values():
+      node.freeze()
+
+    # Build the statement edges.
+    stmt_next = {}
+    stmt_prev = {}
+
+    for node in self.node_index.values():
+      for stmt in self.owners[node]:
+        if stmt not in stmt_prev:
+          stmt_prev[stmt] = set()
+        if stmt not in stmt_next:
+          stmt_next[stmt] = set()
+
+    for first, second in self.forward_edges:
+      stmts_exited = self.owners[first] - self.owners[second]
+      for stmt in stmts_exited:
+        stmt_next[stmt].add(second)
+      stmts_entered = self.owners[second] - self.owners[first]
+      for stmt in stmts_entered:
+        stmt_prev[stmt].add(first)
+    for stmt in stmt_next:
+      stmt_next[stmt] = frozenset(stmt_next[stmt])
+    for stmt in stmt_prev:
+      stmt_prev[stmt] = frozenset(stmt_prev[stmt])
+
+    # Construct the final graph object.
+    result = Graph(
+        entry=self.head,
+        exit=self.leaves,
+        error=self.errors,
+        index=self.node_index,
+        stmt_prev=stmt_prev,
+        stmt_next=stmt_next)
+
+    # Reset the state.
+    self.reset()
+
+    return result
+
+
+class AstToCfg(gast.NodeVisitor):
+  """Converts an AST to CFGs.
+
+  A separate CFG will be constructed for each function.
+  """
+
+  def __init__(self):
+    super(AstToCfg, self).__init__()
+
+    self.builder_stack = []
+    self.builder = None
+    self.cfgs = {}
+
+    self.lexical_scopes = []
+
+  def _enter_lexical_scope(self, node):
+    self.lexical_scopes.append(node)
+
+  def _exit_lexical_scope(self, node):
+    leaving_node = self.lexical_scopes.pop()
+    assert node == leaving_node
+
+  def _get_enclosing_finally_scopes(self, stop_at):
+    included = []
+    for node in reversed(self.lexical_scopes):
+      if isinstance(node, gast.Try) and node.finalbody:
+        included.append(node)
+      if isinstance(node, stop_at):
+        return node, included
+    return None, included
+
+  def _get_enclosing_except_scopes(self, stop_at):
+    included = []
+    for node in reversed(self.lexical_scopes):
+      if isinstance(node, gast.Try) and node.handlers:
+        included.extend(node.handlers)
+      if isinstance(node, stop_at):
+        break
+    return included
+
+  def _process_basic_statement(self, node):
+    self.generic_visit(node)
+    self.builder.add_ordinary_node(node)
+
+  def _process_exit_statement(self,
+                              node,
+                              exits_nodes_of_type,
+                              may_exit_via_except=False):
+    self.generic_visit(node)
+    # Note: this is safe because we process functions separately.
+    try_node, guards = self._get_enclosing_finally_scopes(exits_nodes_of_type)
+    assert try_node is not None, '{} that is not enclosed by any of {}'.format(
+        node, exits_nodes_of_type)
+
+    node = self.builder.add_exit_node(node, try_node, guards)
+
+    if may_exit_via_except:
+      except_guards = self._get_enclosing_except_scopes(exits_nodes_of_type)
+      self.builder.connect_raise_node(node, except_guards)
+
+  def _process_continue_statement(self, node, *loops_to_nodes_of_type):
+    # Note: this is safe because we process functions separately.
+    try_node, guards = self._get_enclosing_finally_scopes(
+        tuple(loops_to_nodes_of_type))
+    if try_node is None:
+      raise ValueError('%s that is not enclosed by any of %s' %
+                       (node, loops_to_nodes_of_type))
+    self.builder.add_continue_node(node, try_node, guards)
+
+  def visit_ClassDef(self, node):
+    # We also keep the ClassDef node in the CFG, since it technically is a
+    # statement.
+    # For example, this is legal and allows executing user code:
+    #
+    #   class Foo(bar()):
+    #     pass
+    #
+    # It also has a scope:
+    #
+    #   class Bar(object):
+    #     a = 1
+    if self.builder is None:
+      self.generic_visit(node)
+      return
+
+    self.builder.add_ordinary_node(node)
+
+    self.builder_stack.append(self.builder)
+    self.builder = GraphBuilder(node)
+    self._enter_lexical_scope(node)
+
+    self._process_basic_statement(node)
+
+    self._exit_lexical_scope(node)
+    # TODO(mdan): Track the CFG local to the class definition as well?
+    self.builder = self.builder_stack.pop()
+
+  def _process_function_def(self, node, is_lambda):
+    # The function body is stored in a separate graph, because function
+    # definitions have effects very different from function calls.
+    if self.builder is not None:
+      self.builder.add_ordinary_node(node)
+
+    self.builder_stack.append(self.builder)
+    self.builder = GraphBuilder(node)
+
+    self._enter_lexical_scope(node)
+    self.builder.enter_section(node)
+
+    self._process_basic_statement(node.args)
+    if is_lambda:
+      self._process_exit_statement(node.body, (gast.Lambda,))
+    else:
+      for stmt in node.body:
+        self.visit(stmt)
+
+    self.builder.exit_section(node)
+    self._exit_lexical_scope(node)
+
+    self.cfgs[node] = self.builder.build()
+    self.builder = self.builder_stack.pop()
+
+  def visit_FunctionDef(self, node):
+    self._process_function_def(node, is_lambda=False)
+
+  def visit_Lambda(self, node):
+    self._process_function_def(node, is_lambda=True)
+
+  def visit_Return(self, node):
+    self._process_exit_statement(node, (gast.FunctionDef,))
+
+  def visit_Import(self, node):
+    self._process_basic_statement(node)
+
+  def visit_ImportFrom(self, node):
+    self._process_basic_statement(node)
+
+  def visit_Expr(self, node):
+    self._process_basic_statement(node)
+
+  def visit_NamedExpr(self, node):
+    # TODO(yileiyang): Add a test case once we have a newer astunparse version.
+    # NamedExpr was introduced in Python 3.8 and supported in gast 0.5.1+.
+    self._process_basic_statement(node)
+
+  def visit_Assign(self, node):
+    self._process_basic_statement(node)
+
+  def visit_AnnAssign(self, node):
+    self._process_basic_statement(node)
+
+  def visit_AugAssign(self, node):
+    self._process_basic_statement(node)
+
+  def visit_Pass(self, node):
+    self._process_basic_statement(node)
+
+  def visit_Global(self, node):
+    self._process_basic_statement(node)
+
+  def visit_Nonlocal(self, node):
+    self._process_basic_statement(node)
+
+  def visit_Print(self, node):
+    self._process_basic_statement(node)
+
+  def visit_Raise(self, node):
+    self._process_exit_statement(
+        node, (gast.FunctionDef,), may_exit_via_except=True)
+    self.builder.errors.add(node)
+
+  def visit_Assert(self, node):
+    # Ignoring the effect of exceptions.
+    self._process_basic_statement(node)
+
+  def visit_Delete(self, node):
+    self._process_basic_statement(node)
+
+  def visit_If(self, node):
+    # No need to track ifs as lexical scopes, for now.
+    # Lexical scopes are generally tracked in order to be able to resolve the
+    # targets of jump statements like break/continue/etc. Since there is no
+    # statement that can interrupt a conditional, we don't need to track their
+    # lexical scope. That may change in the future.
+    self.builder.begin_statement(node)
+
+    self.builder.enter_cond_section(node)
+    self._process_basic_statement(node.test)
+
+    self.builder.new_cond_branch(node)
+    for stmt in node.body:
+      self.visit(stmt)
+
+    self.builder.new_cond_branch(node)
+    for stmt in node.orelse:
+      self.visit(stmt)
+
+    self.builder.exit_cond_section(node)
+    self.builder.end_statement(node)
+
+  def visit_While(self, node):
+    self.builder.begin_statement(node)
+    self._enter_lexical_scope(node)
+
+    self.builder.enter_section(node)
+
+    self.generic_visit(node.test)
+    self.builder.enter_loop_section(node, node.test)
+    for stmt in node.body:
+      self.visit(stmt)
+    self.builder.exit_loop_section(node)
+
+    # Note: although the orelse is technically part of the loop node,
+    # the statements inside it don't affect the loop itself. For example, a
+    # break in the loop's orelse will not affect the loop itself.
+    self._exit_lexical_scope(node)
+
+    for stmt in node.orelse:
+      self.visit(stmt)
+
+    self.builder.exit_section(node)
+    self.builder.end_statement(node)
+
+  def visit_For(self, node):
+    self.builder.begin_statement(node)
+    self._enter_lexical_scope(node)
+
+    self.builder.enter_section(node)
+
+    # Note: Strictly speaking, this should be node.target + node.iter.
+    # However, the activity analysis accounts for this inconsistency,
+    # so dataflow analysis produces the correct values.
+    self.generic_visit(node.iter)
+    self.builder.enter_loop_section(node, node.iter)
+    # Also include the "extra loop test" annotation, to capture things like the
+    # control variable for return and break in for loops.
+    if anno.hasanno(node, anno.Basic.EXTRA_LOOP_TEST):
+      self._process_basic_statement(
+          anno.getanno(node, anno.Basic.EXTRA_LOOP_TEST))
+    for stmt in node.body:
+      self.visit(stmt)
+    self.builder.exit_loop_section(node)
+
+    # Note: although the orelse is technically part of the loop node,
+    # they don't count as loop bodies.  For example, a break in the loop's
+    # orelse will affect the parent loop, not the current one.
+    self._exit_lexical_scope(node)
+
+    for stmt in node.orelse:
+      self.visit(stmt)
+
+    self.builder.exit_section(node)
+    self.builder.end_statement(node)
+
+  def visit_Break(self, node):
+    self._process_exit_statement(node, (
+        gast.While,
+        gast.For,
+    ))
+
+  def visit_Continue(self, node):
+    self._process_continue_statement(node, (
+        gast.While,
+        gast.For,
+    ))
+
+  def visit_ExceptHandler(self, node):
+    self.builder.begin_statement(node)
+    self.builder.enter_except_section(node)
+
+    if node.type is not None:
+      self.visit(node.type)
+    if node.name is not None:
+      self.visit(node.name)
+
+    for stmt in node.body:
+      self.visit(stmt)
+
+    self.builder.end_statement(node)
+
+  def visit_Try(self, node):
+    self.builder.begin_statement(node)
+    self._enter_lexical_scope(node)
+
+    # Note: the current simplification is that the try block fully executes
+    # regardless of whether an exception triggers or not. This is consistent
+    # with blocks free of try/except, which also don't account for the
+    # possibility of an exception being raised mid-block.
+
+    for stmt in node.body:
+      self.visit(stmt)
+    # The orelse is an optional continuation of the body.
+    if node.orelse:
+      block_representative = node.orelse[0]
+      self.builder.enter_cond_section(block_representative)
+      self.builder.new_cond_branch(block_representative)
+      for stmt in node.orelse:
+        self.visit(stmt)
+      self.builder.new_cond_branch(block_representative)
+      self.builder.exit_cond_section(block_representative)
+
+    self._exit_lexical_scope(node)
+
+    if node.handlers:
+      # Using node would be inconsistent. Using the first handler node is also
+      # inconsistent, but less so.
+      block_representative = node.handlers[0]
+      self.builder.enter_cond_section(block_representative)
+      for block in node.handlers:
+        self.builder.new_cond_branch(block_representative)
+        self.visit(block)
+      self.builder.new_cond_branch(block_representative)
+      self.builder.exit_cond_section(block_representative)
+
+    if node.finalbody:
+      self.builder.enter_finally_section(node)
+      for stmt in node.finalbody:
+        self.visit(stmt)
+      self.builder.exit_finally_section(node)
+
+    self.builder.end_statement(node)
+
+  def visit_With(self, node):
+    # TODO(mdan): Mark the context manager's exit call as exit guard.
+    for item in node.items:
+      self._process_basic_statement(item)
+    for stmt in node.body:
+      self.visit(stmt)
+
+
+def build(node):
+  visitor = AstToCfg()
+  visitor.visit(node)
+  return visitor.cfgs

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/error_utils.py

@@ -0,0 +1,230 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Code transformation exceptions."""
+
+import collections
+
+from tensorflow.python.autograph.pyct import origin_info
+from tensorflow.python.util import traceback_utils
+
+
+class FrameInfo(
+    collections.namedtuple('FrameInfo',
+                           ('filename', 'lineno', 'function_name', 'code',
+                            'is_converted', 'is_allowlisted'))):
+
+  __slots__ = ()
+
+
+def _stack_trace_inside_mapped_code(tb, source_map, converter_filename):
+  """Summarizes inner traceback frames up to the call to a given function.
+
+  This functions locates the innermost (i.e. most recent) frame that corresponds
+  to code that can be mapped by source_map originated from, and returns a
+  translated stack trace ending at that frame. If no such frame is found, the
+  entire stack trace is summarized.
+
+  For example, the following code:
+
+    def f():
+      for i in tf.range(1):
+        z = y + i  # z only defined here
+
+  Would generate this traceback:
+
+    <converted code>
+        ag__.for_stmt(...)
+    <for_stmt>
+        return _known_len_tf_for_stmt(iter_, extra_test, body, init_state)
+    <_known_len_tf_for_stmt>
+        _disallow_undefs_into_loop(*init_state)
+    <_disallow_undefs_into_loop>
+        raise ...
+
+  Which is then processed into:
+
+    <f>
+        for i in tf.range(1):
+    <for_stmt>
+        return _known_len_tf_for_stmt(iter_, extra_test, body, init_state)
+    <_known_len_tf_for_stmt>
+        _disallow_undefs_into_loop(*init_state)
+    <_disallow_undefs_into_loop>
+        raise ...
+
+  Args:
+    tb: traceback.FrameSummary, The traceback corresponding to an error.
+      Typically, the output of traceback.Summary.extract(capture_locals=True).
+    source_map: Dict[LineLocation, OriginInfo], a source map as created by
+      origin_info.create_source_map.
+    converter_filename: str, the file path of the converted module. Call frames
+      corresponding to this module are elided and their preceding frames are
+      marked as allowlisted. Note that frames enclosing converted code are
+      dropped using a different mechanism.
+
+  Returns:
+    List[FrameInfo]
+  """
+  result_frames = []
+  for filename, line_number, function_name, text in reversed(tb):
+
+    loc = origin_info.LineLocation(filename=filename, lineno=line_number)
+    if loc in source_map:
+      origin = source_map[loc]
+      fi = FrameInfo(
+          filename=origin.loc.filename,
+          lineno=origin.loc.lineno,
+          function_name=origin.function_name,
+          code=origin.source_code_line,
+          is_converted=True,
+          is_allowlisted=False)
+      result_frames.append(fi)
+      break
+
+    if filename == converter_filename:
+      if result_frames:
+        prev = result_frames[-1]
+        assert not prev.is_converted  # See the if above.
+        fi = FrameInfo(
+            filename=prev.filename,
+            lineno=prev.lineno,
+            function_name=prev.function_name,
+            code=prev.code,
+            is_converted=False,
+            is_allowlisted=True)
+        result_frames[-1] = fi
+      continue
+
+    fi = FrameInfo(
+        filename=filename,
+        lineno=line_number,
+        function_name=function_name,
+        code=text,
+        is_converted=False,
+        is_allowlisted=False)
+    result_frames.append(fi)
+
+  return tuple(result_frames)
+
+
+KNOWN_STRING_CONSTRUCTOR_ERRORS = (
+    AssertionError,
+    AttributeError,
+    NameError,
+    NotImplementedError,
+    RuntimeError,
+    StopIteration,
+    TypeError,
+    UnboundLocalError,
+    ValueError,
+)
+
+
+# KeyError escapes newlines in strings. We create a special subclass
+# that doesn't do that. Overriding the name for display purposes; hopefully
+# that won't create too many surprises.
+class MultilineMessageKeyError(KeyError):
+
+  def __init__(self, message, original_key):
+    super(MultilineMessageKeyError, self).__init__(original_key)
+    self.__message = message
+
+  def __str__(self):
+    return self.__message
+
+MultilineMessageKeyError.__name__ = KeyError.__name__
+
+
+class ErrorMetadataBase(object):
+  """Container objects attached to exceptions raised in user code.
+
+  This metadata allows re-raising exceptions that occur in generated code, with
+  a custom error message that includes a stack trace relative to user-readable
+  code from which the generated code originated.
+  """
+
+  __slots__ = ('translated_stack', 'cause_message')
+
+  def __init__(self, callsite_tb, cause_metadata, cause_message, source_map,
+               converter_filename):
+    translated_stack = _stack_trace_inside_mapped_code(
+        callsite_tb, source_map, converter_filename)
+
+    if cause_metadata is None:
+      self.translated_stack = translated_stack
+      self.cause_message = cause_message
+    else:
+      # Daisy chain the translated stacks.
+      self.translated_stack = (
+          cause_metadata.translated_stack + (translated_stack[-1],))
+      self.cause_message = cause_metadata.cause_message
+
+  def get_message(self):
+    """Returns the message for the underlying exception."""
+    lines = []
+
+    lines.append('in user code:')
+    lines.append('')
+
+    for frame_info in reversed(self.translated_stack):
+      if (traceback_utils.is_traceback_filtering_enabled() and
+          not traceback_utils.include_frame(frame_info.filename)):
+        continue
+
+      # Same format with Python traceback.
+      formatted_line = (f'    File "{frame_info.filename}", line '
+                        f'{frame_info.lineno}, in {frame_info.function_name}')
+      if frame_info.is_converted:
+        formatted_line += '  *'
+      elif frame_info.is_allowlisted:
+        formatted_line += '  **'
+      lines.append(formatted_line)
+
+      if frame_info.code is None:
+        code_snippet = '<source unavailable>'
+      else:
+        code_snippet = frame_info.code.strip()
+      lines.append('        {}'.format(code_snippet))
+
+    lines.append('')
+
+    message_lines = self.cause_message.split('\n')
+    for i in range(len(message_lines)):
+      message_lines[i] = '    ' + message_lines[i]
+    lines.extend(message_lines)
+
+    lines.append('')
+
+    return '\n'.join(lines)
+
+  def create_exception(self, source_error):
+    """Creates exception from source_error."""
+    preferred_type = type(source_error)
+    to_ret = None
+    if preferred_type.__init__ is Exception.__init__:
+      to_ret = preferred_type(self.get_message())
+    if preferred_type in KNOWN_STRING_CONSTRUCTOR_ERRORS:
+      to_ret = preferred_type(self.get_message())
+    elif preferred_type is KeyError:
+      to_ret = MultilineMessageKeyError(self.get_message(), self.cause_message)
+
+    if to_ret is not None:
+      return to_ret.with_traceback(source_error.__traceback__)
+
+  def to_exception(self, source_error):
+    exc = self.create_exception(source_error)
+    exc.__suppress_context__ = True
+    exc.ag_error_metadata = self
+    return exc

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/errors.py

@@ -0,0 +1,27 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Code transformation exceptions."""
+
+
+class PyCTError(Exception):
+  """Base class for all exceptions."""
+
+
+class UnsupportedLanguageElementError(PyCTError, NotImplementedError):
+  """Raised for code patterns that AutoGraph does not support."""
+
+
+class InaccessibleSourceCodeError(PyCTError, ValueError):
+  """Raised when inspect can not access source code."""

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/gast_util.py

@@ -0,0 +1,74 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Gast compatibility library. Supports 0.2.2 and 0.3.2."""
+# TODO(mdan): Remove this file once it's safe to break compatibility.
+
+import functools
+
+import gast
+
+
+GAST2 = hasattr(gast, 'Str')
+GAST3 = not GAST2
+
+
+def _is_constant_gast_2(node):
+  return isinstance(node, (gast.Num, gast.Str, gast.Bytes, gast.Ellipsis,
+                           gast.NameConstant))
+
+
+def _is_constant_gast_3(node):
+  return isinstance(node, gast.Constant)
+
+
+def is_literal(node):
+  """Tests whether node represents a Python literal."""
+  # Normal literals, True/False/None/Etc. in Python3
+  if is_constant(node):
+    return True
+
+  # True/False/None/Etc. in Python2
+  if isinstance(node, gast.Name) and node.id in ['True', 'False', 'None']:
+    return True
+
+  return False
+
+
+def _is_ellipsis_gast_2(node):
+  return isinstance(node, gast.Ellipsis)
+
+
+def _is_ellipsis_gast_3(node):
+  return isinstance(node, gast.Constant) and node.value == Ellipsis
+
+
+if GAST2:
+  is_constant = _is_constant_gast_2
+  is_ellipsis = _is_ellipsis_gast_2
+
+  Module = gast.Module
+  Name = gast.Name
+  Str = gast.Str
+
+elif GAST3:
+  is_constant = _is_constant_gast_3
+  is_ellipsis = _is_ellipsis_gast_3
+
+  Module = functools.partial(gast.Module, type_ignores=None)  # pylint:disable=invalid-name
+  Name = functools.partial(gast.Name, type_comment=None)  # pylint:disable=invalid-name
+  Str = functools.partial(gast.Constant, kind=None)  # pylint:disable=invalid-name
+
+else:
+  assert False

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/inspect_utils.py

@@ -0,0 +1,321 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Live entity inspection utilities.
+
+This module contains whatever inspect doesn't offer out of the box.
+"""
+
+import builtins
+import inspect
+import itertools
+import linecache
+import sys
+import threading
+import types
+
+from tensorflow.python.util import tf_inspect
+
+# This lock seems to help avoid linecache concurrency errors.
+_linecache_lock = threading.Lock()
+
+# Cache all the builtin elements in a frozen set for faster lookup.
+_BUILTIN_FUNCTION_IDS = frozenset(id(v) for v in builtins.__dict__.values())
+
+
+def islambda(f):
+  if not tf_inspect.isfunction(f):
+    return False
+  # TODO(mdan): Look into checking the only the code object.
+  if not (hasattr(f, '__name__') and hasattr(f, '__code__')):
+    return False
+  # Some wrappers can rename the function, but changing the name of the
+  # code object is harder.
+  return ((f.__name__ == '<lambda>') or (f.__code__.co_name == '<lambda>'))
+
+
+def isnamedtuple(f):
+  """Returns True if the argument is a namedtuple-like."""
+  if not (tf_inspect.isclass(f) and issubclass(f, tuple)):
+    return False
+  if not hasattr(f, '_fields'):
+    return False
+  fields = getattr(f, '_fields')
+  if not isinstance(fields, tuple):
+    return False
+  if not all(isinstance(f, str) for f in fields):
+    return False
+  return True
+
+
+def isbuiltin(f):
+  """Returns True if the argument is a built-in function."""
+  if id(f) in _BUILTIN_FUNCTION_IDS:
+    return True
+  elif isinstance(f, types.BuiltinFunctionType):
+    return True
+  elif inspect.isbuiltin(f):
+    return True
+  elif f is eval:
+    return True
+  else:
+    return False
+
+
+def isconstructor(cls):
+  """Returns True if the argument is an object constructor.
+
+  In general, any object of type class is a constructor, with the exception
+  of classes created using a callable metaclass.
+  See below for why a callable metaclass is not a trivial combination:
+  https://docs.python.org/2.7/reference/datamodel.html#customizing-class-creation
+
+  Args:
+    cls: Any
+
+  Returns:
+    Bool
+  """
+  return (inspect.isclass(cls) and
+          not (issubclass(cls.__class__, type) and
+               hasattr(cls.__class__, '__call__') and
+               cls.__class__.__call__ is not type.__call__))
+
+
+def _fix_linecache_record(obj):
+  """Fixes potential corruption of linecache in the presence of functools.wraps.
+
+  functools.wraps modifies the target object's __module__ field, which seems
+  to confuse linecache in special instances, for example when the source is
+  loaded from a .par file (see https://google.github.io/subpar/subpar.html).
+
+  This function simply triggers a call to linecache.updatecache when a mismatch
+  was detected between the object's __module__ property and the object's source
+  file.
+
+  Args:
+    obj: Any
+  """
+  if hasattr(obj, '__module__'):
+    obj_file = inspect.getfile(obj)
+    obj_module = obj.__module__
+
+    # A snapshot of the loaded modules helps avoid "dict changed size during
+    # iteration" errors.
+    loaded_modules = tuple(sys.modules.values())
+    for m in loaded_modules:
+      if hasattr(m, '__file__') and m.__file__ == obj_file:
+        if obj_module is not m:
+          linecache.updatecache(obj_file, m.__dict__)
+
+
+def getimmediatesource(obj):
+  """A variant of inspect.getsource that ignores the __wrapped__ property."""
+  with _linecache_lock:
+    _fix_linecache_record(obj)
+    lines, lnum = inspect.findsource(obj)
+    return ''.join(inspect.getblock(lines[lnum:]))
+
+
+def getnamespace(f):
+  """Returns the complete namespace of a function.
+
+  Namespace is defined here as the mapping of all non-local variables to values.
+  This includes the globals and the closure variables. Note that this captures
+  the entire globals collection of the function, and may contain extra symbols
+  that it does not actually use.
+
+  Args:
+    f: User defined function.
+
+  Returns:
+    A dict mapping symbol names to values.
+  """
+  namespace = dict(f.__globals__)
+  closure = f.__closure__
+  freevars = f.__code__.co_freevars
+  if freevars and closure:
+    for name, cell in zip(freevars, closure):
+      try:
+        namespace[name] = cell.cell_contents
+      except ValueError:
+        # Cell contains undefined variable, omit it from the namespace.
+        pass
+  return namespace
+
+
+def getqualifiedname(namespace, object_, max_depth=5, visited=None):
+  """Returns the name by which a value can be referred to in a given namespace.
+
+  If the object defines a parent module, the function attempts to use it to
+  locate the object.
+
+  This function will recurse inside modules, but it will not search objects for
+  attributes. The recursion depth is controlled by max_depth.
+
+  Args:
+    namespace: Dict[str, Any], the namespace to search into.
+    object_: Any, the value to search.
+    max_depth: Optional[int], a limit to the recursion depth when searching
+      inside modules.
+    visited: Optional[Set[int]], ID of modules to avoid visiting.
+  Returns: Union[str, None], the fully-qualified name that resolves to the value
+    o, or None if it couldn't be found.
+  """
+  if visited is None:
+    visited = set()
+
+  # Copy the dict to avoid "changed size error" during concurrent invocations.
+  # TODO(mdan): This is on the hot path. Can we avoid the copy?
+  namespace = dict(namespace)
+
+  for name in namespace:
+    # The value may be referenced by more than one symbol, case in which
+    # any symbol will be fine. If the program contains symbol aliases that
+    # change over time, this may capture a symbol that will later point to
+    # something else.
+    # TODO(mdan): Prefer the symbol that matches the value type name.
+    if object_ is namespace[name]:
+      return name
+
+  # If an object is not found, try to search its parent modules.
+  parent = tf_inspect.getmodule(object_)
+  if (parent is not None and parent is not object_ and parent is not namespace):
+    # No limit to recursion depth because of the guard above.
+    parent_name = getqualifiedname(
+        namespace, parent, max_depth=0, visited=visited)
+    if parent_name is not None:
+      name_in_parent = getqualifiedname(
+          parent.__dict__, object_, max_depth=0, visited=visited)
+      assert name_in_parent is not None, (
+          'An object should always be found in its owner module')
+      return '{}.{}'.format(parent_name, name_in_parent)
+
+  if max_depth:
+    # Iterating over a copy prevents "changed size due to iteration" errors.
+    # It's unclear why those occur - suspecting new modules may load during
+    # iteration.
+    for name in namespace.keys():
+      value = namespace[name]
+      if tf_inspect.ismodule(value) and id(value) not in visited:
+        visited.add(id(value))
+        name_in_module = getqualifiedname(value.__dict__, object_,
+                                          max_depth - 1, visited)
+        if name_in_module is not None:
+          return '{}.{}'.format(name, name_in_module)
+  return None
+
+
+def getdefiningclass(m, owner_class):
+  """Resolves the class (e.g. one of the superclasses) that defined a method."""
+  method_name = m.__name__
+  for super_class in inspect.getmro(owner_class):
+    if ((hasattr(super_class, '__dict__') and
+         method_name in super_class.__dict__) or
+        (hasattr(super_class, '__slots__') and
+         method_name in super_class.__slots__)):
+      return super_class
+  return owner_class
+
+
+def getmethodclass(m):
+  """Resolves a function's owner, e.g.
+
+  a method's class.
+
+  Note that this returns the object that the function was retrieved from, not
+  necessarily the class where it was defined.
+
+  This function relies on Python stack frame support in the interpreter, and
+  has the same limitations that inspect.currentframe.
+
+  Limitations. This function will only work correctly if the owned class is
+  visible in the caller's global or local variables.
+
+  Args:
+    m: A user defined function
+
+  Returns:
+    The class that this function was retrieved from, or None if the function
+    is not an object or class method, or the class that owns the object or
+    method is not visible to m.
+
+  Raises:
+    ValueError: if the class could not be resolved for any unexpected reason.
+  """
+
+  # Callable objects: return their own class.
+  if (not hasattr(m, '__name__') and hasattr(m, '__class__') and
+      hasattr(m, '__call__')):
+    if isinstance(m.__class__, type):
+      return m.__class__
+
+  # Instance and class: return the class of "self".
+  m_self = getattr(m, '__self__', None)
+  if m_self is not None:
+    if inspect.isclass(m_self):
+      return m_self
+    return m_self.__class__
+
+  # Class, static and unbound methods: search all defined classes in any
+  # namespace. This is inefficient but more robust a method.
+  owners = []
+  caller_frame = tf_inspect.currentframe().f_back
+  try:
+    # TODO(mdan): This doesn't consider cell variables.
+    # TODO(mdan): This won't work if the owner is hidden inside a container.
+    # Cell variables may be pulled using co_freevars and the closure.
+    for v in itertools.chain(caller_frame.f_locals.values(),
+                             caller_frame.f_globals.values()):
+      if hasattr(v, m.__name__):
+        candidate = getattr(v, m.__name__)
+        # Py2 methods may be bound or unbound, extract im_func to get the
+        # underlying function.
+        if hasattr(candidate, 'im_func'):
+          candidate = candidate.im_func
+        if hasattr(m, 'im_func'):
+          m = m.im_func
+        if candidate is m:
+          owners.append(v)
+  finally:
+    del caller_frame
+
+  if owners:
+    if len(owners) == 1:
+      return owners[0]
+
+    # If multiple owners are found, and are not subclasses, raise an error.
+    owner_types = tuple(o if tf_inspect.isclass(o) else type(o) for o in owners)
+    for o in owner_types:
+      if tf_inspect.isclass(o) and issubclass(o, tuple(owner_types)):
+        return o
+    raise ValueError('Found too many owners of %s: %s' % (m, owners))
+
+  return None
+
+
+def getfutureimports(entity):
+  """Detects what future imports are necessary to safely execute entity source.
+
+  Args:
+    entity: Any object
+
+  Returns:
+    A tuple of future strings
+  """
+  if not (tf_inspect.isfunction(entity) or tf_inspect.ismethod(entity)):
+    return tuple()
+  return tuple(
+      sorted(name for name, value in entity.__globals__.items()
+             if getattr(value, '__module__', None) == '__future__'))

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/loader.py

@@ -0,0 +1,102 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Converting AST to code and Python entities.
+
+Adapted from Tangent.
+"""
+
+import atexit
+import errno
+import importlib
+import os
+import sys
+import tempfile
+
+from tensorflow.python.autograph.pyct import origin_info
+from tensorflow.python.autograph.pyct import parser
+
+
+def _remove_file(file_name):
+  """Remove a file, if it exists."""
+  try:
+    os.remove(file_name)
+  except OSError as e:
+    if e.errno == errno.ENOENT:
+      # The file disappeared. Ignore this. Temporary files might get
+      # cleaned up, especially if they reside in /tmp.
+      pass
+    else:
+      raise
+
+
+def load_source(source, delete_on_exit):
+  """Loads the given source code as a Python module."""
+  with tempfile.NamedTemporaryFile(
+      mode='w',
+      suffix='.py',
+      prefix='__autograph_generated_file',
+      delete=False,
+      encoding='utf-8') as f:
+    module_name = os.path.basename(f.name[:-3])
+    file_name = f.name
+    f.write(source)
+
+  if delete_on_exit:
+    atexit.register(lambda: _remove_file(file_name))
+
+  spec = importlib.util.spec_from_file_location(module_name, file_name)
+  module = importlib.util.module_from_spec(spec)
+  spec.loader.exec_module(module)
+  # TODO(mdan): Use our own garbage-collected cache instead of sys.modules.
+  sys.modules[module_name] = module
+  return module, file_name
+
+
+def load_ast(nodes,
+             indentation='  ',
+             include_source_map=False,
+             delete_on_exit=True):
+  """Loads the given AST as a Python module.
+
+  Compiling the AST code this way ensures that the source code is readable by
+  e.g. `pdb` or `inspect`.
+
+  Args:
+    nodes: Union[ast.AST, Iterable[ast.AST]], the code to compile, as an AST
+      object.
+    indentation: Text, the string to use for indentation.
+    include_source_map: bool, whether return a source map.
+    delete_on_exit: bool, whether to delete the temporary file used for
+      compilation on exit.
+
+  Returns:
+    Tuple[module, Text, Dict[LineLocation, OriginInfo]], containing:
+    the module containing the unparsed nodes, the source code corresponding to
+    nodes, and the source map. Is include_source_map is False, the source map
+    will be None.
+  """
+  if not isinstance(nodes, (list, tuple)):
+    nodes = (nodes,)
+
+  source = parser.unparse(nodes, indentation=indentation)
+  module, _ = load_source(source, delete_on_exit)
+
+  if include_source_map:
+    source_map = origin_info.create_source_map(nodes, source, module.__file__)
+  else:
+    source_map = None
+
+  # TODO(mdan): Return a structured object.
+  return module, source, source_map

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/naming.py

@@ -0,0 +1,53 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Symbol naming utilities."""
+
+from tensorflow.python.autograph.pyct import qual_names
+
+
+class Namer(object):
+  """Symbol name generator."""
+
+  def __init__(self, global_namespace):
+    self.global_namespace = global_namespace
+    self.generated_names = set()
+
+  def new_symbol(self, name_root, reserved_locals):
+    """See control_flow.SymbolNamer.new_symbol."""
+    # reserved_locals may contain QNs.
+    all_reserved_locals = set()
+    for s in reserved_locals:
+      if isinstance(s, qual_names.QN):
+        all_reserved_locals.update(s.qn)
+      elif isinstance(s, str):
+        all_reserved_locals.add(s)
+      else:
+        raise ValueError('Unexpected symbol type "%s"' % type(s))
+
+    pieces = name_root.split('_')
+    if pieces[-1].isdigit():
+      name_root = '_'.join(pieces[:-1])
+      n = int(pieces[-1])
+    else:
+      n = 0
+    new_name = name_root
+
+    while (new_name in self.global_namespace or
+           new_name in all_reserved_locals or new_name in self.generated_names):
+      n += 1
+      new_name = '%s_%d' % (name_root, n)
+
+    self.generated_names.add(new_name)
+    return new_name

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/origin_info.py

@@ -0,0 +1,296 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Container for origin source code information before AutoGraph compilation."""
+import collections
+import difflib
+import io
+import os
+import tokenize
+
+import gast
+
+from tensorflow.python.autograph.pyct import anno
+from tensorflow.python.autograph.pyct import ast_util
+from tensorflow.python.autograph.pyct import parser
+from tensorflow.python.autograph.pyct import pretty_printer
+from tensorflow.python.util import tf_inspect
+
+
+class LineLocation(
+    collections.namedtuple('LineLocation', ('filename', 'lineno'))):
+  """Similar to Location, but without column information.
+
+  Attributes:
+    filename: Text
+    lineno: int, 1-based
+  """
+  pass
+
+
+class Location(
+    collections.namedtuple('Location', ('filename', 'lineno', 'col_offset'))):
+  """Encodes code location information.
+
+  Attributes:
+    filename: Text
+    lineno: int, 1-based
+    col_offset: int
+    line_loc: LineLocation
+  """
+
+  @property
+  def line_loc(self):
+    return LineLocation(self.filename, self.lineno)
+
+
+class OriginInfo(
+    collections.namedtuple(
+        'OriginInfo',
+        ('loc', 'function_name', 'source_code_line', 'comment'))):
+  """Container for information about the source code before conversion.
+
+  Attributes:
+    loc: Location
+    function_name: Optional[Text]
+    source_code_line: Text
+    comment: Optional[Text]
+  """
+
+  def as_frame(self):
+    """Returns a 4-tuple consistent with the return of traceback.extract_tb."""
+    return (self.loc.filename, self.loc.lineno, self.function_name,
+            self.source_code_line)
+
+  def __repr__(self):
+    if self.loc.filename:
+      return '{}:{}:{}'.format(
+          os.path.split(self.loc.filename)[1], self.loc.lineno,
+          self.loc.col_offset)
+    return '<no file>:{}:{}'.format(self.loc.lineno, self.loc.col_offset)
+
+
+# TODO(mdan): This source map should be a class - easier to refer to.
+def create_source_map(nodes, code, filepath):
+  """Creates a source map between an annotated AST and the code it compiles to.
+
+  Note: this function assumes nodes nodes, code and filepath correspond to the
+  same code.
+
+  Args:
+    nodes: Iterable[ast.AST, ...], one or more AST modes.
+    code: Text, the source code in which nodes are found.
+    filepath: Text
+
+  Returns:
+    Dict[LineLocation, OriginInfo], mapping locations in code to locations
+    indicated by origin annotations in node.
+  """
+  reparsed_nodes = parser.parse(code, preamble_len=0, single_node=False)
+  for node in reparsed_nodes:
+    resolve(node, code, filepath, node.lineno, node.col_offset)
+
+  source_map = {}
+
+  try:
+    for before, after in ast_util.parallel_walk(nodes, reparsed_nodes):
+      # Note: generated code might not be mapped back to its origin.
+      # TODO(mdan): Generated code should always be mapped to something.
+      origin_info = anno.getanno(before, anno.Basic.ORIGIN, default=None)
+      final_info = anno.getanno(after, anno.Basic.ORIGIN, default=None)
+      if origin_info is None or final_info is None:
+        continue
+
+      # Note: the keys are by line only, excluding the column offset.
+      line_loc = LineLocation(final_info.loc.filename, final_info.loc.lineno)
+
+      existing_origin = source_map.get(line_loc)
+      if existing_origin is not None:
+        # Overlaps may exist because of child nodes, but almost never to
+        # different line locations. Exception make decorated functions, where
+        # both lines are mapped to the same line in the AST.
+
+        # Line overlaps: keep bottom node.
+        if existing_origin.loc.line_loc == origin_info.loc.line_loc:
+          if existing_origin.loc.lineno >= origin_info.loc.lineno:
+            continue
+
+        # In case of column overlaps, keep the leftmost node.
+        if existing_origin.loc.col_offset <= origin_info.loc.col_offset:
+          continue
+
+      source_map[line_loc] = origin_info
+
+  except ValueError as err:
+    new_msg = 'Inconsistent ASTs detected. This is a bug. Cause: \n'
+    new_msg += str(err)
+    new_msg += 'Diff:\n'
+
+    for n, rn in zip(nodes, reparsed_nodes):
+      nodes_str = pretty_printer.fmt(n, color=False, noanno=True)
+      reparsed_nodes_str = pretty_printer.fmt(rn, color=False, noanno=True)
+      diff = difflib.context_diff(
+          nodes_str.split('\n'),
+          reparsed_nodes_str.split('\n'),
+          fromfile='Original nodes',
+          tofile='Reparsed nodes',
+          n=7)
+      diff = '\n'.join(diff)
+      new_msg += diff + '\n'
+    raise ValueError(new_msg)
+
+  return source_map
+
+
+class _Function:
+
+  def __init__(self, name):
+    self.name = name
+
+
+class OriginResolver(gast.NodeVisitor):
+  """Annotates an AST with additional source information like file name."""
+
+  def __init__(self, root_node, source_lines, comments_map,
+               context_lineno, context_col_offset,
+               filepath):
+    self._source_lines = source_lines
+    self._comments_map = comments_map
+
+    if (hasattr(root_node, 'decorator_list') and root_node.decorator_list and
+        hasattr(root_node.decorator_list[0], 'lineno')):
+      # Typical case: functions. The line number of the first decorator
+      # is more accurate than the line number of the function itself in
+      # 3.8+. In earlier versions they coincide.
+      self._lineno_offset = context_lineno - root_node.decorator_list[0].lineno
+    else:
+      # Fall back to the line number of the root node.
+      self._lineno_offset = context_lineno - root_node.lineno
+
+    self._col_offset = context_col_offset - root_node.col_offset
+
+    self._filepath = filepath
+
+    self._function_stack = []
+
+  def _absolute_lineno(self, lineno):
+    return lineno + self._lineno_offset
+
+  def _absolute_col_offset(self, col_offset):
+    if col_offset is None:
+      return 0
+    return col_offset + self._col_offset
+
+  def _attach_origin_info(self, node):
+    lineno = getattr(node, 'lineno', None)
+    col_offset = getattr(node, 'col_offset', None)
+
+    if lineno is None:
+      return
+
+    if self._function_stack:
+      function_name = self._function_stack[-1].name
+    else:
+      function_name = None
+
+    source_code_line = self._source_lines[lineno - 1]
+    comment = self._comments_map.get(lineno)
+
+    loc = Location(self._filepath, self._absolute_lineno(lineno),
+                   self._absolute_col_offset(col_offset))
+    origin = OriginInfo(loc, function_name, source_code_line, comment)
+    anno.setanno(node, 'lineno', lineno)
+    anno.setanno(node, anno.Basic.ORIGIN, origin)
+
+  def visit(self, node):
+    entered_function = False
+    if isinstance(node, gast.FunctionDef):
+      entered_function = True
+      self._function_stack.append(_Function(node.name))
+
+    self._attach_origin_info(node)
+    self.generic_visit(node)
+
+    if entered_function:
+      self._function_stack.pop()
+
+
+def resolve(node, source, context_filepath, context_lineno, context_col_offset):
+  """Adds origin information to an AST, based on the source it was loaded from.
+
+  This allows us to map the original source code line numbers to generated
+  source code.
+
+  Note: the AST may be a part of a larger context (e.g. a function is part of
+  a module that may contain other things). However, this function does not
+  assume the source argument contains the entire context, nor that it contains
+  only code corresponding to node itself. However, it assumes that node was
+  parsed from the given source code.
+  For this reason, two extra arguments are required, and they indicate the
+  location of the node in the original context.
+
+  Args:
+    node: gast.AST, the AST to annotate.
+    source: Text, the source code representing node.
+    context_filepath: Text
+    context_lineno: int
+    context_col_offset: int
+  """
+  # TODO(mdan): Pull this to a separate utility.
+  code_reader = io.StringIO(source)
+  comments_map = {}
+  try:
+    for token in tokenize.generate_tokens(code_reader.readline):
+      tok_type, tok_string, loc, _, _ = token
+      srow, _ = loc
+      if tok_type == tokenize.COMMENT:
+        comments_map[srow] = tok_string.strip()[1:].strip()
+  except tokenize.TokenError:
+    if isinstance(node, gast.Lambda):
+      # Source code resolution in older Python versions is brittle for
+      # lambda functions, and may contain garbage.
+      pass
+    else:
+      raise
+
+  source_lines = source.split('\n')
+  visitor = OriginResolver(node, source_lines, comments_map,
+                           context_lineno, context_col_offset,
+                           context_filepath)
+  visitor.visit(node)
+
+
+def resolve_entity(node, source, entity):
+  """Like resolve, but extracts the context information from an entity."""
+  lines, lineno = tf_inspect.getsourcelines(entity)
+  filepath = tf_inspect.getsourcefile(entity)
+
+  # Poor man's attempt at guessing the column offset: count the leading
+  # whitespace. This might not work well with tabs.
+  definition_line = lines[0]
+  col_offset = len(definition_line) - len(definition_line.lstrip())
+
+  resolve(node, source, filepath, lineno, col_offset)
+
+
+def copy_origin(from_node, to_node):
+  """Copies the origin info from a node to another, recursively."""
+  origin = anno.Basic.ORIGIN.of(from_node, default=None)
+  if origin is None:
+    return
+  if not isinstance(to_node, (list, tuple)):
+    to_node = (to_node,)
+  for node in to_node:
+    for n in gast.walk(node):
+      anno.setanno(n, anno.Basic.ORIGIN, origin)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/parser.py

@@ -0,0 +1,396 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Converting code to AST.
+
+Adapted from Tangent.
+"""
+
+import ast
+import inspect
+import io
+import linecache
+import re
+import sys
+import textwrap
+import tokenize
+
+import astunparse
+import gast
+
+from tensorflow.python.autograph.pyct import errors
+from tensorflow.python.autograph.pyct import inspect_utils
+from tensorflow.python.util import tf_inspect
+
+
+PY2_PREAMBLE = textwrap.dedent("""
+""")
+PY3_PREAMBLE = ''
+MAX_SIZE = 0
+
+if sys.version_info >= (3, 9):
+  astunparse = ast
+
+if sys.version_info >= (3,):
+  STANDARD_PREAMBLE = PY3_PREAMBLE
+  MAX_SIZE = sys.maxsize
+else:
+  STANDARD_PREAMBLE = PY2_PREAMBLE
+  MAX_SIZE = sys.maxint
+
+STANDARD_PREAMBLE_LEN = STANDARD_PREAMBLE.count('__future__')
+
+
+_LEADING_WHITESPACE = re.compile(r'\s*')
+
+
+def _unfold_continuations(code_string):
+  """Removes any backslash line continuations from the code."""
+  return code_string.replace('\\\n', '')
+
+
+def dedent_block(code_string):
+  """Dedents a code so that its first line starts at row zero."""
+
+  code_string = _unfold_continuations(code_string)
+
+  token_gen = tokenize.generate_tokens(io.StringIO(code_string).readline)
+
+  block_indentation = None
+  tokens = []
+  try:
+    for tok in token_gen:
+      tokens.append(tok)
+  except tokenize.TokenError:
+    # Resolution of lambda functions may yield incomplete code, which can
+    # in turn generate this error. We silently ignore this error because the
+    # parser may still be able to deal with it.
+    pass
+
+  for tok in tokens:
+    tok_type, tok_string, _, _, _ = tok
+    if tok_type == tokenize.INDENT:
+      block_indentation = tok_string
+      block_level = len(block_indentation)
+      break
+    elif tok_type not in (
+        tokenize.NL, tokenize.NEWLINE, tokenize.STRING, tokenize.COMMENT):
+      block_indentation = ''
+      break
+
+  if not block_indentation:
+    return code_string
+
+  block_level = len(block_indentation)
+  first_indent_uses_tabs = '\t' in block_indentation
+  for i, tok in enumerate(tokens):
+    tok_type, tok_string, _, _, _ = tok
+    if tok_type == tokenize.INDENT:
+      if ((' ' in tok_string and first_indent_uses_tabs)
+          or ('\t' in tok_string and not first_indent_uses_tabs)):
+        # TODO(mdan): We could attempt to convert tabs to spaces by unix rule.
+        # See:
+        # https://docs.python.org/3/reference/lexical_analysis.html#indentation
+        raise errors.UnsupportedLanguageElementError(
+            'code mixing tabs and spaces for indentation is not allowed')
+      if len(tok_string) >= block_level:
+        tok_string = tok_string[block_level:]
+      tokens[i] = (tok_type, tok_string)
+
+  new_code = tokenize.untokenize(tokens)
+
+  # Note: untokenize respects the line structure, but not the whitespace within
+  # lines. For example, `def foo()` may be untokenized as `def foo ()`
+  # So instead of using the output of dedent, we match the leading whitespace
+  # on each line.
+  dedented_code = []
+  for line, new_line in zip(code_string.split('\n'), new_code.split('\n')):
+    original_indent = re.match(_LEADING_WHITESPACE, line).group()
+    new_indent = re.match(_LEADING_WHITESPACE, new_line).group()
+    if len(original_indent) > len(new_indent):
+      dedented_line = line[len(original_indent) - len(new_indent):]
+    else:
+      dedented_line = line
+    dedented_code.append(dedented_line)
+  new_code = '\n'.join(dedented_code)
+
+  return new_code
+
+
+def parse_entity(entity, future_features):
+  """Returns the AST and source code of given entity.
+
+  Args:
+    entity: Any, Python function/method/class
+    future_features: Iterable[Text], future features to use (e.g.
+      'print_statement'). See
+      https://docs.python.org/2/reference/simple_stmts.html#future
+
+  Returns:
+    gast.AST, Text: the parsed AST node; the source code that was parsed to
+    generate the AST (including any prefixes that this function may have added).
+  """
+  if inspect_utils.islambda(entity):
+    return _parse_lambda(entity)
+
+  try:
+    original_source = inspect_utils.getimmediatesource(entity)
+  except OSError as e:
+    raise errors.InaccessibleSourceCodeError(
+        f'Unable to locate the source code of {entity}. Note that functions'
+        ' defined in certain environments, like the interactive Python shell,'
+        ' do not expose their source code. If that is the case, you should'
+        ' define them in a .py source file. If you are certain the code is'
+        ' graph-compatible, wrap the call using'
+        f' @tf.autograph.experimental.do_not_convert. Original error: {e}')
+
+  source = dedent_block(original_source)
+
+  future_statements = tuple(
+      'from __future__ import {}'.format(name) for name in future_features)
+  source = '\n'.join(future_statements + (source,))
+
+  return parse(source, preamble_len=len(future_features)), source
+
+
+def _without_context(node, lines, minl, maxl):
+  """Returns a clean node and source code without indenting and context."""
+  for n in gast.walk(node):
+    lineno = getattr(n, 'lineno', None)
+    if lineno is not None:
+      n.lineno = lineno - minl
+    end_lineno = getattr(n, 'end_lineno', None)
+    if end_lineno is not None:
+      n.end_lineno = end_lineno - minl
+
+  code_lines = lines[minl - 1:maxl]
+
+  # Attempt to clean up surrounding context code.
+
+  end_col_offset = getattr(node, 'end_col_offset', None)
+  if end_col_offset is not None:
+    # This is only available in 3.8.
+    code_lines[-1] = code_lines[-1][:end_col_offset]
+
+  col_offset = getattr(node, 'col_offset', None)
+  if col_offset is None:
+    # Older Python: try to find the "lambda" token. This is brittle.
+    match = re.search(r'(?<!\w)lambda(?!\w)', code_lines[0])
+    if match is not None:
+      col_offset = match.start(0)
+
+  if col_offset is not None:
+    code_lines[0] = code_lines[0][col_offset:]
+
+  code_block = '\n'.join([c.rstrip() for c in code_lines])
+
+  return node, code_block
+
+
+def _arg_name(node):
+  if node is None:
+    return None
+  if isinstance(node, gast.Name):
+    return node.id
+  assert isinstance(node, str)
+  return node
+
+
+def _node_matches_argspec(node, func):
+  """Returns True is node fits the argspec of func."""
+  # TODO(mdan): Use just inspect once support for Python 2 is dropped.
+  arg_spec = tf_inspect.getfullargspec(func)
+
+  node_args = tuple(_arg_name(arg) for arg in node.args.args)
+  if node_args != tuple(arg_spec.args):
+    return False
+
+  if arg_spec.varargs != _arg_name(node.args.vararg):
+    return False
+
+  if arg_spec.varkw != _arg_name(node.args.kwarg):
+    return False
+
+  node_kwonlyargs = tuple(_arg_name(arg) for arg in node.args.kwonlyargs)
+  if node_kwonlyargs != tuple(arg_spec.kwonlyargs):
+    return False
+
+  return True
+
+
+def _parse_lambda(lam):
+  """Returns the AST and source code of given lambda function.
+
+  Args:
+    lam: types.LambdaType, Python function/method/class
+
+  Returns:
+    gast.AST, Text: the parsed AST node; the source code that was parsed to
+    generate the AST (including any prefixes that this function may have added).
+  """
+  # TODO(mdan): Use a fast path if the definition is not multi-line.
+  # We could detect that the lambda is in a multi-line expression by looking
+  # at the surrounding code - an surrounding set of parentheses indicates a
+  # potential multi-line definition.
+
+  mod = inspect.getmodule(lam)
+  f = inspect.getsourcefile(lam)
+  def_line = lam.__code__.co_firstlineno
+
+  # This method is more robust that just calling inspect.getsource(mod), as it
+  # works in interactive shells, where getsource would fail. This is the
+  # same procedure followed by inspect for non-modules:
+  # https://github.com/python/cpython/blob/3.8/Lib/inspect.py#L772
+  lines = linecache.getlines(f, mod.__dict__)
+  source = ''.join(lines)
+
+  # Narrow down to the last node starting before our definition node.
+  all_nodes = parse(source, preamble_len=0, single_node=False)
+  search_nodes = []
+  for node in all_nodes:
+    # Also include nodes without a line number, for safety. This is defensive -
+    # we don't know whether such nodes might exist, and if they do, whether
+    # they are not safe to skip.
+    # TODO(mdan): Replace this check with an assertion or skip such nodes.
+    if getattr(node, 'lineno', def_line) <= def_line:
+      search_nodes.append(node)
+    else:
+      # Found a node starting past our lambda - can stop the search.
+      break
+
+  # Extract all lambda nodes from the shortlist.
+  lambda_nodes = []
+  for node in search_nodes:
+    lambda_nodes.extend(
+        n for n in gast.walk(node) if isinstance(n, gast.Lambda))
+
+  # Filter down to lambda nodes which span our actual lambda.
+  candidates = []
+  for ln in lambda_nodes:
+    minl, maxl = MAX_SIZE, 0
+    for n in gast.walk(ln):
+      minl = min(minl, getattr(n, 'lineno', minl))
+      lineno = getattr(n, 'lineno', maxl)
+      end_lineno = getattr(n, 'end_lineno', None)
+      if end_lineno is not None:
+        # end_lineno is more precise, but lineno should almost always work too.
+        lineno = end_lineno
+      maxl = max(maxl, lineno)
+    if minl <= def_line <= maxl:
+      candidates.append((ln, minl, maxl))
+
+  # Happy path: exactly one node found.
+  if len(candidates) == 1:
+    (node, minl, maxl), = candidates  # pylint:disable=unbalanced-tuple-unpacking
+    return _without_context(node, lines, minl, maxl)
+
+  elif not candidates:
+    lambda_codes = '\n'.join([unparse(l) for l in lambda_nodes])
+    raise errors.UnsupportedLanguageElementError(
+        f'could not parse the source code of {lam}:'
+        f' no matching AST found among candidates:\n{lambda_codes}')
+
+  # Attempt to narrow down selection by signature is multiple nodes are found.
+  matches = [v for v in candidates if _node_matches_argspec(v[0], lam)]
+  if len(matches) == 1:
+    (node, minl, maxl), = matches
+    return _without_context(node, lines, minl, maxl)
+
+  # Give up if could not narrow down to a single node.
+  matches = '\n'.join(
+      'Match {}:\n{}\n'.format(i, unparse(node, include_encoding_marker=False))
+      for i, (node, _, _) in enumerate(matches))
+  raise errors.UnsupportedLanguageElementError(
+      f'could not parse the source code of {lam}: found multiple definitions'
+      ' with identical signatures at the location. This error'
+      ' may be avoided by defining each lambda on a single line and with'
+      f' unique argument names. The matching definitions were:\n{matches}')
+
+
+# TODO(mdan): This should take futures as input instead.
+def parse(src, preamble_len=0, single_node=True):
+  """Returns the AST of given piece of code.
+
+  Args:
+    src: Text
+    preamble_len: Int, indicates leading nodes in the parsed AST which should be
+      dropped.
+    single_node: Bool, whether `src` is assumed to be represented by exactly one
+      AST node.
+
+  Returns:
+    ast.AST
+  """
+  module_node = gast.parse(src)
+  nodes = module_node.body
+  if preamble_len:
+    nodes = nodes[preamble_len:]
+  if single_node:
+    if len(nodes) != 1:
+      raise ValueError('expected exactly one node, got {}'.format(nodes))
+    return nodes[0]
+  return nodes
+
+
+def parse_expression(src):
+  """Returns the AST of given identifier.
+
+  Args:
+    src: A piece of code that represents a single Python expression
+  Returns:
+    A gast.AST object.
+  Raises:
+    ValueError: if src does not consist of a single Expression.
+  """
+  src = STANDARD_PREAMBLE + src.strip()
+  node = parse(src, preamble_len=STANDARD_PREAMBLE_LEN, single_node=True)
+  if __debug__:
+    if not isinstance(node, gast.Expr):
+      raise ValueError(
+          'expected exactly one node of type Expr, got {}'.format(node))
+  return node.value
+
+
+def unparse(node, indentation=None, include_encoding_marker=True):
+  """Returns the source code of given AST.
+
+  Args:
+    node: The code to compile, as an AST object.
+    indentation: Unused, deprecated. The returning code will always be indented
+      at 4 spaces.
+    include_encoding_marker: Bool, whether to include a comment on the first
+      line to explicitly specify UTF-8 encoding.
+
+  Returns:
+    code: The source code generated from the AST object
+    source_mapping: A mapping between the user and AutoGraph generated code.
+  """
+  del indentation  # astunparse doesn't allow configuring it.
+  if not isinstance(node, (list, tuple)):
+    node = (node,)
+
+  codes = []
+  if include_encoding_marker:
+    codes.append('# coding=utf-8')
+  for n in node:
+    if isinstance(n, gast.AST):
+      ast_n = gast.gast_to_ast(n)
+    else:
+      ast_n = n
+
+    if astunparse is ast:
+      ast.fix_missing_locations(ast_n)  # Only ast needs to call this.
+    codes.append(astunparse.unparse(ast_n).strip())
+
+  return '\n'.join(codes)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/pretty_printer.py

@@ -0,0 +1,130 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Print an AST tree in a form more readable than ast.dump."""
+
+import gast
+import termcolor
+
+
+class PrettyPrinter(gast.NodeVisitor):
+  """Print AST nodes."""
+
+  def __init__(self, color, noanno):
+    self.indent_lvl = 0
+    self.result = ''
+    self.color = color
+    self.noanno = noanno
+
+  def _color(self, string, color, attrs=None):
+    if self.color:
+      return termcolor.colored(string, color, attrs=attrs)
+    return string
+
+  def _type(self, node):
+    return self._color(node.__class__.__name__, None, ['bold'])
+
+  def _field(self, name):
+    return self._color(name, 'blue')
+
+  def _value(self, name):
+    return self._color(name, 'magenta')
+
+  def _warning(self, name):
+    return self._color(name, 'red')
+
+  def _indent(self):
+    return self._color('| ' * self.indent_lvl, None, ['dark'])
+
+  def _print(self, s):
+    self.result += s
+    self.result += '\n'
+
+  def generic_visit(self, node, name=None):
+    # In very rare instances, a list can contain something other than a Node.
+    # e.g. Global contains a list of strings.
+    if isinstance(node, str):
+      if name:
+        self._print('%s%s="%s"' % (self._indent(), name, node))
+      else:
+        self._print('%s"%s"' % (self._indent(), node))
+      return
+
+    if node._fields:
+      cont = ':'
+    else:
+      cont = '()'
+
+    if name:
+      self._print('%s%s=%s%s' % (self._indent(), self._field(name),
+                                 self._type(node), cont))
+    else:
+      self._print('%s%s%s' % (self._indent(), self._type(node), cont))
+
+    self.indent_lvl += 1
+    for f in node._fields:
+      if self.noanno and f.startswith('__'):
+        continue
+      if not hasattr(node, f):
+        self._print('%s%s' % (self._indent(), self._warning('%s=<unset>' % f)))
+        continue
+      v = getattr(node, f)
+      if isinstance(v, list):
+        if v:
+          self._print('%s%s=[' % (self._indent(), self._field(f)))
+          self.indent_lvl += 1
+          for n in v:
+            if n is not None:
+              self.generic_visit(n)
+            else:
+              self._print('%sNone' % (self._indent()))
+          self.indent_lvl -= 1
+          self._print('%s]' % (self._indent()))
+        else:
+          self._print('%s%s=[]' % (self._indent(), self._field(f)))
+      elif isinstance(v, tuple):
+        if v:
+          self._print('%s%s=(' % (self._indent(), self._field(f)))
+          self.indent_lvl += 1
+          for n in v:
+            if n is not None:
+              self.generic_visit(n)
+            else:
+              self._print('%sNone' % (self._indent()))
+          self.indent_lvl -= 1
+          self._print('%s)' % (self._indent()))
+        else:
+          self._print('%s%s=()' % (self._indent(), self._field(f)))
+      elif isinstance(v, gast.AST):
+        self.generic_visit(v, f)
+      elif isinstance(v, bytes):
+        self._print('%s%s=%s' % (self._indent(), self._field(f),
+                                 self._value('b"%s"' % v)))
+      elif isinstance(v, str):
+        self._print('%s%s=%s' % (self._indent(), self._field(f),
+                                 self._value('u"%s"' % v)))
+      else:
+        self._print('%s%s=%s' % (self._indent(), self._field(f),
+                                 self._value(v)))
+    self.indent_lvl -= 1
+
+
+def fmt(node, color=True, noanno=False):
+  printer = PrettyPrinter(color, noanno)
+  if isinstance(node, (list, tuple)):
+    for n in node:
+      printer.visit(n)
+  else:
+    printer.visit(node)
+  return printer.result

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/qual_names.py

@@ -0,0 +1,266 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities for manipulating qualified names.
+
+A qualified name is a uniform way to refer to simple (e.g. 'foo') and composite
+(e.g. 'foo.bar') syntactic symbols.
+
+This is *not* related to the __qualname__ attribute used by inspect, which
+refers to scopes.
+"""
+
+import collections
+
+import gast
+
+from tensorflow.python.autograph.pyct import anno
+from tensorflow.python.autograph.pyct import parser
+
+
+class CallerMustSetThis(object):
+  pass
+
+
+class Symbol(collections.namedtuple('Symbol', ['name'])):
+  """Represents a Python symbol."""
+
+
+class Literal(collections.namedtuple('Literal', ['value'])):
+  """Represents a Python numeric literal."""
+
+  def __str__(self):
+    if isinstance(self.value, str):
+      return "'{}'".format(self.value)
+    return str(self.value)
+
+  def __repr__(self):
+    return str(self)
+
+
+# TODO(mdan): Use subclasses to remove the has_attr has_subscript booleans.
+class QN(object):
+  """Represents a qualified name."""
+
+  def __init__(self, base, attr=None, subscript=None):
+    if attr is not None and subscript is not None:
+      raise ValueError('A QN can only be either an attr or a subscript, not '
+                       'both: attr={}, subscript={}.'.format(attr, subscript))
+    self._has_attr = False
+    self._has_subscript = False
+
+    if attr is not None:
+      if not isinstance(base, QN):
+        raise ValueError(
+            'for attribute QNs, base must be a QN; got instead "%s"' % base)
+      if not isinstance(attr, str):
+        raise ValueError('attr may only be a string; got instead "%s"' % attr)
+      self._parent = base
+      # TODO(mdan): Get rid of the tuple - it can only have 1 or 2 elements now.
+      self.qn = (base, attr)
+      self._has_attr = True
+
+    elif subscript is not None:
+      if not isinstance(base, QN):
+        raise ValueError('For subscript QNs, base must be a QN.')
+      self._parent = base
+      self.qn = (base, subscript)
+      self._has_subscript = True
+
+    else:
+      if not isinstance(base, (str, Literal)):
+        # TODO(mdan): Require Symbol instead of string.
+        raise ValueError(
+            'for simple QNs, base must be a string or a Literal object;'
+            ' got instead "%s"' % type(base))
+      assert '.' not in base and '[' not in base and ']' not in base
+      self._parent = None
+      self.qn = (base,)
+
+  def is_symbol(self):
+    return isinstance(self.qn[0], str)
+
+  def is_simple(self):
+    return len(self.qn) <= 1
+
+  def is_composite(self):
+    return len(self.qn) > 1
+
+  def has_subscript(self):
+    return self._has_subscript
+
+  def has_attr(self):
+    return self._has_attr
+
+  @property
+  def attr(self):
+    if not self._has_attr:
+      raise ValueError('Cannot get attr of non-attribute "%s".' % self)
+    return self.qn[1]
+
+  @property
+  def parent(self):
+    if self._parent is None:
+      raise ValueError('Cannot get parent of simple name "%s".' % self.qn[0])
+    return self._parent
+
+  @property
+  def owner_set(self):
+    """Returns all the symbols (simple or composite) that own this QN.
+
+    In other words, if this symbol was modified, the symbols in the owner set
+    may also be affected.
+
+    Examples:
+      'a.b[c.d]' has two owners, 'a' and 'a.b'
+    """
+    owners = set()
+    if self.has_attr() or self.has_subscript():
+      owners.add(self.parent)
+      owners.update(self.parent.owner_set)
+    return owners
+
+  @property
+  def support_set(self):
+    """Returns the set of simple symbols that this QN relies on.
+
+    This would be the smallest set of symbols necessary for the QN to
+    statically resolve (assuming properties and index ranges are verified
+    at runtime).
+
+    Examples:
+      'a.b' has only one support symbol, 'a'
+      'a[i]' has two support symbols, 'a' and 'i'
+    """
+    # TODO(mdan): This might be the set of Name nodes in the AST. Track those?
+    roots = set()
+    if self.has_attr():
+      roots.update(self.parent.support_set)
+    elif self.has_subscript():
+      roots.update(self.parent.support_set)
+      roots.update(self.qn[1].support_set)
+    else:
+      roots.add(self)
+    return roots
+
+  def __hash__(self):
+    return hash(self.qn + (self._has_attr, self._has_subscript))
+
+  def __eq__(self, other):
+    return (isinstance(other, QN) and self.qn == other.qn and
+            self.has_subscript() == other.has_subscript() and
+            self.has_attr() == other.has_attr())
+
+  def __lt__(self, other):
+    return str(self) < str(other)
+
+  def __gt__(self, other):
+    return str(self) > str(other)
+
+  def __str__(self):
+    root = self.qn[0]
+    if self.has_subscript():
+      return '{}[{}]'.format(root, self.qn[1])
+    if self.has_attr():
+      return '.'.join(map(str, self.qn))
+    else:
+      return str(root)
+
+  def __repr__(self):
+    return str(self)
+
+  def ssf(self):
+    """Simple symbol form."""
+    ssfs = [n.ssf() if isinstance(n, QN) else n for n in self.qn]
+    ssf_string = ''
+    for i in range(0, len(self.qn) - 1):
+      if self.has_subscript():
+        delimiter = '_sub_'
+      else:
+        delimiter = '_'
+      ssf_string += ssfs[i] + delimiter
+    return ssf_string + ssfs[-1]
+
+  def ast(self):
+    """AST representation."""
+    # The caller must adjust the context appropriately.
+    if self.has_subscript():
+      return gast.Subscript(
+          value=self.parent.ast(),
+          slice=self.qn[-1].ast(),
+          ctx=CallerMustSetThis)
+    if self.has_attr():
+      return gast.Attribute(
+          value=self.parent.ast(), attr=self.qn[-1], ctx=CallerMustSetThis)
+
+    base = self.qn[0]
+    if isinstance(base, str):
+      return gast.Name(
+          base, ctx=CallerMustSetThis, annotation=None, type_comment=None)
+    elif isinstance(base, Literal):
+      return gast.Constant(base.value, kind=None)
+    else:
+      assert False, ('the constructor should prevent types other than '
+                     'str and Literal')
+
+
+class QnResolver(gast.NodeTransformer):
+  """Annotates nodes with QN information.
+
+  Note: Not using NodeAnnos to avoid circular dependencies.
+  """
+
+  def visit_Name(self, node):
+    node = self.generic_visit(node)
+    anno.setanno(node, anno.Basic.QN, QN(node.id))
+    return node
+
+  def visit_Attribute(self, node):
+    node = self.generic_visit(node)
+    if anno.hasanno(node.value, anno.Basic.QN):
+      anno.setanno(node, anno.Basic.QN,
+                   QN(anno.getanno(node.value, anno.Basic.QN), attr=node.attr))
+    return node
+
+  def visit_Subscript(self, node):
+    # TODO(mdan): This may no longer apply if we overload getitem.
+    node = self.generic_visit(node)
+    s = node.slice
+    if isinstance(s, (gast.Tuple, gast.Slice)):
+      # TODO(mdan): Support range and multi-dimensional indices.
+      # Continuing silently because some demos use these.
+      return node
+    if isinstance(s, gast.Constant) and s.value != Ellipsis:
+      subscript = QN(Literal(s.value))
+    else:
+      # The index may be an expression, case in which a name doesn't make sense.
+      if anno.hasanno(s, anno.Basic.QN):
+        subscript = anno.getanno(s, anno.Basic.QN)
+      else:
+        return node
+    if anno.hasanno(node.value, anno.Basic.QN):
+      anno.setanno(node, anno.Basic.QN,
+                   QN(anno.getanno(node.value, anno.Basic.QN),
+                      subscript=subscript))
+    return node
+
+
+def resolve(node):
+  return QnResolver().visit(node)
+
+
+def from_str(qn_str):
+  node = parser.parse_expression(qn_str)
+  node = resolve(node)
+  return anno.getanno(node, anno.Basic.QN)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/templates.py

@@ -0,0 +1,290 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""AST conversion templates.
+
+Adapted from Tangent.
+"""
+
+import ast
+import textwrap
+
+import gast
+
+from tensorflow.python.autograph.pyct import anno
+from tensorflow.python.autograph.pyct import ast_util
+from tensorflow.python.autograph.pyct import parser
+from tensorflow.python.autograph.pyct import qual_names
+
+
+class ContextAdjuster(gast.NodeTransformer):
+  """Adjusts the ctx field of nodes to ensure consistency.
+
+  This transformer can change the ctx fields of a variable, tuple and other
+  AST elements that allow one, based on whether the element is being read or
+  written.
+  """
+
+  def __init__(self, override_value):
+    self._ctx_override = override_value
+
+  def visit(self, node):
+    original_override = self._ctx_override
+    node = super(ContextAdjuster, self).visit(node)
+    if hasattr(node, 'ctx'):
+      assert node.ctx is not None, 'node {} has ctx unset'.format(node)
+    self._ctx_override = original_override
+    return node
+
+  def _apply_override(self, node):
+    if self._ctx_override is not None:
+      node.ctx = self._ctx_override()
+
+  def visit_Attribute(self, node):
+    self._apply_override(node)
+    self._ctx_override = gast.Load
+    node = self.generic_visit(node)
+    return node
+
+  def visit_Tuple(self, node):
+    self._apply_override(node)
+    return self.generic_visit(node)
+
+  def visit_List(self, node):
+    self._apply_override(node)
+    return self.generic_visit(node)
+
+  def visit_Name(self, node):
+    self._apply_override(node)
+    return self.generic_visit(node)
+
+  def visit_Call(self, node):
+    self._apply_override(node)
+    # We may be able to override these to Load(), but for now it's simpler
+    # to just assert that they're set.
+    self._ctx_override = None
+    return self.generic_visit(node)
+
+  def visit_Dict(self, node):
+    # We may be able to override these to Load(), but for now it's simpler
+    # to just assert that they're set.
+    self._ctx_override = None
+    return self.generic_visit(node)
+
+  def visit_Subscript(self, node):
+    self._apply_override(node)
+    self._ctx_override = gast.Load
+    node.value = self.visit(node.value)
+    return self.generic_visit(node)
+
+  def visit_comprehension(self, node):
+    # We may be able to override some of these, but for now it's simpler
+    # to just assert that they're set.
+    self._ctx_override = None
+    return self.generic_visit(node)
+
+  def visit_Lambda(self, node):
+    # We may be able to override some of these, but for now it's simpler
+    # to just assert that they're set.
+    self._ctx_override = None
+    return self.generic_visit(node)
+
+
+class ReplaceTransformer(gast.NodeTransformer):
+  """Replace AST nodes."""
+
+  def __init__(self, replacements):
+    """Create a new ReplaceTransformer.
+
+    Args:
+      replacements: A mapping from placeholder names to (lists of) AST nodes
+          that these placeholders will be replaced by.
+    """
+    self.replacements = replacements
+    self.in_replacements = False
+    self.preserved_annos = {
+        anno.Basic.DIRECTIVES,
+        anno.Basic.EXTRA_LOOP_TEST,
+        anno.Basic.ORIGIN,
+        anno.Basic.SKIP_PROCESSING,
+        anno.Static.ORIG_DEFINITIONS,
+        'function_context_name',
+    }
+
+  def _prepare_replacement(self, replaced, key):
+    """Prepares a replacement AST that's safe to swap in for a node.
+
+    Args:
+      replaced: ast.AST, the node being replaced
+      key: Hashable, the key of the replacement AST
+    Returns:
+      ast.AST, the replacement AST
+    """
+    repl = self.replacements[key]
+
+    new_nodes = ast_util.copy_clean(repl, preserve_annos=self.preserved_annos)
+    if isinstance(new_nodes, gast.AST):
+      new_nodes = [new_nodes]
+
+    return new_nodes
+
+  def visit_Expr(self, node):
+    # When replacing a placeholder with an entire statement, the replacement
+    # must stand on its own and not be wrapped in an Expr.
+    new_value = self.visit(node.value)
+    if new_value is node.value:
+      return node
+    return new_value
+
+  def visit_keyword(self, node):
+    if node.arg not in self.replacements:
+      return self.generic_visit(node)
+
+    repl = self._prepare_replacement(node, node.arg)
+    if isinstance(repl, gast.keyword):
+      return repl
+    elif (repl and isinstance(repl, (list, tuple)) and
+          all(isinstance(r, gast.keyword) for r in repl)):
+      return repl
+    # TODO(mdan): We may allow replacing with a string as well.
+    # For example, if one wanted to replace foo with bar in foo=baz, then
+    # we could allow changing just node arg, so that we end up with bar=baz.
+    raise ValueError(
+        'a keyword argument may only be replaced by another keyword or a '
+        'non-empty list of keywords. Found: {} for keyword {}'.format(
+            repl, node.arg))
+
+  def visit_FunctionDef(self, node):
+    node = self.generic_visit(node)
+    if node.name not in self.replacements:
+      return node
+
+    repl = self.replacements[node.name]
+    if not isinstance(repl, (gast.Name, ast.Name)):
+      raise ValueError(
+          'a function name can only be replaced by a Name node. Found: %s' %
+          repl)
+    node.name = repl.id
+    return node
+
+  def visit_Attribute(self, node):
+    node = self.generic_visit(node)
+    if node.attr not in self.replacements:
+      return node
+
+    repl = self.replacements[node.attr]
+    if not isinstance(repl, gast.Name):
+      raise ValueError(
+          'An attribute can only be replaced by a Name node. Found: %s' % repl)
+    node.attr = repl.id
+    return node
+
+  def visit_Name(self, node):
+    if node.id not in self.replacements:
+      return node
+
+    new_nodes = self._prepare_replacement(node, node.id)
+
+    if not new_nodes:
+      return new_nodes
+
+    # Preserve the target context.
+    adjuster = ContextAdjuster(type(node.ctx))
+    for n in new_nodes:
+      if hasattr(n, 'ctx'):
+        adjuster.visit(n)
+
+    if len(new_nodes) == 1:
+      new_nodes, = new_nodes
+
+    return new_nodes
+
+
+def _convert_to_ast(n):
+  """Converts from a known data type to AST."""
+  # Note: When generating AST nodes from strings/QNs in isolation, ctx is
+  # unknown. ctx must be filled in according to the template being used.
+  # See ReplaceTransformer.visit_Name.
+  if isinstance(n, str):
+    return gast.Name(id=n, ctx=None, annotation=None, type_comment=None)
+  if isinstance(n, qual_names.QN):
+    return n.ast()
+  if isinstance(n, list):
+    return [_convert_to_ast(e) for e in n]
+  if isinstance(n, tuple):
+    return tuple(_convert_to_ast(e) for e in n)
+  return n
+
+
+def replace(template, **replacements):
+  """Replaces placeholders in a Python template.
+
+  AST Name and Tuple nodes always receive the context that inferred from
+  the template. However, when replacing more complex nodes (that can potentially
+  contain Name children), then the caller is responsible for setting the
+  appropriate context.
+
+  Args:
+    template: A string representing Python code. Any symbol name can be used
+        that appears in the template code can be used as placeholder.
+    **replacements: A mapping from placeholder names to (lists of) AST nodes
+        that these placeholders will be replaced by. String values are also
+        supported as a shorthand for AST Name nodes with the respective ID.
+
+  Returns:
+    An AST node or list of AST nodes with the replacements made. If the
+    template was a function, a list will be returned. If the template was a
+    node, the same node will be returned. If the template was a string, an
+    AST node will be returned (a `Module` node in the case of a multi-line
+    string, an `Expr` node otherwise).
+
+  Raises:
+    ValueError: if the arguments are incorrect.
+  """
+  if not isinstance(template, str):
+    raise ValueError('Expected string template, got %s' % type(template))
+  for k in replacements:
+    replacements[k] = _convert_to_ast(replacements[k])
+  template_str = parser.STANDARD_PREAMBLE + textwrap.dedent(template)
+  nodes = parser.parse(
+      template_str,
+      preamble_len=parser.STANDARD_PREAMBLE_LEN,
+      single_node=False)
+  results = []
+  for node in nodes:
+    node = ReplaceTransformer(replacements).visit(node)
+    if isinstance(node, (list, tuple)):
+      results.extend(node)
+    else:
+      results.append(node)
+  results = [qual_names.resolve(r) for r in results]
+  return results
+
+
+def replace_as_expression(template, **replacements):
+  """Variant of replace that generates expressions, instead of code blocks."""
+  replacement = replace(template, **replacements)
+  if len(replacement) != 1:
+    raise ValueError(
+        'single expression expected; for more general templates use replace')
+  node, = replacement
+
+  if isinstance(node, gast.Expr):
+    return node.value
+  elif isinstance(node, gast.Name):
+    return node
+
+  raise ValueError(
+      'the template is expected to generate an expression or a name node;'
+      ' instead found %s' % node)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/transformer.py

@@ -0,0 +1,538 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""A node transformer that includes utilities for SCT."""
+
+import collections
+import enum
+
+import gast
+
+from tensorflow.python.autograph.pyct import anno
+from tensorflow.python.autograph.pyct import parser
+from tensorflow.python.autograph.pyct import pretty_printer
+from tensorflow.python.autograph.pyct import templates
+
+
+class AnalysisLevel(enum.IntEnum):
+
+  NONE = 0
+  ACTIVITY = 1
+  DEFINEDNESS = 2
+  LIVENESS = 3
+
+
+# TODO(znado): Use namedtuple.
+class Context(object):
+  """Contains 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.
+  """
+
+  def __init__(self, info, namer, user_context):
+    self.info = info
+    self.namer = namer
+    self.current_origin = None
+    self.user = user_context
+
+
+# TODO(mdan): Move to a standalone file.
+class EntityInfo(
+    collections.namedtuple(
+        'EntityInfo',
+        ('name', 'source_code', 'source_file', 'future_features', 'namespace'))
+):
+  """Contains 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).
+  """
+  pass
+
+
+class _StateStack(object):
+  """Templated 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
+  """
+
+  def __init__(self, type_):
+    # Because we override __setattr__, we need to attach these attributes using
+    # the superclass' setattr.
+    object.__setattr__(self, 'type', type_)
+    object.__setattr__(self, '_stack', [])
+    if not hasattr(type_, 'no_root'):
+      self.enter()
+
+  def __enter__(self):
+    self.enter()
+    return self
+
+  def __exit__(self, exc_type, exc_value, traceback):
+    self.exit()
+
+  def enter(self):
+    self._stack.append(self.type())
+
+  def exit(self):
+    self._stack.pop()
+
+  @property
+  def stack(self):
+    return self._stack
+
+  @property
+  def level(self):
+    return len(self._stack)
+
+  @property
+  def value(self):
+    return self._stack[-1]
+
+  def __iter__(self):
+    return iter(self._stack)
+
+  def __getattr__(self, key):
+    return getattr(self._stack[-1], key)
+
+  def __setattr__(self, key, value):
+    setattr(self._stack[-1], key, value)
+
+
+class _State(object):
+  """Syntactic 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.
+  """
+
+  def __init__(self):
+    self._value = {}
+
+  def __getitem__(self, key):
+    if key not in self._value:
+      self._value[key] = _StateStack(key)
+    return self._value[key]
+
+
+class NodeStateTracker(object):
+  """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)
+  ```
+  """
+
+  # TODO(mdan): Document all extra features.
+
+  def __init__(self, ctx):
+    """Initialize the transformer.
+
+    Subclasses should call this.
+
+    Args:
+      ctx: A Context object.
+    """
+    self._lineno = 0
+    self._col_offset = 0
+    self.ctx = ctx
+
+    # Allows scoping of local variables to keep state across calls to visit_*
+    # methods. Multiple scope hierarchies may exist and are keyed by tag. A
+    # scope is valid at one or more nodes and all its children. Scopes created
+    # in child nodes supersede their parent. Scopes are isolated from one
+    # another.
+    self.state = _State()
+
+  def debug_print(self, node):
+    """Helper method useful for debugging. Prints the AST."""
+    if __debug__:
+      print(pretty_printer.fmt(node))
+    return node
+
+  def debug_print_src(self, node):
+    """Helper method useful for debugging. Prints the AST as code."""
+    if __debug__:
+      print(parser.unparse(node))
+    return node
+
+  def visit_block(self, nodes, before_visit=None, after_visit=None):
+    """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.
+    """
+    if nodes is None:
+      return None
+
+    results = []
+    node_destination = results
+    for node in nodes:
+      if before_visit:
+        # TODO(mdan): We can modify node here too, if ever needed.
+        before_visit()
+
+      replacement = self.visit(node)
+
+      if after_visit and replacement:
+        replacement, new_destination = after_visit(replacement)
+      else:
+        new_destination = None
+
+      if replacement:
+        if isinstance(replacement, (list, tuple)):
+          node_destination.extend(replacement)
+        else:
+          node_destination.append(replacement)
+
+      # Allow the postprocessor to reroute the remaining nodes to a new list.
+      if new_destination is not None:
+        node_destination = new_destination
+    return results
+
+
+# TODO(mdan): Rename to PythonCodeTransformer.
+class Base(NodeStateTracker, gast.NodeTransformer):
+  """Base class for general-purpose Python-to-Python code transformation.
+
+  This is an extension of ast.NodeTransformer that provides the additional
+  functions offered by NodeStateTracker.
+  """
+
+  def create_assignment(self, target, expression):
+    template = """
+      target = expression
+    """
+    return templates.replace(template, target=target, expression=expression)
+
+  # TODO(mdan): Remove.
+  def apply_to_single_assignments(self, targets, values, apply_fn):
+    """Applies 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.
+    """
+    if not isinstance(targets, (list, tuple)):
+      targets = (targets,)
+    for target in targets:
+      if isinstance(target, (gast.Tuple, gast.List)):
+        for i in range(len(target.elts)):
+          target_el = target.elts[i]
+          if isinstance(values, (gast.Tuple, gast.List)):
+            value_el = values.elts[i]
+          else:
+            value_el = gast.Subscript(values, i, ctx=gast.Store())
+          self.apply_to_single_assignments(target_el, value_el, apply_fn)
+      else:
+        # TODO(mdan): Look into allowing to rewrite the AST here.
+        apply_fn(target, values)
+
+  def visit(self, node):
+    if not isinstance(node, gast.AST):
+      # This is not that uncommon a mistake: various node bodies are lists, for
+      # example, posing a land mine for transformers that need to recursively
+      # call `visit`.  The error needs to be raised before the exception handler
+      # below is installed, because said handler will mess up if `node` is not,
+      # in fact, a node.
+      msg = ('invalid value for "node": expected "ast.AST", got "{}"; to'
+             ' visit lists of nodes, use "visit_block" instead').format(
+                 type(node))
+      raise ValueError(msg)
+
+    if anno.hasanno(node, anno.Basic.SKIP_PROCESSING):
+      return node
+
+    parent_origin = self.ctx.current_origin
+    if anno.hasanno(node, anno.Basic.ORIGIN):
+      self.ctx.current_origin = anno.getanno(node, anno.Basic.ORIGIN)
+
+    try:
+      processing_expr_node = isinstance(node, gast.Expr)
+      if processing_expr_node:
+        entry_expr_value = node.value
+
+      result = super(Base, self).visit(node)
+
+      # Adjust for consistency: replacing the value of an Expr with
+      # an Assign node removes the need for the Expr node.
+      if (processing_expr_node and isinstance(result, gast.Expr) and
+          (result.value is not entry_expr_value)):
+        # When the replacement is a list, it is assumed that the list came
+        # from a template that contained a number of statements, which
+        # themselves are standalone and don't require an enclosing Expr.
+        if isinstance(result.value,
+                      (list, tuple, gast.Assign, gast.AugAssign)):
+          result = result.value
+
+      # By default, all replacements receive the origin info of the replaced
+      # node.
+      if result is not node and result is not None:
+        inherited_origin = anno.getanno(
+            node, anno.Basic.ORIGIN, default=parent_origin)
+        if inherited_origin is not None:
+          nodes_to_adjust = result
+          if isinstance(result, (list, tuple)):
+            nodes_to_adjust = result
+          else:
+            nodes_to_adjust = (result,)
+          for n in nodes_to_adjust:
+            if not anno.hasanno(n, anno.Basic.ORIGIN):
+              anno.setanno(n, anno.Basic.ORIGIN, inherited_origin)
+    finally:
+      self.ctx.current_origin = parent_origin
+
+    return result
+
+
+class CodeGenerator(NodeStateTracker, gast.NodeVisitor):
+  """Base 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
+  """
+
+  def __init__(self, ctx):
+    super(CodeGenerator, self).__init__(ctx)
+
+    self._output_code = ''
+    self.source_map = {}
+
+  def emit(self, code):
+    self._output_code += code
+
+  @property
+  def code_buffer(self):
+    return self._output_code
+
+  def visit(self, node):
+    if anno.hasanno(node, anno.Basic.SKIP_PROCESSING):
+      return
+
+    parent_origin = self.ctx.current_origin
+    eof_before = len(self._output_code)
+    if anno.hasanno(node, anno.Basic.ORIGIN):
+      self.ctx.current_origin = anno.getanno(node, anno.Basic.ORIGIN)
+
+    try:
+      ret = super(CodeGenerator, self).visit(node)
+
+      # By default, all replacements receive the origin info of the replaced
+      # node.
+      eof_after = len(self._output_code)
+      if eof_before - eof_after:
+        inherited_origin = anno.getanno(
+            node, anno.Basic.ORIGIN, default=parent_origin)
+        if inherited_origin is not None:
+          self.source_map[(eof_before, eof_after)] = inherited_origin
+      return ret
+    finally:
+      self.ctx.current_origin = parent_origin

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/transpiler.py

@@ -0,0 +1,496 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Generic source code transformation infrastructure."""
+
+import inspect
+import threading
+import types
+
+import gast
+
+from tensorflow.python.autograph.pyct import cache
+from tensorflow.python.autograph.pyct import inspect_utils
+from tensorflow.python.autograph.pyct import loader
+from tensorflow.python.autograph.pyct import naming
+from tensorflow.python.autograph.pyct import origin_info
+from tensorflow.python.autograph.pyct import parser
+from tensorflow.python.autograph.pyct import templates
+from tensorflow.python.autograph.pyct import transformer
+from tensorflow.python.autograph.utils import ag_logging as logging
+
+
+def _wrap_into_factory(nodes, entity_name, inner_factory_name,
+                       outer_factory_name, closure_vars, factory_args,
+                       future_features):
+  """Wraps an AST into the body of a factory with consistent lexical context.
+
+  The AST is expected to define some symbol with a name given by `entity_name`.
+
+  This mechanism ensures that the resulting transformed entity has lexical
+  scoping identical to that of the source entity, while allowing extra
+  parametrization.
+
+  Two nested factories achieve the following:
+
+   1. The inner factory dynamically creates the entity represented by `nodes`.
+   2. The inner factory is parametrized by a custom set of arguments.
+   3. The inner factory has a closure identical to that of the transformed
+       entity.
+   4. The inner factory has local variables named like `args`, which `nodes` may
+       use as additional parameters.
+   5. The inner factory returns the variables given by `entity_name`.
+   6. The outer factory is niladic.
+   7. The outer factory has no closure.
+   8. The outer factory creates the necessary lexical scope for the inner
+       factory, so that the loaded code has the given configuration for
+       closure/globals.
+   9. The outer factory returns the inner factory.
+
+  Roughly speaking, the following code is generated:
+
+      from __future__ import future_feature_1
+      from __future__ import future_feature_2
+      ...
+
+      def outer_factory():
+        closure_var_1 = None
+        closure_var_2 = None
+        ...
+
+        def inner_factory(arg_1, arg_2, ...):
+          <<nodes>>
+          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
+  """
+  dummy_closure_defs = []
+  for var_name in closure_vars:
+    template = """
+      var_name = None
+    """
+    dummy_closure_defs.extend(templates.replace(template, var_name=var_name))
+
+  if future_features:
+    future_imports = gast.ImportFrom(
+        module='__future__',
+        names=[gast.alias(name=name, asname=None) for name in future_features],
+        level=0)
+  else:
+    future_imports = []
+
+  factory_args = [
+      gast.Name(name, ctx=gast.Param(), annotation=None, type_comment=None)
+      for name in factory_args
+  ]
+
+  template = """
+    future_imports
+    def outer_factory_name():
+      dummy_closure_defs
+      def inner_factory_name(factory_args):
+        entity_defs
+        return entity_name
+      return inner_factory_name
+  """
+  return templates.replace(
+      template,
+      dummy_closure_defs=dummy_closure_defs,
+      entity_defs=nodes,
+      entity_name=entity_name,
+      factory_args=factory_args,
+      future_imports=future_imports,
+      inner_factory_name=inner_factory_name,
+      outer_factory_name=outer_factory_name)
+
+
+class _PythonFnFactory(object):
+  """Helper object that wraps a Python function factory."""
+
+  def __init__(self, name, freevars, extra_locals):
+    """Creates 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.
+    """
+    self._name = name
+    self._freevars = freevars
+    self._extra_locals = extra_locals
+
+    self._unbound_factory = None
+    self.module = None
+    self.source_map = None
+
+  def create(self,
+             nodes,
+             namer,
+             inner_factory_name='inner_factory',
+             outer_factory_name='outer_factory',
+             future_features=()):
+    """Initializes a function."""
+    if self._unbound_factory is not None:
+      raise ValueError('double initialization; create a new object instead')
+
+    inner_factory_name = namer.new_symbol(inner_factory_name, ())
+    outer_factory_name = namer.new_symbol(outer_factory_name, ())
+    nodes = _wrap_into_factory(nodes, self._name, inner_factory_name,
+                               outer_factory_name, self._freevars,
+                               self._extra_locals.keys(), future_features)
+
+    module, _, source_map = loader.load_ast(
+        nodes, include_source_map=True)
+    outer_factory = getattr(module, outer_factory_name)
+    self._unbound_factory = outer_factory()
+    self.module = module
+    self.source_map = source_map
+
+  def instantiate(self,
+                  globals_,
+                  closure,
+                  defaults=None,
+                  kwdefaults=None):
+    """Creates a new function instance."""
+    if self._unbound_factory is None:
+      raise ValueError('call create first')
+
+    factory_code = self._unbound_factory.__code__
+    factory_freevars = factory_code.co_freevars
+    closure_map = dict(zip(self._freevars, closure))
+    factory_closure = tuple(
+        closure_map[name] for name in factory_code.co_freevars)
+    if len(factory_closure) != len(closure):
+      raise ValueError(
+          'closure mismatch, requested {}, but source function had {}'.format(
+              self._freevars, factory_freevars))
+
+    bound_factory = types.FunctionType(
+        code=factory_code,
+        globals=globals_,
+        name=self._name,
+        argdefs=(),
+        closure=factory_closure)
+
+    # The lint override is a false positive.
+    new_fn = bound_factory(**self._extra_locals)  # pylint:disable=not-callable
+
+    if defaults:
+      new_fn.__defaults__ = defaults
+    if kwdefaults:
+      new_fn.__kwdefaults__ = kwdefaults
+
+    return new_fn
+
+
+class GenericTranspiler(object):
+  """A 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 = <<transform node>>
+          return result
+
+      transformer = MyTransformer()
+
+      result = transformer.transform(f, ...)
+      # result is the output
+  """
+
+  def get_transformed_name(self, node):
+    """Returns a name for the output function. Subclasses may override this."""
+    if isinstance(node, gast.Lambda):
+      return 'lam'
+    elif isinstance(node, gast.FunctionDef):
+      return node.name
+    raise ValueError('Unknown node type {}'.format(node))
+
+  def transform_ast(self, node, ctx):
+    """Performs 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.
+    """
+    raise NotImplementedError('subclasses must override this')
+
+  def transform(self, obj, user_context):
+    """Transforms 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.
+    """
+    if inspect.isfunction(obj) or inspect.ismethod(obj):
+      return self.transform_function(obj, user_context)
+
+    raise NotImplementedError('Non-function: {}'.format(type(obj)))
+
+  def _erase_arg_defaults(self, node):
+    """Erase arg default expressions, which would otherwise be unbound."""
+    args = node.args
+    for i in range(len(args.defaults)):
+      args.defaults[i] = parser.parse_expression('None')
+    for i, d in enumerate(args.kw_defaults):
+      if d is not None:
+        args.kw_defaults[i] = parser.parse_expression('None')
+    return node
+
+  def transform_module(self, mod, user_context):
+    """Transforms 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.
+    """
+    result = []
+    for member in mod.__dict__.values():
+      if inspect.ismodule(member):
+        continue  # Not transforming modules recursively.
+      try:
+        result.append(self.transform(member, user_context))
+      except NotImplementedError:
+        pass  # Skip unsupported elements.
+    return result
+
+  def transform_function(self, fn, user_context):
+    """Transforms 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.
+    """
+    future_features = inspect_utils.getfutureimports(fn)
+    node, source = parser.parse_entity(fn, future_features=future_features)
+    logging.log(3, 'Source code of %s:\n\n%s\n', fn, source)
+
+    origin_info.resolve_entity(node, source, fn)
+
+    namespace = inspect_utils.getnamespace(fn)
+    namer = naming.Namer(namespace)
+    new_name = namer.new_symbol(self.get_transformed_name(node), ())
+    entity_info = transformer.EntityInfo(
+        name=new_name,
+        source_code=source,
+        source_file='<fragment>',
+        future_features=future_features,
+        namespace=namespace)
+    context = transformer.Context(entity_info, namer, user_context)
+
+    node = self._erase_arg_defaults(node)
+    result = self.transform_ast(node, context)
+
+    return result, context
+
+
+class PyToPy(GenericTranspiler):
+  """A 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 = <<transform node, usually using ast.NodeTransformer classes>>
+          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`.
+  """
+
+  def __init__(self):
+    self._cache_lock = threading.RLock()
+    self._cache = cache.CodeObjectCache()
+
+  def get_extra_locals(self):
+    """Returns 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.
+    """
+    raise NotImplementedError('subclasses must override this')
+
+  def get_caching_key(self, user_context):
+    """Returns 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.
+    """
+    raise NotImplementedError('subclasses must override this')
+
+  def _cached_factory(self, fn, cache_subkey):
+    cached_factory = self._cache[fn][cache_subkey]
+    logging.log(3, 'Cache hit for %s subkey %s: %s', fn, cache_subkey,
+                cached_factory)
+    return cached_factory
+
+  def transform_function(self, fn, user_context):
+    """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]
+    """
+    cache_subkey = self.get_caching_key(user_context)
+
+    if self._cache.has(fn, cache_subkey):
+      # Fast path: use a lock-free check.
+      factory = self._cached_factory(fn, cache_subkey)
+
+    else:
+      with self._cache_lock:
+        # Check again under lock.
+        if self._cache.has(fn, cache_subkey):
+          factory = self._cached_factory(fn, cache_subkey)
+
+        else:
+          logging.log(1, '%s is not cached for subkey %s', fn, cache_subkey)
+          # TODO(mdan): Confusing overloading pattern. Fix.
+          nodes, ctx = super(PyToPy, self).transform_function(fn, user_context)
+
+          if isinstance(nodes, gast.Lambda):
+            nodes = gast.Assign(
+                targets=[
+                    gast.Name(
+                        ctx.info.name,
+                        ctx=gast.Store(),
+                        annotation=None,
+                        type_comment=None)
+                ],
+                value=nodes)
+          else:
+            nodes.name = ctx.info.name
+
+          if logging.has_verbosity(2):
+            logging.log(2, 'Transformed %s:\n\n%s\n', fn, parser.unparse(nodes))
+
+          factory = _PythonFnFactory(
+              ctx.info.name, fn.__code__.co_freevars, self.get_extra_locals())
+          factory.create(
+              nodes, ctx.namer, future_features=ctx.info.future_features)
+          self._cache[fn][cache_subkey] = factory
+
+    transformed_fn = factory.instantiate(
+        globals_=fn.__globals__,
+        closure=fn.__closure__ or (),
+        defaults=fn.__defaults__,
+        kwdefaults=getattr(fn, '__kwdefaults__', None))
+    return transformed_fn, factory.module, factory.source_map