Add files using upload-large-folder tool

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/_pywrap_checkpoint_reader.pyi

@@ -0,0 +1,25 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+from typing import Any
+
+class CheckpointReader:
+    def __init__(self, arg0: str) -> None: ...
+    @classmethod
+    def CheckpointReader_GetTensor(cls, arg0: CheckpointReader, arg1: str) -> object: ...
+    def _GetVariableToDataTypeMap(self, *args, **kwargs) -> Any: ...
+    def _HasTensor(self, arg0: str) -> bool: ...
+    def debug_string(self) -> bytes: ...
+    def get_variable_to_shape_map(self, *args, **kwargs) -> Any: ...

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/_pywrap_determinism.pyi

@@ -0,0 +1,17 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+def enable(arg0: bool) -> None: ...
+def is_enabled() -> bool: ...

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/_pywrap_kernel_registry.pyi

@@ -0,0 +1,16 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+def TryFindKernelClass(arg0: str) -> bytes: ...

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/_pywrap_nest.pyi

@@ -0,0 +1,16 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+def FlattenDictItems(arg0: object) -> object: ...

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/_pywrap_stat_summarizer.pyi

@@ -0,0 +1,26 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+from typing import overload
+
+class StatSummarizer:
+    @overload
+    def __init__(self, arg0: str) -> None: ...
+    @overload
+    def __init__(self) -> None: ...
+    def GetOutputString(self) -> str: ...
+    def PrintStepStats(self) -> None: ...
+    def ProcessStepStats(self, arg0) -> None: ...
+    def ProcessStepStatsStr(self, arg0: str) -> None: ...

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/_pywrap_tensor_float_32_execution.pyi

@@ -0,0 +1,17 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+def enable(arg0: bool) -> None: ...
+def is_enabled() -> bool: ...

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/_pywrap_transform_graph.pyi

@@ -0,0 +1,16 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+def TransformGraphWithStringInputs(arg0: object, arg1: object, arg2: object, arg3: object) -> bytes: ...

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/_pywrap_utils.pyi

@@ -0,0 +1,35 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+def AssertSameStructure(arg0: object, arg1: object, arg2: bool, arg3: bool) -> bool: ...
+def AssertSameStructureForData(arg0: object, arg1: object, arg2: bool) -> bool: ...
+def Flatten(arg0: object, arg1: bool) -> object: ...
+def FlattenForData(arg0: object) -> object: ...
+def IsAttrs(arg0: object) -> bool: ...
+def IsCompositeTensor(arg0: object) -> bool: ...
+def IsDataTypeSupportedByOneDNNOnThisCPU(arg0) -> bool: ...
+def IsMapping(arg0: object) -> bool: ...
+def IsMappingView(arg0: object) -> bool: ...
+def IsMutableMapping(arg0: object) -> bool: ...
+def IsNamedtuple(arg0: object, arg1: bool) -> object: ...
+def IsNested(arg0: object) -> bool: ...
+def IsNestedForData(arg0: object) -> bool: ...
+def IsNestedOrComposite(arg0: object) -> bool: ...
+def IsResourceVariable(arg0: object) -> bool: ...
+def IsTensor(arg0: object) -> bool: ...
+def IsTypeSpec(arg0: object) -> bool: ...
+def IsVariable(arg0: object) -> bool: ...
+def RegisterPyObject(arg0: object, arg1: object) -> object: ...
+def SameNamedtuples(arg0: object, arg1: object) -> object: ...

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/_tf_stack.pyi

@@ -0,0 +1,64 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+from typing import Iterator
+
+from typing import overload
+
+class GraphDebugInfoBuilder:
+    def __init__(self) -> None: ...
+    def AccumulateStackTrace(self, function: str, op: str, trace) -> None: ...
+    def AppendGraphDebugInfo(self, prefix: str, debug_info: bytes) -> None: ...
+    def Build(self) -> bytes: ...
+
+class PyBindFileSet:
+    def __init__(self) -> None: ...
+    def update_to(self, arg0: set) -> None: ...
+
+class PyBindSourceMap:
+    def __init__(self) -> None: ...
+    def update_to(self, arg0: tuple) -> None: ...
+
+class StackFrame:
+    def __init__(self, *args, **kwargs) -> None: ...
+    def __eq__(self, arg0: StackFrame) -> bool: ...
+    def __getitem__(self, arg0: object) -> object: ...
+    def __hash__(self) -> int: ...
+    def __iter__(self) -> Iterator: ...
+    def __len__(self) -> int: ...
+    def __ne__(self, arg0: StackFrame) -> bool: ...
+    @property
+    def filename(self) -> str: ...
+    @property
+    def line(self) -> str: ...
+    @property
+    def lineno(self) -> int: ...
+    @property
+    def name(self) -> str: ...
+
+class StackTrace:
+    def __init__(self, *args, **kwargs) -> None: ...
+    def get_user_frames(self) -> StackTrace: ...
+    def last_user_frame(self) -> StackFrame: ...
+    def __eq__(self, arg0: StackTrace) -> bool: ...
+    @overload
+    def __getitem__(self, arg0: int) -> StackFrame: ...
+    @overload
+    def __getitem__(self, arg0: slice) -> StackTrace: ...
+    def __hash__(self) -> int: ...
+    def __len__(self) -> int: ...
+
+def LoadTracesFromDebugInfo(debug_info_proto: bytes) -> dict[str,StackTrace]: ...
+def extract_stack(source_map: PyBindSourceMap, file_set: PyBindFileSet, stacklevel: int = ...) -> StackTrace: ...

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/all_util.py

@@ -0,0 +1,117 @@
+# Copyright 2015 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.
+# ==============================================================================
+
+"""Generate __all__ from a module docstring."""
+import re as _re
+import sys as _sys
+
+from tensorflow.python.util import tf_inspect as _tf_inspect
+
+
+_reference_pattern = _re.compile(r'^@@(\w+)$', flags=_re.MULTILINE)
+
+
+def make_all(module_name, doc_string_modules=None):
+  """Generates `__all__` from the docstring of one or more modules.
+
+  Usage: `make_all(__name__)` or
+  `make_all(__name__, [sys.modules(__name__), other_module])`. The doc string
+  modules must each a docstring, and `__all__` will contain all symbols with
+  `@@` references, where that symbol currently exists in the module named
+  `module_name`.
+
+  Args:
+    module_name: The name of the module (usually `__name__`).
+    doc_string_modules: a list of modules from which to take docstring.
+    If None, then a list containing only the module named `module_name` is used.
+
+  Returns:
+    A list suitable for use as `__all__`.
+  """
+  if doc_string_modules is None:
+    doc_string_modules = [_sys.modules[module_name]]
+  cur_members = set(
+      name for name, _ in _tf_inspect.getmembers(_sys.modules[module_name]))
+
+  results = set()
+  for doc_module in doc_string_modules:
+    results.update([m.group(1)
+                    for m in _reference_pattern.finditer(doc_module.__doc__)
+                    if m.group(1) in cur_members])
+  return list(results)
+
+# Hidden attributes are attributes that have been hidden by
+# `remove_undocumented`. They can be re-instated by `reveal_undocumented`.
+# This maps symbol names to a tuple, containing:
+#   (module object, attribute value)
+_HIDDEN_ATTRIBUTES = {}
+
+
+def reveal_undocumented(symbol_name, target_module=None):
+  """Reveals a symbol that was previously removed by `remove_undocumented`.
+
+  This should be used by tensorflow internal tests only. It explicitly
+  defeats the encapsulation afforded by `remove_undocumented`.
+
+  It throws an exception when the symbol was not hidden in the first place.
+
+  Args:
+    symbol_name: a string representing the full absolute path of the symbol.
+    target_module: if specified, the module in which to restore the symbol.
+  """
+  if symbol_name not in _HIDDEN_ATTRIBUTES:
+    raise LookupError('Symbol %s is not a hidden symbol' % symbol_name)
+  symbol_basename = symbol_name.split('.')[-1]
+  (original_module, attr_value) = _HIDDEN_ATTRIBUTES[symbol_name]
+  if not target_module: target_module = original_module
+  setattr(target_module, symbol_basename, attr_value)
+
+
+def remove_undocumented(module_name, allowed_exception_list=None,
+                        doc_string_modules=None):
+  """Removes symbols in a module that are not referenced by a docstring.
+
+  Args:
+    module_name: the name of the module (usually `__name__`).
+    allowed_exception_list: a list of names that should not be removed.
+    doc_string_modules: a list of modules from which to take the docstrings.
+    If None, then a list containing only the module named `module_name` is used.
+
+    Furthermore, if a symbol previously added with `add_to_global_allowlist`,
+    then it will always be allowed. This is useful for internal tests.
+
+  Returns:
+    None
+  """
+  current_symbols = set(dir(_sys.modules[module_name]))
+  should_have = make_all(module_name, doc_string_modules)
+  should_have += allowed_exception_list or []
+  extra_symbols = current_symbols - set(should_have)
+  target_module = _sys.modules[module_name]
+  for extra_symbol in extra_symbols:
+    # Skip over __file__, etc. Also preserves internal symbols.
+    if extra_symbol.startswith('_'): continue
+    fully_qualified_name = module_name + '.' + extra_symbol
+    _HIDDEN_ATTRIBUTES[fully_qualified_name] = (target_module,
+                                                getattr(target_module,
+                                                        extra_symbol))
+    delattr(target_module, extra_symbol)
+
+
+__all__ = [
+    'make_all',
+    'remove_undocumented',
+    'reveal_undocumented',
+]

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/compat.py

@@ -0,0 +1,226 @@
+# Copyright 2015 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.
+# ==============================================================================
+"""Compatibility functions.
+
+The `tf.compat` module contains two sets of compatibility functions.
+
+## Tensorflow 1.x and 2.x APIs
+
+The `compat.v1` and `compat.v2` submodules provide a complete copy of both the
+`v1` and `v2` APIs for backwards and forwards compatibility across TensorFlow
+versions 1.x and 2.x. See the
+[migration guide](https://www.tensorflow.org/guide/migrate) for details.
+
+## Utilities for writing compatible code
+
+Aside from the `compat.v1` and `compat.v2` submodules, `tf.compat` also contains
+a set of helper functions for writing code that works in both:
+
+* TensorFlow 1.x and 2.x
+* Python 2 and 3
+
+
+## Type collections
+
+The compatibility module also provides the following aliases for common
+sets of python types:
+
+* `bytes_or_text_types`
+* `complex_types`
+* `integral_types`
+* `real_types`
+
+API docstring: tensorflow.compat
+"""
+
+import codecs
+import collections.abc as collections_abc  # pylint: disable=unused-import
+import numbers as _numbers
+
+import numpy as _np
+
+from tensorflow.python.util.tf_export import tf_export
+
+
+def as_bytes(bytes_or_text, encoding='utf-8'):
+  """Converts `bytearray`, `bytes`, or unicode python input types to `bytes`.
+
+  Uses utf-8 encoding for text by default.
+
+  Args:
+    bytes_or_text: A `bytearray`, `bytes`, `str`, or `unicode` object.
+    encoding: A string indicating the charset for encoding unicode.
+
+  Returns:
+    A `bytes` object.
+
+  Raises:
+    TypeError: If `bytes_or_text` is not a binary or unicode string.
+  """
+  # Validate encoding, a LookupError will be raised if invalid.
+  encoding = codecs.lookup(encoding).name
+  if isinstance(bytes_or_text, bytearray):
+    return bytes(bytes_or_text)
+  elif isinstance(bytes_or_text, str):
+    return bytes_or_text.encode(encoding)
+  elif isinstance(bytes_or_text, bytes):
+    return bytes_or_text
+  else:
+    raise TypeError('Expected binary or unicode string, got %r' %
+                    (bytes_or_text,))
+
+
+def as_text(bytes_or_text, encoding='utf-8'):
+  """Converts any string-like python input types to unicode.
+
+  Returns the input as a unicode string. Uses utf-8 encoding for text
+  by default.
+
+  Args:
+    bytes_or_text: A `bytes`, `str`, or `unicode` object.
+    encoding: A string indicating the charset for decoding unicode.
+
+  Returns:
+    A `unicode` (Python 2) or `str` (Python 3) object.
+
+  Raises:
+    TypeError: If `bytes_or_text` is not a binary or unicode string.
+  """
+  # Validate encoding, a LookupError will be raised if invalid.
+  encoding = codecs.lookup(encoding).name
+  if isinstance(bytes_or_text, str):
+    return bytes_or_text
+  elif isinstance(bytes_or_text, bytes):
+    return bytes_or_text.decode(encoding)
+  else:
+    raise TypeError('Expected binary or unicode string, got %r' % bytes_or_text)
+
+
+def as_str(bytes_or_text, encoding='utf-8'):
+  """Acts as an alias for the `as_text` function..
+
+  Args:
+    bytes_or_text: The input value to be converted. A bytes or unicode object.
+    encoding: Optional string. The encoding to use if bytes_or_text is a bytes
+      object. Defaults to 'utf-8'.
+
+  Returns:
+    A unicode string.
+
+  Raises:
+    TypeError: If bytes_or_text is not a bytes or unicode object.
+    UnicodeDecodeError: If bytes_or_text is a bytes object and cannot be
+                        decoded using the specified encoding.
+  """
+  return as_text(bytes_or_text, encoding)
+
+tf_export('compat.as_text')(as_text)
+tf_export('compat.as_bytes')(as_bytes)
+tf_export('compat.as_str')(as_str)
+
+
+@tf_export('compat.as_str_any')
+def as_str_any(value, encoding='utf-8'):
+  """Converts input to `str` type.
+
+     Uses `str(value)`, except for `bytes` typed inputs, which are converted
+     using `as_str`.
+
+  Args:
+    value: A object that can be converted to `str`.
+    encoding: Encoding for `bytes` typed inputs.
+
+  Returns:
+    A `str` object.
+  """
+  if isinstance(value, bytes):
+    return as_str(value, encoding=encoding)
+  else:
+    return str(value)
+
+
+@tf_export('compat.path_to_str')
+def path_to_str(path):
+  r"""Converts input which is a `PathLike` object to `str` type.
+
+  Converts from any python constant representation of a `PathLike` object to
+  a string. If the input is not a `PathLike` object, simply returns the input.
+
+  Args:
+    path: An object that can be converted to path representation.
+
+  Returns:
+    A `str` object.
+
+  Usage:
+    In case a simplified `str` version of the path is needed from an
+    `os.PathLike` object.
+
+  Examples:
+  ```python
+  $ tf.compat.path_to_str('C:\XYZ\tensorflow\./.././tensorflow')
+  'C:\XYZ\tensorflow\./.././tensorflow' # Windows OS
+  $ tf.compat.path_to_str(Path('C:\XYZ\tensorflow\./.././tensorflow'))
+  'C:\XYZ\tensorflow\..\tensorflow' # Windows OS
+  $ tf.compat.path_to_str(Path('./corpus'))
+  'corpus' # Linux OS
+  $ tf.compat.path_to_str('./.././Corpus')
+  './.././Corpus' # Linux OS
+  $ tf.compat.path_to_str(Path('./.././Corpus'))
+  '../Corpus' # Linux OS
+  $ tf.compat.path_to_str(Path('./..////../'))
+  '../..' # Linux OS
+
+  ```
+  """
+  if hasattr(path, '__fspath__'):
+    path = as_str_any(path.__fspath__())
+  return path
+
+
+def path_to_bytes(path):
+  r"""Converts input which is a `PathLike` object to `bytes`.
+
+  Converts from any python constant representation of a `PathLike` object
+  or `str` to bytes.
+
+  Args:
+    path: An object that can be converted to path representation.
+
+  Returns:
+    A `bytes` object.
+
+  Usage:
+    In case a simplified `bytes` version of the path is needed from an
+    `os.PathLike` object.
+  """
+  if hasattr(path, '__fspath__'):
+    path = path.__fspath__()
+  return as_bytes(path)
+
+
+# Numpy 1.8 scalars don't inherit from numbers.Integral in Python 3, so we
+# need to check them specifically.  The same goes from Real and Complex.
+integral_types = (_numbers.Integral, _np.integer)
+tf_export('compat.integral_types').export_constant(__name__, 'integral_types')
+real_types = (_numbers.Real, _np.integer, _np.floating)
+tf_export('compat.real_types').export_constant(__name__, 'real_types')
+complex_types = (_numbers.Complex, _np.number)
+tf_export('compat.complex_types').export_constant(__name__, 'complex_types')
+
+# Either bytes or text.
+bytes_or_text_types = (bytes, str)
+tf_export('compat.bytes_or_text_types').export_constant(__name__,
+                                                        'bytes_or_text_types')

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/custom_nest_protocol.py

@@ -0,0 +1,120 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+"""Protocol class for custom tf.nest support."""
+
+import typing
+from typing import Protocol
+
+
+@typing.runtime_checkable
+class CustomNestProtocol(Protocol):
+  """Protocol for adding custom tf.nest support in user-defined classes.
+
+  User classes should implement the two methods defined in this protocol in
+  order to be supported by nest functions.
+    - `__tf_flatten__` for generating the flattened components and the metadata
+      of the current object.
+    - `__tf_unflatten__` for creating a new object based on the input metadata
+      and the components.
+  See the method doc for details.
+
+  In terms of support level, classes implementing this protocol
+    - are supported by tf.nest and tf.data functions.
+    - have limited support from tf.function, which requires writing a custom
+      TraceType subclass to be used as the input or output of a tf.function.
+    - are NOT supported by SavedModel.
+
+  Code Examples:
+
+  >>> import dataclasses
+  >>> @dataclasses.dataclass
+  ... class MaskedTensor:
+  ...   mask: bool
+  ...   value: tf.Tensor
+  ...
+  ...   def __tf_flatten__(self):
+  ...     metadata = (self.mask,)  # static config.
+  ...     components = (self.value,)  # dynamic values.
+  ...     return metadata, components
+  ...
+  ...   @classmethod
+  ...   def __tf_unflatten__(cls, metadata, components):
+  ...     mask = metadata[0]
+  ...     value = components[0]
+  ...     return MaskedTensor(mask=mask, value=value)
+  ...
+  >>> mt = MaskedTensor(mask=True, value=tf.constant([1]))
+  >>> mt
+  MaskedTensor(mask=True, value=<tf.Tensor: ... numpy=array([1], dtype=int32)>)
+  >>> tf.nest.is_nested(mt)
+  True
+  >>> mt2 = MaskedTensor(mask=False, value=tf.constant([2]))
+  >>> tf.nest.assert_same_structure(mt, mt2)
+
+  >>> leaves = tf.nest.flatten(mt)
+  >>> leaves
+  [<tf.Tensor: shape=(1,), dtype=int32, numpy=array([1], dtype=int32)>]
+
+  >>> mt3 = tf.nest.pack_sequence_as(mt, leaves)
+  >>> mt3
+  MaskedTensor(mask=True, value=<tf.Tensor: ... numpy=array([1], dtype=int32)>)
+  >>> bool(mt == mt3)
+  True
+
+  >>> tf.nest.map_structure(lambda x: x * 2, mt)
+  MaskedTensor(mask=True, value=<tf.Tensor: ... numpy=array([2], dtype=int32)>)
+
+  More examples are available in the unit tests (nest_test.py).
+  """
+
+  def __tf_flatten__(self):
+    """Flatten current object into (metadata, components).
+
+    Returns:
+      A `tuple` of (metadata, components), where
+        - metadata is a custom Python object that stands for the static config
+          of the current object, which is supposed to be fixed and not affected
+          by data transformation.
+        - components is a `tuple` that contains the modifiable fields of the
+          current object.
+
+    Implementation Note:
+    - This method should not invoke any TensorFlow ops.
+    - This method only needs to flatten the current level. If current object has
+      an attribute that also need custom flattening, nest functions (such as
+      `nest.flatten`) will utilize this method to do recursive flattening.
+    - Components must ba a `tuple`, not a `list`
+    """
+
+  @classmethod
+  def __tf_unflatten__(cls, metadata, components):
+    """Create a user-defined object from (metadata, components).
+
+    Args:
+      metadata: a custom Python objet that stands for the static config for
+        reconstructing a new object of the current class.
+      components: a `tuple` that contains the dynamic data fields of the current
+        class, for object reconstruction.
+
+    Returns:
+      The user-defined object, with the same class of the current object.
+
+    Implementation Note:
+    - This method should not invoke any TensorFlow ops.
+    - This method only needs to unflatten the current level. If the object has
+      an attribute that also need custom unflattening, nest functions will
+      utilize this method to do recursive unflattening.
+    """

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/decorator_utils.py

@@ -0,0 +1,203 @@
+# 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.
+# ==============================================================================
+
+"""Utility functions for writing decorators (which modify docstrings)."""
+import sys
+
+
+def get_qualified_name(function):
+  # Python 3
+  if hasattr(function, '__qualname__'):
+    return function.__qualname__
+
+  # Python 2
+  if hasattr(function, 'im_class'):
+    return function.im_class.__name__ + '.' + function.__name__
+  return function.__name__
+
+
+def _normalize_docstring(docstring):
+  """Normalizes the docstring.
+
+  Replaces tabs with spaces, removes leading and trailing blanks lines, and
+  removes any indentation.
+
+  Copied from PEP-257:
+  https://www.python.org/dev/peps/pep-0257/#handling-docstring-indentation
+
+  Args:
+    docstring: the docstring to normalize
+
+  Returns:
+    The normalized docstring
+  """
+  if not docstring:
+    return ''
+  # Convert tabs to spaces (following the normal Python rules)
+  # and split into a list of lines:
+  lines = docstring.expandtabs().splitlines()
+  # Determine minimum indentation (first line doesn't count):
+  # (we use sys.maxsize because sys.maxint doesn't exist in Python 3)
+  indent = sys.maxsize
+  for line in lines[1:]:
+    stripped = line.lstrip()
+    if stripped:
+      indent = min(indent, len(line) - len(stripped))
+  # Remove indentation (first line is special):
+  trimmed = [lines[0].strip()]
+  if indent < sys.maxsize:
+    for line in lines[1:]:
+      trimmed.append(line[indent:].rstrip())
+  # Strip off trailing and leading blank lines:
+  while trimmed and not trimmed[-1]:
+    trimmed.pop()
+  while trimmed and not trimmed[0]:
+    trimmed.pop(0)
+  # Return a single string:
+  return '\n'.join(trimmed)
+
+
+def add_notice_to_docstring(doc,
+                            instructions,
+                            no_doc_str,
+                            suffix_str,
+                            notice,
+                            notice_type='Warning'):
+  """Adds a deprecation notice to a docstring.
+
+  Args:
+    doc: The original docstring.
+    instructions: A string, describing how to fix the problem.
+    no_doc_str: The default value to use for `doc` if `doc` is empty.
+    suffix_str: Is added to the end of the first line.
+    notice: A list of strings. The main notice warning body.
+    notice_type: The type of notice to use. Should be one of `[Caution,
+    Deprecated, Important, Note, Warning]`
+
+  Returns:
+    A new docstring, with the notice attached.
+
+  Raises:
+    ValueError: If `notice` is empty.
+  """
+  allowed_notice_types = ['Deprecated', 'Warning', 'Caution', 'Important',
+                          'Note']
+  if notice_type not in allowed_notice_types:
+    raise ValueError(
+        f'Unrecognized notice type. Should be one of: {allowed_notice_types}')
+
+  if not doc:
+    lines = [no_doc_str]
+  else:
+    lines = _normalize_docstring(doc).splitlines()
+    lines[0] += ' ' + suffix_str
+
+  if not notice:
+    raise ValueError('The `notice` arg must not be empty.')
+
+  notice[0] = f'{notice_type}: {notice[0]}'
+  notice = [''] + notice + ([instructions] if instructions else [])
+
+  if len(lines) > 1:
+    # Make sure that we keep our distance from the main body
+    if lines[1].strip():
+      notice.append('')
+
+    lines[1:1] = notice
+  else:
+    lines += notice
+
+  return '\n'.join(lines)
+
+
+def validate_callable(func, decorator_name):
+  if not hasattr(func, '__call__'):
+    raise ValueError(
+        '%s is not a function. If this is a property, make sure'
+        ' @property appears before @%s in your source code:'
+        '\n\n@property\n@%s\ndef method(...)' % (
+            func, decorator_name, decorator_name))
+
+
+class classproperty(object):  # pylint: disable=invalid-name
+  """Class property decorator.
+
+  Example usage:
+
+  class MyClass(object):
+
+    @classproperty
+    def value(cls):
+      return '123'
+
+  > print MyClass.value
+  123
+  """
+
+  def __init__(self, func):
+    self._func = func
+
+  def __get__(self, owner_self, owner_cls):
+    return self._func(owner_cls)
+
+
+class _CachedClassProperty(object):
+  """Cached class property decorator.
+
+  Transforms a class method into a property whose value is computed once
+  and then cached as a normal attribute for the life of the class.  Example
+  usage:
+
+  >>> class MyClass(object):
+  ...   @cached_classproperty
+  ...   def value(cls):
+  ...     print("Computing value")
+  ...     return '<property of %s>' % cls.__name__
+  >>> class MySubclass(MyClass):
+  ...   pass
+  >>> MyClass.value
+  Computing value
+  '<property of MyClass>'
+  >>> MyClass.value  # uses cached value
+  '<property of MyClass>'
+  >>> MySubclass.value
+  Computing value
+  '<property of MySubclass>'
+
+  This decorator is similar to `functools.cached_property`, but it adds a
+  property to the class, not to individual instances.
+  """
+
+  def __init__(self, func):
+    self._func = func
+    self._cache = {}
+
+  def __get__(self, obj, objtype):
+    if objtype not in self._cache:
+      self._cache[objtype] = self._func(objtype)
+    return self._cache[objtype]
+
+  def __set__(self, obj, value):
+    raise AttributeError('property %s is read-only' % self._func.__name__)
+
+  def __delete__(self, obj):
+    raise AttributeError('property %s is read-only' % self._func.__name__)
+
+
+def cached_classproperty(func):
+  return _CachedClassProperty(func)
+
+
+cached_classproperty.__doc__ = _CachedClassProperty.__doc__

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/deprecated_module.py

@@ -0,0 +1,24 @@
+# Copyright 2022 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 deprecated module.
+
+For testing `deprecation.deprecate_moved_module`.
+"""
+
+from tensorflow.python.util import deprecated_module_new
+from tensorflow.python.util import deprecation
+
+__getattr__ = deprecation.deprecate_moved_module(
+    __name__, deprecated_module_new, "2.9")

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/deprecated_module_new.py

@@ -0,0 +1,22 @@
+# Copyright 2022 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 module to replace deprecated_module.
+
+For testing `deprecation.deprecate_moved_module`.
+"""
+
+
+def a():
+  return 1

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/deprecation.py

@@ -0,0 +1,763 @@
+# 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.
+# ==============================================================================
+"""Tensor utility functions."""
+import collections
+import functools
+import inspect
+import re
+
+from tensorflow.python.framework import strict_mode
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.util import decorator_utils
+from tensorflow.python.util import is_in_graph_mode
+from tensorflow.python.util import tf_contextlib
+from tensorflow.python.util import tf_decorator
+from tensorflow.python.util import tf_inspect
+from tensorflow.tools.docs import doc_controls
+
+# Allow deprecation warnings to be silenced temporarily with a context manager.
+_PRINT_DEPRECATION_WARNINGS = True
+
+# Remember which deprecation warnings have been printed already.
+_PRINTED_WARNING = {}
+
+
+class DeprecatedNamesAlreadySetError(Exception):
+  """Raised when setting deprecated names multiple times for the same symbol."""
+
+
+def _log_deprecation(msg, *args, **kwargs):
+  """Raises errors for deprecated methods if in strict mode, warns otherwise."""
+  if strict_mode.STRICT_MODE:
+    logging.error(msg, *args, **kwargs)
+    raise RuntimeError(
+        'This behavior has been deprecated, which raises an error in strict'
+        ' mode.'
+    )
+  else:
+    logging.warning(msg, *args, **kwargs)
+
+
+def _add_deprecated_function_notice_to_docstring(doc, date, instructions):
+  """Adds a deprecation notice to a docstring for deprecated functions."""
+  main_text = [
+      'THIS FUNCTION IS DEPRECATED. It will be removed %s.'
+      % ('in a future version' if date is None else ('after %s' % date))
+  ]
+  if instructions:
+    main_text.append('Instructions for updating:')
+  return decorator_utils.add_notice_to_docstring(
+      doc,
+      instructions,
+      'DEPRECATED FUNCTION',
+      '(deprecated)',
+      main_text,
+      notice_type='Deprecated')
+
+
+def _add_deprecated_arg_notice_to_docstring(doc, date, instructions,
+                                            deprecated_names):
+  """Adds a deprecation notice to a docstring for deprecated arguments."""
+
+  deprecation_string = ', '.join(sorted(deprecated_names))
+
+  return decorator_utils.add_notice_to_docstring(
+      doc,
+      instructions,
+      'DEPRECATED FUNCTION ARGUMENTS',
+      '(deprecated arguments)', [
+          'SOME ARGUMENTS ARE DEPRECATED: `(%s)`. '
+          'They will be removed %s.' %
+          (deprecation_string, 'in a future version' if date is None else
+           ('after %s' % date)), 'Instructions for updating:'
+      ],
+      notice_type='Deprecated')
+
+
+def _add_deprecated_arg_value_notice_to_docstring(doc, date, instructions,
+                                                  deprecated_name_value_dict):
+  """Adds a deprecation notice to a docstring for deprecated arguments."""
+
+  deprecation_string = ', '.join(
+      '%s=%r' % (key, value)
+      for key, value in sorted(deprecated_name_value_dict.items()))
+
+  when = 'in a future version' if date is None else ('after %s' % date)
+
+  return decorator_utils.add_notice_to_docstring(
+      doc,
+      instructions,
+      'DEPRECATED FUNCTION ARGUMENT VALUES',
+      '(deprecated argument values)', [
+          'SOME ARGUMENT VALUES ARE DEPRECATED: `(%s)`. '
+          'They will be removed %s.' %
+          (deprecation_string, when), 'Instructions for updating:'
+      ],
+      notice_type='Deprecated')
+
+
+def _validate_deprecation_args(date, instructions):
+  if date is not None and not re.match(r'20\d\d-[01]\d-[0123]\d', date):
+    raise ValueError(f'Date must be in format YYYY-MM-DD. Received: {date}')
+  if not instructions:
+    raise ValueError(
+        'Don\'t deprecate things without conversion instructions! Specify '
+        'the `instructions` argument.')
+
+
+def _call_location(outer=False):
+  """Returns call location given level up from current call."""
+  # Two up: <_call_location>, <_call_location's caller>
+  # tf_inspect is not required here. Please ignore the lint warning by adding
+  # DISABLE_IMPORT_INSPECT_CHECK=TRUE to your cl description. Using it caused
+  # test timeouts (b/189384061).
+  f = inspect.currentframe().f_back.f_back
+  parent = f and f.f_back
+  if outer and parent is not None:
+    f = parent
+  return '{}:{}'.format(f.f_code.co_filename, f.f_lineno)
+
+
+def _safe_eq(a, b):
+  if a is None or b is None:
+    return a is None and b is None
+  return a == b
+
+
+def _wrap_decorator(wrapped_function, decorator_name):
+  """Indicate that one function wraps another.
+
+  This decorator wraps a function using `tf_decorator.make_decorator`
+  so that doc generation scripts can pick up original function
+  signature.
+  It would be better to use @functools.wrap decorator, but it would
+  not update function signature to match wrapped function in Python 2.
+
+  Args:
+    wrapped_function: The function that decorated function wraps.
+    decorator_name: The name of the decorator.
+
+  Returns:
+    Function that accepts wrapper function as an argument and returns
+    `TFDecorator` instance.
+  """
+
+  def wrapper(wrapper_func):
+    return tf_decorator.make_decorator(wrapped_function, wrapper_func,
+                                       decorator_name)
+
+  return wrapper
+
+
+def deprecated_alias(deprecated_name, name, func_or_class, warn_once=True):
+  """Deprecate a symbol in favor of a new name with identical semantics.
+
+  This function is meant to be used when defining a backwards-compatibility
+  alias for a symbol which has been moved. For example:
+
+  module1.py:
+  ```python
+  class NewNameForClass: pass
+  ```
+
+  module2.py:
+  ```python
+  import module1
+
+  DeprecatedNameForClass = deprecated_alias(
+    deprecated_name='module2.DeprecatedNameForClass',
+    name='module1.NewNameForClass',
+    func_or_class=module1.NewNameForClass)
+  ```
+
+  This function works for classes and functions.
+
+  For classes, it creates a new class which is functionally identical (it
+  inherits from the original, and overrides its constructor), but which prints
+  a deprecation warning when an instance is created. It also adds a deprecation
+  notice to the class' docstring.
+
+  For functions, it returns a function wrapped by `tf_decorator.make_decorator`.
+  That function prints a warning when used, and has a deprecation notice in its
+  docstring. This is more or less equivalent (the deprecation warning has
+  slightly different text) to writing:
+
+  ```python
+  @deprecated
+  def deprecated_alias(original_args):
+    real_function(original_args)
+  ```
+
+  Args:
+    deprecated_name: The name of the symbol that is being deprecated, to be used
+      in the warning message. This should be its fully qualified name to avoid
+      confusion.
+    name: The name of the symbol that is to be used instead of the deprecated
+      name. This should be a fully qualified name to avoid confusion.
+    func_or_class: The (non-deprecated) class or function for which a deprecated
+      alias should be created.
+    warn_once: If True (the default), only print a deprecation warning the first
+      time this function is used, or the class is instantiated.
+
+  Returns:
+    A wrapped version of `func_or_class` which prints a deprecation warning on
+    use and has a modified docstring.
+  """
+  if tf_inspect.isclass(func_or_class):
+
+    # Make a new class with __init__ wrapped in a warning.
+    class _NewClass(func_or_class):  # pylint: disable=missing-docstring
+      __doc__ = decorator_utils.add_notice_to_docstring(
+          func_or_class.__doc__,
+          'Please use %s instead.' % name,
+          'DEPRECATED CLASS',
+          '(deprecated)', [('THIS CLASS IS DEPRECATED. '
+                            'It will be removed in a future version. ')],
+          notice_type='Deprecated')
+      __name__ = func_or_class.__name__
+      __module__ = _call_location(outer=True)
+
+      @_wrap_decorator(func_or_class.__init__, 'deprecated_alias')
+      def __init__(self, *args, **kwargs):
+        if hasattr(_NewClass.__init__, '__func__'):
+          # Python 2
+          _NewClass.__init__.__func__.__doc__ = func_or_class.__init__.__doc__
+        else:
+          # Python 3
+          _NewClass.__init__.__doc__ = func_or_class.__init__.__doc__
+
+        if _PRINT_DEPRECATION_WARNINGS:
+          # We're making the alias as we speak. The original may have other
+          # aliases, so we cannot use it to check for whether it's already been
+          # warned about.
+          if _NewClass.__init__ not in _PRINTED_WARNING:
+            if warn_once:
+              _PRINTED_WARNING[_NewClass.__init__] = True
+            _log_deprecation(
+                'From %s: The name %s is deprecated. Please use %s instead.\n',
+                _call_location(), deprecated_name, name)
+        super(_NewClass, self).__init__(*args, **kwargs)
+
+    return _NewClass
+  else:
+    decorator_utils.validate_callable(func_or_class, 'deprecated')
+
+    # Make a wrapper for the original
+    @functools.wraps(func_or_class)
+    def new_func(*args, **kwargs):  # pylint: disable=missing-docstring
+      if _PRINT_DEPRECATION_WARNINGS:
+        # We're making the alias as we speak. The original may have other
+        # aliases, so we cannot use it to check for whether it's already been
+        # warned about.
+        if new_func not in _PRINTED_WARNING:
+          if warn_once:
+            _PRINTED_WARNING[new_func] = True
+          _log_deprecation(
+              'From %s: The name %s is deprecated. Please use %s instead.\n',
+              _call_location(), deprecated_name, name)
+      return func_or_class(*args, **kwargs)
+
+    return tf_decorator.make_decorator(
+        func_or_class, new_func, 'deprecated',
+        _add_deprecated_function_notice_to_docstring(
+            func_or_class.__doc__, None, 'Please use %s instead.' % name))
+
+
+def deprecated_endpoints(*args):
+  """Decorator for marking endpoints deprecated.
+
+  This decorator does not print deprecation messages.
+  TODO(annarev): eventually start printing deprecation warnings when
+  @deprecation_endpoints decorator is added.
+
+  Args:
+    *args: Deprecated endpoint names.
+
+  Returns:
+    A function that takes symbol as an argument and adds
+    _tf_deprecated_api_names to that symbol.
+    _tf_deprecated_api_names would be set to a list of deprecated
+    endpoint names for the symbol.
+  """
+
+  def deprecated_wrapper(func):
+    # pylint: disable=protected-access
+    if '_tf_deprecated_api_names' in func.__dict__:
+      raise DeprecatedNamesAlreadySetError(
+          f'Cannot set deprecated names for {func.__name__} to {args}. '
+          'Deprecated names are already set to '
+          f'{func._tf_deprecated_api_names}.')
+    func._tf_deprecated_api_names = args
+    # pylint: disable=protected-access
+    return func
+
+  return deprecated_wrapper
+
+
+def deprecated(date, instructions, warn_once=True):
+  """Decorator for marking functions or methods deprecated.
+
+  This decorator logs a deprecation warning whenever the decorated function is
+  called. It has the following format:
+
+    <function> (from <module>) is deprecated and will be removed after <date>.
+    Instructions for updating:
+    <instructions>
+
+  If `date` is None, 'after <date>' is replaced with 'in a future version'.
+  <function> will include the class name if it is a method.
+
+  It also edits the docstring of the function: ' (deprecated)' is appended
+  to the first line of the docstring and a deprecation notice is prepended
+  to the rest of the docstring.
+
+  Args:
+    date: String or None. The date the function is scheduled to be removed. Must
+      be ISO 8601 (YYYY-MM-DD), or None.
+    instructions: String. Instructions on how to update code using the
+      deprecated function.
+    warn_once: Boolean. Set to `True` to warn only the first time the decorated
+      function is called. Otherwise, every call will log a warning.
+
+  Returns:
+    Decorated function or method.
+
+  Raises:
+    ValueError: If date is not None or in ISO 8601 format, or instructions are
+      empty.
+  """
+  _validate_deprecation_args(date, instructions)
+
+  def deprecated_wrapper(func_or_class):
+    """Deprecation wrapper."""
+    if isinstance(func_or_class, type):
+      # If a class is deprecated, you actually want to wrap the constructor.
+      cls = func_or_class
+      if cls.__new__ is object.__new__:
+        # If a class defaults to its parent's constructor, wrap that instead.
+        func = cls.__init__
+        constructor_name = '__init__'
+        decorators, _ = tf_decorator.unwrap(func)
+        for decorator in decorators:
+          if decorator.decorator_name == 'deprecated':
+            # If the parent is already deprecated, there's nothing to do.
+            return cls
+      else:
+        func = cls.__new__
+        constructor_name = '__new__'
+
+    else:
+      cls = None
+      constructor_name = None
+      func = func_or_class
+
+    decorator_utils.validate_callable(func, 'deprecated')
+
+    @_wrap_decorator(func, 'deprecated')
+    def new_func(*args, **kwargs):  # pylint: disable=missing-docstring
+      if _PRINT_DEPRECATION_WARNINGS:
+        if func not in _PRINTED_WARNING and cls not in _PRINTED_WARNING:
+          if warn_once:
+            _PRINTED_WARNING[func] = True
+            if cls:
+              _PRINTED_WARNING[cls] = True
+          _log_deprecation(
+              'From %s: %s (from %s) is deprecated and will be removed %s.\n'
+              'Instructions for updating:\n%s', _call_location(),
+              decorator_utils.get_qualified_name(func),
+              func_or_class.__module__,
+              'in a future version' if date is None else ('after %s' % date),
+              instructions)
+      return func(*args, **kwargs)
+
+    doc_controls.set_deprecated(new_func)
+    new_func = tf_decorator.make_decorator(
+        func, new_func, 'deprecated',
+        _add_deprecated_function_notice_to_docstring(func.__doc__, date,
+                                                     instructions))
+    new_func.__signature__ = inspect.signature(func)
+
+    if cls is None:
+      return new_func
+    else:
+      # Insert the wrapped function as the constructor
+      setattr(cls, constructor_name, new_func)
+
+      # And update the docstring of the class.
+      cls.__doc__ = _add_deprecated_function_notice_to_docstring(
+          cls.__doc__, date, instructions)
+
+      return cls
+
+  return deprecated_wrapper
+
+
+DeprecatedArgSpec = collections.namedtuple(
+    'DeprecatedArgSpec', ['position', 'has_ok_value', 'ok_value'])
+
+
+def deprecated_args(date, instructions, *deprecated_arg_names_or_tuples,
+                    **kwargs):
+  """Decorator for marking specific function arguments as deprecated.
+
+  This decorator logs a deprecation warning whenever the decorated function is
+  called with the deprecated argument. It has the following format:
+
+    Calling <function> (from <module>) with <arg> is deprecated and will be
+    removed after <date>. Instructions for updating:
+      <instructions>
+
+  If `date` is None, 'after <date>' is replaced with 'in a future version'.
+  <function> includes the class name if it is a method.
+
+  It also edits the docstring of the function: ' (deprecated arguments)' is
+  appended to the first line of the docstring and a deprecation notice is
+  prepended to the rest of the docstring.
+
+  Args:
+    date: String or None. The date the function is scheduled to be removed. Must
+      be ISO 8601 (YYYY-MM-DD), or None.
+    instructions: String. Instructions on how to update code using the
+      deprecated function.
+    *deprecated_arg_names_or_tuples: String or 2-Tuple (String, ok_val).  The
+      string is the deprecated argument name. Optionally, an ok-value may be
+      provided.  If the user provided argument equals this value, the warning is
+      suppressed.
+    **kwargs: If `warn_once=False` is passed, every call with a deprecated
+      argument will log a warning. The default behavior is to only warn the
+      first time the function is called with any given deprecated argument. All
+      other kwargs raise `ValueError`.
+
+  Returns:
+    Decorated function or method.
+
+  Raises:
+    ValueError: If date is not None or in ISO 8601 format, instructions are
+      empty, the deprecated arguments are not present in the function
+      signature, the second element of a deprecated_tuple is not a
+      list, or if a kwarg other than `warn_once` is passed.
+  """
+  _validate_deprecation_args(date, instructions)
+  if not deprecated_arg_names_or_tuples:
+    raise ValueError('Specify which argument is deprecated.')
+  if kwargs and list(kwargs.keys()) != ['warn_once']:
+    kwargs.pop('warn_once', None)
+    raise ValueError(f'Illegal argument passed to deprecated_args: {kwargs}')
+  warn_once = kwargs.get('warn_once', True)
+
+  def _get_arg_names_to_ok_vals():
+    """Returns a dict mapping arg_name to DeprecatedArgSpec w/o position."""
+    d = {}
+    for name_or_tuple in deprecated_arg_names_or_tuples:
+      if isinstance(name_or_tuple, tuple):
+        d[name_or_tuple[0]] = DeprecatedArgSpec(-1, True, name_or_tuple[1])
+      else:
+        d[name_or_tuple] = DeprecatedArgSpec(-1, False, None)
+    return d
+
+  def _get_deprecated_positional_arguments(names_to_ok_vals, arg_spec):
+    """Builds a dictionary from deprecated arguments to their spec.
+
+    Returned dict is keyed by argument name.
+    Each value is a DeprecatedArgSpec with the following fields:
+       position: The zero-based argument position of the argument
+         within the signature.  None if the argument isn't found in
+         the signature.
+       ok_values:  Values of this argument for which warning will be
+         suppressed.
+
+    Args:
+      names_to_ok_vals: dict from string arg_name to a list of values, possibly
+        empty, which should not elicit a warning.
+      arg_spec: Output from tf_inspect.getfullargspec on the called function.
+
+    Returns:
+      Dictionary from arg_name to DeprecatedArgSpec.
+    """
+    # Extract argument list
+    arg_space = arg_spec.args + arg_spec.kwonlyargs
+    arg_name_to_pos = {name: pos for pos, name in enumerate(arg_space)}
+    deprecated_positional_args = {}
+    for arg_name, spec in iter(names_to_ok_vals.items()):
+      if arg_name in arg_name_to_pos:
+        pos = arg_name_to_pos[arg_name]
+        deprecated_positional_args[arg_name] = DeprecatedArgSpec(
+            pos, spec.has_ok_value, spec.ok_value)
+    return deprecated_positional_args
+
+  deprecated_arg_names = _get_arg_names_to_ok_vals()
+
+  def deprecated_wrapper(func):
+    """Deprecation decorator."""
+    decorator_utils.validate_callable(func, 'deprecated_args')
+
+    arg_spec = tf_inspect.getfullargspec(func)
+    deprecated_positions = _get_deprecated_positional_arguments(
+        deprecated_arg_names, arg_spec)
+
+    is_varargs_deprecated = arg_spec.varargs in deprecated_arg_names
+    is_kwargs_deprecated = arg_spec.varkw in deprecated_arg_names
+
+    if (len(deprecated_positions) + is_varargs_deprecated + is_kwargs_deprecated
+        != len(deprecated_arg_names_or_tuples)):
+      known_args = (
+          arg_spec.args + arg_spec.kwonlyargs +
+          [arg_spec.varargs, arg_spec.varkw])
+      missing_args = [
+          arg_name for arg_name in deprecated_arg_names
+          if arg_name not in known_args
+      ]
+      raise ValueError('The following deprecated arguments are not present '
+                       f'in the function signature: {missing_args}. '
+                       'Expected arguments from the following list: '
+                       f'{known_args}.')
+
+    def _same_value(a, b):
+      """A comparison operation that works for multiple object types.
+
+      Returns True for two empty lists, two numeric values with the
+      same value, etc.
+
+      Returns False for (pd.DataFrame, None), and other pairs which
+      should not be considered equivalent.
+
+      Args:
+        a: value one of the comparison.
+        b: value two of the comparison.
+
+      Returns:
+        A boolean indicating whether the two inputs are the same value
+        for the purposes of deprecation.
+      """
+      if a is b:
+        return True
+      try:
+        equality = a == b
+        if isinstance(equality, bool):
+          return equality
+      except TypeError:
+        return False
+      return False
+
+    @functools.wraps(func)
+    def new_func(*args, **kwargs):
+      """Deprecation wrapper."""
+      # TODO(apassos) figure out a way to have reasonable performance with
+      # deprecation warnings and eager mode.
+      if is_in_graph_mode.IS_IN_GRAPH_MODE() and _PRINT_DEPRECATION_WARNINGS:
+        invalid_args = []
+        named_args = tf_inspect.getcallargs(func, *args, **kwargs)
+        for arg_name, spec in iter(deprecated_positions.items()):
+          if (spec.position < len(args) and
+              not (spec.has_ok_value and
+                   _same_value(named_args[arg_name], spec.ok_value))):
+            invalid_args.append(arg_name)
+        if is_varargs_deprecated and len(args) > len(arg_spec.args):
+          invalid_args.append(arg_spec.varargs)
+        if is_kwargs_deprecated and kwargs:
+          invalid_args.append(arg_spec.varkw)
+        for arg_name in deprecated_arg_names:
+          if (arg_name in kwargs and
+              not (deprecated_positions[arg_name].has_ok_value and
+                   _same_value(named_args[arg_name],
+                               deprecated_positions[arg_name].ok_value))):
+            invalid_args.append(arg_name)
+        for arg_name in invalid_args:
+          if (func, arg_name) not in _PRINTED_WARNING:
+            if warn_once:
+              _PRINTED_WARNING[(func, arg_name)] = True
+            _log_deprecation(
+                'From %s: calling %s (from %s) with %s is deprecated and will '
+                'be removed %s.\nInstructions for updating:\n%s',
+                _call_location(), decorator_utils.get_qualified_name(func),
+                func.__module__, arg_name,
+                'in a future version' if date is None else ('after %s' % date),
+                instructions)
+      return func(*args, **kwargs)
+
+    doc = _add_deprecated_arg_notice_to_docstring(
+        func.__doc__, date, instructions, sorted(deprecated_arg_names.keys()))
+    return tf_decorator.make_decorator(func, new_func, 'deprecated', doc)
+
+  return deprecated_wrapper
+
+
+def deprecated_arg_values(date,
+                          instructions,
+                          warn_once=True,
+                          **deprecated_kwargs):
+  """Decorator for marking specific function argument values as deprecated.
+
+  This decorator logs a deprecation warning whenever the decorated function is
+  called with the deprecated argument values. It has the following format:
+
+    Calling <function> (from <module>) with <arg>=<value> is deprecated and
+    will be removed after <date>. Instructions for updating:
+      <instructions>
+
+  If `date` is None, 'after <date>' is replaced with 'in a future version'.
+  <function> will include the class name if it is a method.
+
+  It also edits the docstring of the function: ' (deprecated arguments)' is
+  appended to the first line of the docstring and a deprecation notice is
+  prepended to the rest of the docstring.
+
+  Args:
+    date: String or None. The date the function is scheduled to be removed. Must
+      be ISO 8601 (YYYY-MM-DD), or None
+    instructions: String. Instructions on how to update code using the
+      deprecated function.
+    warn_once: If `True`, warn only the first time this function is called with
+      deprecated argument values. Otherwise, every call (with a deprecated
+      argument value) will log a warning.
+    **deprecated_kwargs: The deprecated argument values.
+
+  Returns:
+    Decorated function or method.
+
+  Raises:
+    ValueError: If date is not None or in ISO 8601 format, or instructions are
+      empty.
+  """
+  _validate_deprecation_args(date, instructions)
+  if not deprecated_kwargs:
+    raise ValueError('Specify which argument values are deprecated.')
+
+  def deprecated_wrapper(func):
+    """Deprecation decorator."""
+    decorator_utils.validate_callable(func, 'deprecated_arg_values')
+
+    @functools.wraps(func)
+    def new_func(*args, **kwargs):
+      """Deprecation wrapper."""
+      if _PRINT_DEPRECATION_WARNINGS:
+        named_args = tf_inspect.getcallargs(func, *args, **kwargs)
+        for arg_name, arg_value in deprecated_kwargs.items():
+          if arg_name in named_args and _safe_eq(named_args[arg_name],
+                                                 arg_value):
+            if (func, arg_name) not in _PRINTED_WARNING:
+              if warn_once:
+                _PRINTED_WARNING[(func, arg_name)] = True
+              _log_deprecation(
+                  'From %s: calling %s (from %s) with %s=%s is deprecated and '
+                  'will be removed %s.\nInstructions for updating:\n%s',
+                  _call_location(), decorator_utils.get_qualified_name(func),
+                  func.__module__, arg_name, arg_value,
+                  'in a future version' if date is None else
+                  ('after %s' % date), instructions)
+      return func(*args, **kwargs)
+
+    doc = _add_deprecated_arg_value_notice_to_docstring(func.__doc__, date,
+                                                        instructions,
+                                                        deprecated_kwargs)
+    return tf_decorator.make_decorator(func, new_func, 'deprecated', doc)
+
+  return deprecated_wrapper
+
+
+def deprecated_argument_lookup(new_name, new_value, old_name, old_value):
+  """Looks up deprecated argument name and ensures both are not used.
+
+  Args:
+    new_name: new name of argument
+    new_value: value of new argument (or None if not used)
+    old_name: old name of argument
+    old_value: value of old argument (or None if not used)
+
+  Returns:
+    The effective argument that should be used.
+  Raises:
+    ValueError: if new_value and old_value are both non-null
+  """
+  if old_value is not None:
+    if new_value is not None:
+      raise ValueError(f"Cannot specify both '{old_name}' and '{new_name}'.")
+    return old_value
+  return new_value
+
+
+def rewrite_argument_docstring(old_doc, old_argument, new_argument):
+  return old_doc.replace('`%s`' % old_argument,
+                         '`%s`' % new_argument).replace('%s:' % old_argument,
+                                                        '%s:' % new_argument)
+
+
+@tf_contextlib.contextmanager
+def silence():
+  """Temporarily silence deprecation warnings."""
+  global _PRINT_DEPRECATION_WARNINGS
+  print_deprecation_warnings = _PRINT_DEPRECATION_WARNINGS
+  _PRINT_DEPRECATION_WARNINGS = False
+  yield
+  _PRINT_DEPRECATION_WARNINGS = print_deprecation_warnings
+
+
+def deprecate_moved_module(deprecated_name, new_module, deletion_version):
+  """Logs a warning when a module that has been moved to a new location is used.
+
+  Copy the following code into the old module:
+
+  ```
+  import deprecation
+  import new_module
+
+  __getattr__ = deprecation.deprecate_moved_module(
+      __name__, new_module, "2.9")  # adjust version number.
+  ```
+
+  Args:
+    deprecated_name: Name of old module.
+    new_module: Module to replace the old module.
+    deletion_version: Version of TensorFlow in which the old module will be
+      removed.
+
+  Returns:
+    A function that logs a warning and returns the symbol from the new module.
+    Set this function as the module's `__getattr__`.
+  """
+
+  def getter(name):
+    if getter not in _PRINTED_WARNING and _PRINT_DEPRECATION_WARNINGS:
+      _PRINTED_WARNING[getter] = True
+      _log_deprecation(
+          'Please fix your imports. Module %s has been moved to %s. The old '
+          'module will be deleted in version %s.', deprecated_name,
+          new_module.__name__, deletion_version)
+    return getattr(new_module, name)
+
+  return getter
+
+
+class HiddenTfApiAttribute(property):
+  """Hides a class attribute from the public API.
+
+  Attributes in public classes can be hidden from the API by having an '_' in
+  front of the name (e.g. ClassName._variables). This doesn't work when
+  attributes or methods are inherited from a parent class. To hide inherited
+  attributes, set their values to be `deprecation.hide_attribute_from_api`.
+  """
+
+  def __init__(self, deprecation_message):
+
+    def raise_error(unused_self):
+      raise AttributeError(deprecation_message)
+
+    super(HiddenTfApiAttribute, self).__init__(raise_error)
+
+
+hide_attribute_from_api = HiddenTfApiAttribute  # pylint: disable=invalid-name
+
+# TODO(kathywu): Remove once cl/246395236 is submitted.
+HIDDEN_ATTRIBUTE = HiddenTfApiAttribute('This attribute has been deprecated.')

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/dispatch.py

@@ -0,0 +1,1302 @@
+# 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.
+# ==============================================================================
+"""Type-based dispatch for TensorFlow's Python APIs.
+
+"Python APIs" refers to Python functions that have been exported with
+`tf_export`, such as `tf.add` and `tf.linalg.matmul`; they are sometimes also
+referred to as "ops".
+
+There are currently two dispatch systems for TensorFlow:
+
+  * The "fallback dispatch" system calls an API's standard implementation first,
+    and only tries to perform dispatch if that standard implementation raises a
+    TypeError (or ValueError) exception.
+
+  * The "type-based dispatch" system checks the types of the parameters passed
+    to an API, and performs dispatch if those types match any signatures that
+    have been registered for dispatch.
+
+The fallback dispatch system was the original dispatch system, but it was
+somewhat brittle and had limitations, such as an inability to support dispatch
+for some operations (like convert_to_tensor).  We plan to remove the fallback
+dispatch system in favor of the type-based dispatch system, once all users have
+been switched over to use it.
+
+### Fallback Dispatch
+
+The fallback dispatch system is based on "operation dispatchers", which can be
+used to override the behavior for TensorFlow ops when they are called with
+otherwise unsupported argument types.  In particular, when an operation is
+called with arguments that would cause it to raise a TypeError, it falls back on
+its registered operation dispatchers.  If any registered dispatchers can handle
+the arguments, then its result is returned. Otherwise, the original TypeError is
+raised.
+
+### Type-based Dispatch
+
+The main interface for the type-based dispatch system is the `dispatch_for_api`
+decorator, which overrides the default implementation for a TensorFlow API.
+The decorated function (known as the "dispatch target") will override the
+default implementation for the API when the API is called with parameters that
+match a specified type signature.
+
+### Dispatch Support
+
+By default, dispatch support is added to the generated op wrappers for any
+visible ops by default.  APIs/ops that are implemented in Python can opt in to
+dispatch support using the `add_dispatch_support` decorator.
+"""
+
+import collections
+import itertools
+import typing  # pylint: disable=unused-import (used in doctests)
+
+from tensorflow.python.framework import _pywrap_python_api_dispatcher as _api_dispatcher
+from tensorflow.python.framework import ops
+from tensorflow.python.util import tf_decorator
+from tensorflow.python.util import tf_export as tf_export_lib
+from tensorflow.python.util import tf_inspect
+from tensorflow.python.util import traceback_utils
+from tensorflow.python.util import type_annotations
+from tensorflow.python.util.tf_export import tf_export
+
+
+# Private function attributes used to store dispatchers on TensorFlow APIs.
+FALLBACK_DISPATCH_ATTR = "_tf_fallback_dispatchers"
+TYPE_BASED_DISPATCH_ATTR = "_tf_type_based_dispatcher"
+
+# OpDispatchers which should be used for all operations.
+_GLOBAL_DISPATCHERS = []
+
+
+################################################################################
+# Fallback Dispatch
+################################################################################
+
+
+@tf_export("__internal__.dispatch.OpDispatcher", v1=[])
+class OpDispatcher(object):
+  """Abstract base class for TensorFlow operator dispatchers.
+
+  Each operation dispatcher acts as an override handler for a single
+  TensorFlow operation, and its results are used when the handler indicates
+  that it can handle the operation's arguments (by returning any value other
+  than `OpDispatcher.NOT_SUPPORTED`).
+  """
+
+  # Sentinel value that can be returned to indicate that an operation
+  # dispatcher does not support a given set of arguments.
+  NOT_SUPPORTED = object()
+
+  def handle(self, args, kwargs):  # pylint: disable=unused-argument
+    """Handle this dispatcher's operation with the specified arguments.
+
+    If this operation dispatcher can handle the given arguments, then
+    return an appropriate value (or raise an appropriate exception).
+
+    Args:
+      args: The arguments to the operation.
+      kwargs: They keyword arguments to the operation.
+
+    Returns:
+      The result of the operation, or `OpDispatcher.NOT_SUPPORTED` if this
+      dispatcher can not handle the given arguments.
+    """
+    return self.NOT_SUPPORTED
+
+  def register(self, op):
+    """Register this dispatcher as a handler for `op`.
+
+    Args:
+      op: Python function: the TensorFlow operation that should be handled. Must
+        have a dispatch list (which is added automatically for generated ops,
+        and can be added to Python ops using the `add_dispatch_support`
+        decorator).
+    """
+    if not hasattr(op, FALLBACK_DISPATCH_ATTR):
+      raise AssertionError("Dispatching not enabled for %s" % op)
+    getattr(op, FALLBACK_DISPATCH_ATTR).append(self)
+
+
+@tf_export("__internal__.dispatch.GlobalOpDispatcher", v1=[])
+class GlobalOpDispatcher(object):
+  """Abstract base class for TensorFlow global operator dispatchers."""
+
+  NOT_SUPPORTED = OpDispatcher.NOT_SUPPORTED
+
+  def handle(self, op, args, kwargs):
+    """Handle the specified operation with the specified arguments."""
+
+  def register(self):
+    """Register this dispatcher as a handler for all ops."""
+    _GLOBAL_DISPATCHERS.append(self)
+
+
+def dispatch(op, args, kwargs):
+  """Returns the result from the first successful dispatcher for a given op.
+
+  Calls the `handle` method of each `OpDispatcher` that has been registered
+  to handle `op`, and returns the value from the first successful handler.
+
+  Args:
+    op: Python function: the operation to dispatch for.
+    args: The arguments to the operation.
+    kwargs: They keyword arguments to the operation.
+
+  Returns:
+    The result of the operation, or `NOT_SUPPORTED` if no registered
+    dispatcher can handle the given arguments.
+  """
+  for dispatcher in getattr(op, FALLBACK_DISPATCH_ATTR):
+    result = dispatcher.handle(args, kwargs)
+    if result is not OpDispatcher.NOT_SUPPORTED:
+      return result
+  for dispatcher in _GLOBAL_DISPATCHERS:
+    result = dispatcher.handle(op, args, kwargs)
+    if result is not OpDispatcher.NOT_SUPPORTED:
+      return result
+  return OpDispatcher.NOT_SUPPORTED
+
+
+class _TypeBasedDispatcher(OpDispatcher):
+  """Dispatcher that handles op if any arguments have a specified type.
+
+  Checks the types of the arguments and keyword arguments (including elements
+  of lists or tuples), and if any argument values have the indicated type(s),
+  then delegates to an override function.
+  """
+
+  def __init__(self, override_func, types):
+    self._types = types
+    self._override_func = override_func
+
+  def _handles(self, args, kwargs):
+    for arg in itertools.chain(args, kwargs.values()):
+      if (isinstance(arg, self._types) or
+          (isinstance(arg, (list, tuple)) and
+           any(isinstance(elt, self._types) for elt in arg))):
+        return True
+    return False
+
+  def handle(self, args, kwargs):
+    if self._handles(args, kwargs):
+      return self._override_func(*args, **kwargs)
+    else:
+      return self.NOT_SUPPORTED
+
+
+def _remove_annotation(sig):
+  """Removes annotation from a python Signature."""
+  parameters = [p.replace(annotation=p.empty) for p in sig.parameters.values()]
+  return sig.replace(parameters=parameters, return_annotation=sig.empty)
+
+
+def _get_required_param_names(sig):
+  """Returns a list of required parameter names from a python Signature."""
+  params = []
+  for p in sig.parameters.values():
+    if p.kind == p.VAR_POSITIONAL:
+      continue
+    if p.kind == p.VAR_KEYWORD:
+      continue
+    if p.default is not p.empty:
+      continue
+    params.append(p.name)
+  return params
+
+
+def get_compatible_func(op, func):
+  """Returns a compatible function.
+
+  Args:
+    op: a callable with whose signature the returned function is compatible.
+    func: a callable which is called by the returned function.
+
+  Returns:
+    a compatible function, which conducts the actions of `func` but can
+    be called like `op`, given that:
+      - the list of required arguments in `func` and `op` are the same.
+      - there is no override of the default arguments of `op` that are not
+        supported by `func`.
+  """
+  op_signature = _remove_annotation(tf_inspect.signature(op))
+  func_signature = _remove_annotation(tf_inspect.signature(func))
+
+  # Identitical signatures, no need to apply compatibility fixes.
+  if op_signature == func_signature:
+    return func
+
+  # When calling func:
+  # - Positional args without default must be in the same order.
+  # - Ignore missing optional arguments from op
+
+  op_pos_names = _get_required_param_names(op_signature)
+  func_pos_names = _get_required_param_names(func_signature)
+
+  if op_pos_names != func_pos_names:
+    raise AssertionError(
+        "The decorated function's non-default arguments must be identical"
+        " to that of the overridden op."
+        f" func has {func_pos_names}. op has {op_pos_names}."
+    )
+
+  func_missing_params = {}
+
+  for name in set(op_signature.parameters.keys()) - set(
+      func_signature.parameters.keys()
+  ):
+    p = op_signature.parameters[name]
+    if p.default is p.empty:
+      raise AssertionError(
+          "The decorated function's signature must implement all of the"
+          f" non-default arguments of the overridden op. Argument `{name}` is"
+          " unimplemented."
+      )
+    func_missing_params[name] = p
+
+  def compatible_func(*args, **kwargs):
+    bound = op_signature.bind(*args, **kwargs)
+    for name, param in func_missing_params.items():
+      if name not in bound.arguments:
+        continue
+      value = bound.arguments.pop(name)
+      if value is not param.default:
+        raise AssertionError(
+            f"Dispatched op is called with argument `{name}` set to a"
+            " non-default value, which is not supported by the decorated"
+            " function"
+        )
+    return func(*bound.args, **bound.kwargs)
+
+  return compatible_func
+
+
+# pylint: disable=g-doc-return-or-yield
+def dispatch_for_types(op, *types):
+  """Decorator to declare that a Python function overrides an op for a type.
+
+  The decorated function is used to override `op` if any of the arguments or
+  keyword arguments (including elements of lists or tuples) have one of the
+  specified types.
+
+  Example:
+
+  ```python
+  @dispatch_for_types(math_ops.add, RaggedTensor, RaggedTensorValue)
+  def ragged_add(x, y, name=None): ...
+  ```
+
+  Args:
+    op: Python function: the operation that should be overridden.
+    *types: The argument types for which this function should be used.
+  """
+
+  def decorator(func):
+
+    _TypeBasedDispatcher(get_compatible_func(op, func), types).register(op)
+    return func
+
+  return decorator
+
+
+# pylint: enable=g-doc-return-or-yield
+
+
+def add_fallback_dispatch_list(target):
+  """Decorator that adds a dispatch_list attribute to an op."""
+  if hasattr(target, FALLBACK_DISPATCH_ATTR):
+    raise AssertionError("%s already has a dispatch list" % target)
+  setattr(target, FALLBACK_DISPATCH_ATTR, [])
+  return target
+
+
+# Alias for backwards-compatibility.
+add_dispatch_list = add_fallback_dispatch_list
+
+
+################################################################################
+# Type-based Dispatch
+################################################################################
+
+
+@tf_export("experimental.dispatch_for_api")
+def dispatch_for_api(api, *signatures):
+  """Decorator that overrides the default implementation for a TensorFlow API.
+
+  The decorated function (known as the "dispatch target") will override the
+  default implementation for the API when the API is called with parameters that
+  match a specified type signature.  Signatures are specified using dictionaries
+  that map parameter names to type annotations.  E.g., in the following example,
+  `masked_add` will be called for `tf.add` if both `x` and `y` are
+  `MaskedTensor`s:
+
+  >>> class MaskedTensor(tf.experimental.ExtensionType):
+  ...   values: tf.Tensor
+  ...   mask: tf.Tensor
+
+  >>> @dispatch_for_api(tf.math.add, {'x': MaskedTensor, 'y': MaskedTensor})
+  ... def masked_add(x, y, name=None):
+  ...   return MaskedTensor(x.values + y.values, x.mask & y.mask)
+
+  >>> mt = tf.add(MaskedTensor([1, 2], [True, False]), MaskedTensor(10, True))
+  >>> print(f"values={mt.values.numpy()}, mask={mt.mask.numpy()}")
+  values=[11 12], mask=[ True False]
+
+  If multiple type signatures are specified, then the dispatch target will be
+  called if any of the signatures match.  For example, the following code
+  registers `masked_add` to be called if `x` is a `MaskedTensor` *or* `y` is
+  a `MaskedTensor`.
+
+  >>> @dispatch_for_api(tf.math.add, {'x': MaskedTensor}, {'y':MaskedTensor})
+  ... def masked_add(x, y):
+  ...   x_values = x.values if isinstance(x, MaskedTensor) else x
+  ...   x_mask = x.mask if isinstance(x, MaskedTensor) else True
+  ...   y_values = y.values if isinstance(y, MaskedTensor) else y
+  ...   y_mask = y.mask if isinstance(y, MaskedTensor) else True
+  ...   return MaskedTensor(x_values + y_values, x_mask & y_mask)
+
+  The type annotations in type signatures may be type objects (e.g.,
+  `MaskedTensor`), `typing.List` values, or `typing.Union` values.   For
+  example, the following will register `masked_concat` to be called if `values`
+  is a list of `MaskedTensor` values:
+
+  >>> @dispatch_for_api(tf.concat, {'values': typing.List[MaskedTensor]})
+  ... def masked_concat(values, axis):
+  ...   return MaskedTensor(tf.concat([v.values for v in values], axis),
+  ...                       tf.concat([v.mask for v in values], axis))
+
+  Each type signature must contain at least one subclass of `tf.CompositeTensor`
+  (which includes subclasses of `tf.ExtensionType`), and dispatch will only be
+  triggered if at least one type-annotated parameter contains a
+  `CompositeTensor` value.  This rule avoids invoking dispatch in degenerate
+  cases, such as the following examples:
+
+  * `@dispatch_for_api(tf.concat, {'values': List[MaskedTensor]})`: Will not
+    dispatch to the decorated dispatch target when the user calls
+    `tf.concat([])`.
+
+  * `@dispatch_for_api(tf.add, {'x': Union[MaskedTensor, Tensor], 'y':
+    Union[MaskedTensor, Tensor]})`: Will not dispatch to the decorated dispatch
+    target when the user calls `tf.add(tf.constant(1), tf.constant(2))`.
+
+  The dispatch target's signature must match the signature of the API that is
+  being overridden.  In particular, parameters must have the same names, and
+  must occur in the same order.  The dispatch target may optionally elide the
+  "name" parameter, in which case it will be wrapped with a call to
+  `tf.name_scope` when appropraite.
+
+  Args:
+    api: The TensorFlow API to override.
+    *signatures: Dictionaries mapping parameter names or indices to type
+      annotations, specifying when the dispatch target should be called.  In
+      particular, the dispatch target will be called if any signature matches;
+      and a signature matches if all of the specified parameters have types that
+      match with the indicated type annotations.  If no signatures are
+      specified, then a signature will be read from the dispatch target
+      function's type annotations.
+
+  Returns:
+    A decorator that overrides the default implementation for `api`.
+
+  #### Registered APIs
+
+  The TensorFlow APIs that may be overridden by `@dispatch_for_api` are:
+
+  <<API_LIST>>
+  """
+  dispatcher = getattr(api, TYPE_BASED_DISPATCH_ATTR, None)
+  if dispatcher is None:
+    raise ValueError(f"{api} does not support dispatch.")
+
+  api_signature = tf_inspect.signature(api)
+  signature_checkers = [
+      _make_signature_checker(api_signature, signature)
+      for signature in signatures
+  ]
+
+  def decorator(dispatch_target):
+    """Decorator that registers the given dispatch target."""
+    if not callable(dispatch_target):
+      raise TypeError("Expected dispatch_target to be callable; "
+                      f"got {dispatch_target!r}")
+    dispatch_target = _add_name_scope_wrapper(dispatch_target, api_signature)
+    _check_signature(api_signature, dispatch_target)
+
+    for signature_checker in signature_checkers:
+      dispatcher.Register(signature_checker, dispatch_target)
+    _TYPE_BASED_DISPATCH_SIGNATURES[api][dispatch_target].extend(signatures)
+
+    if not signature_checkers:
+      signature = _signature_from_annotations(dispatch_target)
+      checker = _make_signature_checker(api_signature, signature)
+      dispatcher.Register(checker, dispatch_target)
+      _TYPE_BASED_DISPATCH_SIGNATURES[api][dispatch_target].append(signature)
+
+    return dispatch_target
+
+  return decorator
+
+
+# Nested dict mapping `api_func` -> `dispatch_target` -> `List[signature]`,
+# which can be used for documentation generation and for improved error messages
+# when APIs are called with unsupported types.
+_TYPE_BASED_DISPATCH_SIGNATURES = {}
+
+
+def apis_with_type_based_dispatch():
+  """Returns a list of TensorFlow APIs that support type-based dispatch."""
+  return sorted(
+      _TYPE_BASED_DISPATCH_SIGNATURES,
+      key=lambda api: f"{api.__module__}.{api.__name__}")
+
+
+def type_based_dispatch_signatures_for(cls):
+  """Returns dispatch signatures that have been registered for a given class.
+
+  This function is intended for documentation-generation purposes.
+
+  Args:
+    cls: The class to search for.  Type signatures are searched recursively, so
+      e.g., if `cls=RaggedTensor`, then information will be returned for all
+      dispatch targets that have `RaggedTensor` anywhere in their type
+      annotations (including nested in `typing.Union` or `typing.List`.)
+
+  Returns:
+    A `dict` mapping `api` -> `signatures`, where `api` is a TensorFlow API
+    function; and `signatures` is a list of dispatch signatures for `api`
+    that include `cls`.  (Each signature is a dict mapping argument names to
+    type annotations; see `dispatch_for_api` for more info.)
+  """
+
+  def contains_cls(x):
+    """Returns true if `x` contains `cls`."""
+    if isinstance(x, dict):
+      return any(contains_cls(v) for v in x.values())
+    elif x is cls:
+      return True
+    elif (type_annotations.is_generic_list(x) or
+          type_annotations.is_generic_union(x)):
+      type_args = type_annotations.get_generic_type_args(x)
+      return any(contains_cls(arg) for arg in type_args)
+    else:
+      return False
+
+  result = {}
+  for api, api_signatures in _TYPE_BASED_DISPATCH_SIGNATURES.items():
+    for _, signatures in api_signatures.items():
+      filtered = list(filter(contains_cls, signatures))
+      if filtered:
+        result.setdefault(api, []).extend(filtered)
+  return result
+
+
+# TODO(edloper): Consider using a mechanism like this to automatically add
+# the `name` argument to all TensorFlow APIs that are implemented in Python
+# (so each Python function doesn't need to do it manually).
+def _add_name_scope_wrapper(func, api_signature):
+  """Wraps `func` to expect a "name" arg, and use it to call `ops.name_scope`.
+
+  If `func` already expects a "name" arg, or if `api_signature` does not
+  expect a "name" arg, then returns `func` as-is.
+
+  Args:
+    func: The function to wrap.  Signature must match `api_signature` (except
+      the "name" parameter may be missing.
+    api_signature: The signature of the original API (used to find the index for
+      the "name" parameter).
+
+  Returns:
+    The wrapped function (or the original function if no wrapping is needed).
+  """
+  if "name" not in api_signature.parameters:
+    return func  # no wrapping needed (API has no name parameter).
+
+  func_signature = tf_inspect.signature(func)
+  func_argspec = tf_inspect.getargspec(func)
+  if "name" in func_signature.parameters or func_argspec.keywords is not None:
+    return func  # No wrapping needed (already has name parameter).
+
+  name_index = list(api_signature.parameters).index("name")
+
+  def wrapped_func(*args, **kwargs):
+    if name_index < len(args):
+      name = args[name_index]
+      args = args[:name_index] + args[name_index + 1:]
+    else:
+      name = kwargs.pop("name", None)
+    if name is None:
+      return func(*args, **kwargs)
+    else:
+      with ops.name_scope(name):
+        return func(*args, **kwargs)
+
+  wrapped_func = tf_decorator.make_decorator(func, wrapped_func)
+  wrapped_func.__signature__ = func_signature.replace(
+      parameters=(list(func_signature.parameters.values()) +
+                  [api_signature.parameters["name"]]))
+  del wrapped_func._tf_decorator
+  return wrapped_func
+
+
+@tf_export("experimental.unregister_dispatch_for")
+def unregister_dispatch_for(dispatch_target):
+  """Unregisters a function that was registered with `@dispatch_for_*`.
+
+  This is primarily intended for testing purposes.
+
+  Example:
+
+  >>> # Define a type and register a dispatcher to override `tf.abs`:
+  >>> class MyTensor(tf.experimental.ExtensionType):
+  ...   value: tf.Tensor
+  >>> @tf.experimental.dispatch_for_api(tf.abs)
+  ... def my_abs(x: MyTensor):
+  ...   return MyTensor(tf.abs(x.value))
+  >>> tf.abs(MyTensor(5))
+  MyTensor(value=<tf.Tensor: shape=(), dtype=int32, numpy=5>)
+
+  >>> # Unregister the dispatcher, so `tf.abs` no longer calls `my_abs`.
+  >>> unregister_dispatch_for(my_abs)
+  >>> tf.abs(MyTensor(5))
+  Traceback (most recent call last):
+  ...
+  ValueError: Attempt to convert a value ... to a Tensor.
+
+  Args:
+    dispatch_target: The function to unregister.
+
+  Raises:
+    ValueError: If `dispatch_target` was not registered using `@dispatch_for`,
+      `@dispatch_for_unary_elementwise_apis`, or
+      `@dispatch_for_binary_elementwise_apis`.
+  """
+  found = False
+
+  # Check if dispatch_target registered by `@dispatch_for_api`
+  for api, signatures in _TYPE_BASED_DISPATCH_SIGNATURES.items():
+    if dispatch_target in signatures:
+      dispatcher = getattr(api, TYPE_BASED_DISPATCH_ATTR)
+      dispatcher.Unregister(dispatch_target)
+      del signatures[dispatch_target]
+      found = True
+
+  # Check if dispatch_target registered by `@dispatch_for_*_elementwise_apis`
+  elementwise_keys_to_delete = [
+      key for (key, handler) in _ELEMENTWISE_API_HANDLERS.items()
+      if handler is dispatch_target
+  ]
+  for key in set(elementwise_keys_to_delete):
+    for _, target in _ELEMENTWISE_API_TARGETS[key]:
+      unregister_dispatch_for(target)
+    del _ELEMENTWISE_API_HANDLERS[key]
+    del _ELEMENTWISE_API_TARGETS[key]
+    found = True
+
+  if not found:
+    raise ValueError(f"Function {dispatch_target} was not registered using "
+                     "a `@dispatch_for_*` decorator.")
+
+
+def register_dispatchable_type(cls):
+  """Class decorator that registers a type for use with type-based dispatch.
+
+  Should *not* be used with subclasses of `CompositeTensor` or `ExtensionType`
+  (which are automatically registered).
+
+  Note: this function is intended to support internal legacy use cases (such
+  as RaggedTensorValue), and will probably not be exposed as a public API.
+
+  Args:
+    cls: The class to register.
+
+  Returns:
+    `cls`.
+  """
+  _api_dispatcher.register_dispatchable_type(cls)
+  return cls
+
+
+def add_type_based_api_dispatcher(target):
+  """Adds a PythonAPIDispatcher to the given TensorFlow API function."""
+  if hasattr(target, TYPE_BASED_DISPATCH_ATTR):
+    raise ValueError(f"{target} already has a type-based API dispatcher.")
+
+  _, unwrapped = tf_decorator.unwrap(target)
+  target_argspec = tf_inspect.getargspec(unwrapped)
+  if target_argspec.varargs or target_argspec.keywords:
+    # @TODO(b/194903203) Add v2 dispatch support for APIs that take varargs
+    # and keywords.  Examples of APIs that take varargs and kwargs: meshgrid,
+    # einsum, map_values, map_flat_values.
+    return target
+
+  setattr(
+      target, TYPE_BASED_DISPATCH_ATTR,
+      _api_dispatcher.PythonAPIDispatcher(unwrapped.__name__,
+                                          target_argspec.args,
+                                          target_argspec.defaults))
+  _TYPE_BASED_DISPATCH_SIGNATURES[target] = collections.defaultdict(list)
+  return target
+
+
+def _check_signature(api_signature, func):
+  """Checks that a dispatch target's signature is compatible with an API.
+
+  Args:
+    api_signature: The signature of the TensorFlow API.
+    func: The dispatch target.
+
+  Raises:
+    ValueError: if the signatures are incompatible.  Two signatures are
+      considered compatible if they have the same number of parameters, and all
+      corresponding parameters have the same `name` and `kind`.  (Parameters
+      are not required to have the same default value or the same annotation.)
+  """
+  # Special case: if func_signature is (*args, **kwargs), then assume it's ok.
+  func_argspec = tf_inspect.getargspec(func)
+  if (func_argspec.varargs is not None and func_argspec.keywords is not None
+      and not func_argspec.args):
+    return
+
+  func_signature = tf_inspect.signature(func)
+  ok = len(api_signature.parameters) == len(func_signature.parameters)
+  if ok:
+    for param_1, param_2 in zip(api_signature.parameters.values(),
+                                func_signature.parameters.values()):
+      if (param_1.name != param_2.name) or (param_1.kind != param_2.kind):
+        ok = False
+  if not ok:
+    raise ValueError(f"Dispatch function's signature {func_signature} does "
+                     f"not match API's signature {api_signature}.")
+
+
+def _make_signature_checker(api_signature, signature):
+  """Builds a PySignatureChecker for the given type signature.
+
+  Args:
+    api_signature: The `inspect.Signature` of the API whose signature is
+      being checked.
+    signature: Dictionary mapping parameter names to type annotations.
+
+  Returns:
+    A `PySignatureChecker`.
+  """
+  if not (isinstance(signature, dict) and
+          all(isinstance(k, (str, int)) for k in signature)):
+    raise TypeError("signatures must be dictionaries mapping parameter names "
+                    "to type annotations.")
+  checkers = []
+
+  param_names = list(api_signature.parameters)
+  for param_name, param_type in signature.items():
+    # Convert positional parameters to named parameters.
+    if (isinstance(param_name, int) and
+        param_name < len(api_signature.parameters)):
+      param_name = list(api_signature.parameters.values())[param_name].name
+
+    # Check that the parameter exists, and has an appropriate kind.
+    param = api_signature.parameters.get(param_name, None)
+    if param is None:
+      raise ValueError("signature includes annotation for unknown "
+                       f"parameter {param_name!r}.")
+    if param.kind not in (tf_inspect.Parameter.POSITIONAL_ONLY,
+                          tf_inspect.Parameter.POSITIONAL_OR_KEYWORD):
+      raise ValueError("Dispatch currently only supports type annotations "
+                       "for positional parameters; can't handle annotation "
+                       f"for {param.kind!r} parameter {param_name}.")
+
+    checker = make_type_checker(param_type)
+    index = param_names.index(param_name)
+    checkers.append((index, checker))
+
+  return _api_dispatcher.PySignatureChecker(checkers)
+
+
+# Cache for InstanceTypeChecker objects (we only want to create one
+# InstanceTypeChecker for each type, since each one uses an internal cache
+# to avoid repeated calls back into Python's isinstance).
+_is_instance_checker_cache = {}
+
+
+def make_type_checker(annotation):
+  """Builds a PyTypeChecker for the given type annotation."""
+  if type_annotations.is_generic_union(annotation):
+    type_args = type_annotations.get_generic_type_args(annotation)
+
+    # If the union contains two or more simple types, then use a single
+    # InstanceChecker to check them.
+    simple_types = [t for t in type_args if isinstance(t, type)]
+    simple_types = tuple(sorted(simple_types, key=id))
+    if len(simple_types) > 1:
+      if simple_types not in _is_instance_checker_cache:
+        checker = _api_dispatcher.MakeInstanceChecker(*simple_types)
+        _is_instance_checker_cache[simple_types] = checker
+      options = ([_is_instance_checker_cache[simple_types]] +
+                 [make_type_checker(t) for t in type_args
+                  if not isinstance(t, type)])
+      return _api_dispatcher.MakeUnionChecker(options)
+
+    options = [make_type_checker(t) for t in type_args]
+    return _api_dispatcher.MakeUnionChecker(options)
+
+  elif type_annotations.is_generic_list(annotation):
+    type_args = type_annotations.get_generic_type_args(annotation)
+    if len(type_args) != 1:
+      raise AssertionError("Expected List[...] to have a single type parameter")
+    elt_type = make_type_checker(type_args[0])
+    return _api_dispatcher.MakeListChecker(elt_type)
+
+  elif isinstance(annotation, type):
+    if annotation not in _is_instance_checker_cache:
+      checker = _api_dispatcher.MakeInstanceChecker(annotation)
+      _is_instance_checker_cache[annotation] = checker
+    return _is_instance_checker_cache[annotation]
+
+  elif annotation is None:
+    return make_type_checker(type(None))
+
+  else:
+    raise ValueError(f"Type annotation {annotation} is not currently supported"
+                     " by dispatch.  Supported annotations: type objects, "
+                     " List[...], and Union[...]")
+
+
+def _signature_from_annotations(func):
+  """Builds a dict mapping from parameter names to type annotations."""
+  func_signature = tf_inspect.signature(func)
+
+  signature = dict([(name, param.annotation)
+                    for (name, param) in func_signature.parameters.items()
+                    if param.annotation != tf_inspect.Parameter.empty])
+  if not signature:
+    raise ValueError("The dispatch_for_api decorator must be called with at "
+                     "least one signature, or applied to a function that "
+                     "has type annotations on its parameters.")
+  return signature
+
+
+# Registries for elementwise APIs and API handlers.
+#
+# _*_ELEMENTWISE_APIS: A list of TensorFlow APIs that have been registered
+# as elementwise operations using the `register_*_elementwise_api`
+# decorators.
+#
+# _ELEMENTWISE_API_HANDLERS: Dicts mapping from argument type(s) to API
+# handlers that have been registered with the `dispatch_for_*_elementwise_apis`
+# decorators.
+#
+# _ELEMENTWISE_API_TARGETS: Dict mapping from argument type(s) to lists of
+# `(api, dispatch_target)` pairs.  Used to impelement
+# `unregister_elementwise_api_handler`.
+_UNARY_ELEMENTWISE_APIS = []
+_BINARY_ELEMENTWISE_APIS = []
+_BINARY_ELEMENTWISE_ASSERT_APIS = []
+_ELEMENTWISE_API_HANDLERS = {}
+_ELEMENTWISE_API_TARGETS = {}
+
+_ASSERT_API_TAG = "ASSERT_API_TAG"
+
+
+@tf_export("experimental.dispatch_for_unary_elementwise_apis")
+def dispatch_for_unary_elementwise_apis(x_type):
+  """Decorator to override default implementation for unary elementwise APIs.
+
+  The decorated function (known as the "elementwise api handler") overrides
+  the default implementation for any unary elementwise API whenever the value
+  for the first argument (typically named `x`) matches the type annotation
+  `x_type`. The elementwise api handler is called with two arguments:
+
+    `elementwise_api_handler(api_func, x)`
+
+  Where `api_func` is a function that takes a single parameter and performs the
+  elementwise operation (e.g., `tf.abs`), and `x` is the first argument to the
+  elementwise api.
+
+  The following example shows how this decorator can be used to update all
+  unary elementwise operations to handle a `MaskedTensor` type:
+
+  >>> class MaskedTensor(tf.experimental.ExtensionType):
+  ...   values: tf.Tensor
+  ...   mask: tf.Tensor
+  >>> @dispatch_for_unary_elementwise_apis(MaskedTensor)
+  ... def unary_elementwise_api_handler(api_func, x):
+  ...   return MaskedTensor(api_func(x.values), x.mask)
+  >>> mt = MaskedTensor([1, -2, -3], [True, False, True])
+  >>> abs_mt = tf.abs(mt)
+  >>> print(f"values={abs_mt.values.numpy()}, mask={abs_mt.mask.numpy()}")
+  values=[1 2 3], mask=[ True False True]
+
+  For unary elementwise operations that take extra arguments beyond `x`, those
+  arguments are *not* passed to the elementwise api handler, but are
+  automatically added when `api_func` is called.  E.g., in the following
+  example, the `dtype` parameter is not passed to
+  `unary_elementwise_api_handler`, but is added by `api_func`.
+
+  >>> ones_mt = tf.ones_like(mt, dtype=tf.float32)
+  >>> print(f"values={ones_mt.values.numpy()}, mask={ones_mt.mask.numpy()}")
+  values=[1.0 1.0 1.0], mask=[ True False True]
+
+  Args:
+    x_type: A type annotation indicating when the api handler should be called.
+      See `dispatch_for_api` for a list of supported annotation types.
+
+  Returns:
+    A decorator.
+
+  #### Registered APIs
+
+  The unary elementwise APIs are:
+
+  <<API_LIST>>
+  """
+
+  def decorator(handler):
+    if (x_type,) in _ELEMENTWISE_API_HANDLERS:
+      raise ValueError("A unary elementwise dispatch handler "
+                       f"({_ELEMENTWISE_API_HANDLERS[(x_type,)]}) "
+                       f"has already been registered for {x_type}.")
+    _ELEMENTWISE_API_HANDLERS[(x_type,)] = handler
+    for api in _UNARY_ELEMENTWISE_APIS:
+      _add_dispatch_for_unary_elementwise_api(api, x_type, handler)
+
+    return handler
+
+  return decorator
+
+
+@tf_export("experimental.dispatch_for_binary_elementwise_apis")
+def dispatch_for_binary_elementwise_apis(x_type, y_type):
+  """Decorator to override default implementation for binary elementwise APIs.
+
+  The decorated function (known as the "elementwise api handler") overrides
+  the default implementation for any binary elementwise API whenever the value
+  for the first two arguments (typically named `x` and `y`) match the specified
+  type annotations.  The elementwise api handler is called with two arguments:
+
+    `elementwise_api_handler(api_func, x, y)`
+
+  Where `x` and `y` are the first two arguments to the elementwise api, and
+  `api_func` is a TensorFlow function that takes two parameters and performs the
+  elementwise operation (e.g., `tf.add`).
+
+  The following example shows how this decorator can be used to update all
+  binary elementwise operations to handle a `MaskedTensor` type:
+
+  >>> class MaskedTensor(tf.experimental.ExtensionType):
+  ...   values: tf.Tensor
+  ...   mask: tf.Tensor
+  >>> @dispatch_for_binary_elementwise_apis(MaskedTensor, MaskedTensor)
+  ... def binary_elementwise_api_handler(api_func, x, y):
+  ...   return MaskedTensor(api_func(x.values, y.values), x.mask & y.mask)
+  >>> a = MaskedTensor([1, 2, 3, 4, 5], [True, True, True, True, False])
+  >>> b = MaskedTensor([2, 4, 6, 8, 0], [True, True, True, False, True])
+  >>> c = tf.add(a, b)
+  >>> print(f"values={c.values.numpy()}, mask={c.mask.numpy()}")
+  values=[ 3 6 9 12 5], mask=[ True True True False False]
+
+  Args:
+    x_type: A type annotation indicating when the api handler should be called.
+    y_type: A type annotation indicating when the api handler should be called.
+
+  Returns:
+    A decorator.
+
+  #### Registered APIs
+
+  The binary elementwise APIs are:
+
+  <<API_LIST>>
+  """
+
+  def decorator(handler):
+    if (x_type, y_type) in _ELEMENTWISE_API_HANDLERS:
+      raise ValueError("A binary elementwise dispatch handler "
+                       f"({_ELEMENTWISE_API_HANDLERS[x_type, y_type]}) "
+                       f"has already been registered for ({x_type}, {y_type}).")
+    _ELEMENTWISE_API_HANDLERS[x_type, y_type] = handler
+    for api in _BINARY_ELEMENTWISE_APIS:
+      _add_dispatch_for_binary_elementwise_api(api, x_type, y_type, handler)
+
+    return handler
+
+  return decorator
+
+
+@tf_export("experimental.dispatch_for_binary_elementwise_assert_apis")
+def dispatch_for_binary_elementwise_assert_apis(x_type, y_type):
+  """Decorator to override default implementation for binary elementwise assert APIs.
+
+  The decorated function (known as the "elementwise assert handler")
+  overrides the default implementation for any binary elementwise assert API
+  whenever the value for the first two arguments (typically named `x` and `y`)
+  match the specified type annotations.  The handler is called with two
+  arguments:
+
+    `elementwise_assert_handler(assert_func, x, y)`
+
+  Where `x` and `y` are the first two arguments to the binary elementwise assert
+  operation, and `assert_func` is a TensorFlow function that takes two
+  parameters and performs the elementwise assert operation (e.g.,
+  `tf.debugging.assert_equal`).
+
+  The following example shows how this decorator can be used to update all
+  binary elementwise assert operations to handle a `MaskedTensor` type:
+
+  >>> class MaskedTensor(tf.experimental.ExtensionType):
+  ...   values: tf.Tensor
+  ...   mask: tf.Tensor
+  >>> @dispatch_for_binary_elementwise_assert_apis(MaskedTensor, MaskedTensor)
+  ... def binary_elementwise_assert_api_handler(assert_func, x, y):
+  ...   merged_mask = tf.logical_and(x.mask, y.mask)
+  ...   selected_x_values = tf.boolean_mask(x.values, merged_mask)
+  ...   selected_y_values = tf.boolean_mask(y.values, merged_mask)
+  ...   assert_func(selected_x_values, selected_y_values)
+  >>> a = MaskedTensor([1, 1, 0, 1, 1], [False, False, True, True, True])
+  >>> b = MaskedTensor([2, 2, 0, 2, 2], [True, True, True, False, False])
+  >>> tf.debugging.assert_equal(a, b) # assert passed; no exception was thrown
+
+  >>> a = MaskedTensor([1, 1, 1, 1, 1], [True, True, True, True, True])
+  >>> b = MaskedTensor([0, 0, 0, 0, 2], [True, True, True, True, True])
+  >>> tf.debugging.assert_greater(a, b)
+  Traceback (most recent call last):
+  ...
+  InvalidArgumentError: Condition x > y did not hold.
+
+  Args:
+    x_type: A type annotation indicating when the api handler should be called.
+    y_type: A type annotation indicating when the api handler should be called.
+
+  Returns:
+    A decorator.
+
+  #### Registered APIs
+
+  The binary elementwise assert APIs are:
+
+  <<API_LIST>>
+  """
+
+  def decorator(handler):
+    api_handler_key = (x_type, y_type, _ASSERT_API_TAG)
+    if api_handler_key in _ELEMENTWISE_API_HANDLERS:
+      raise ValueError("A binary elementwise assert dispatch handler "
+                       f"({_ELEMENTWISE_API_HANDLERS[api_handler_key]}) "
+                       f"has already been registered for ({x_type}, {y_type}).")
+    _ELEMENTWISE_API_HANDLERS[api_handler_key] = handler
+    for api in _BINARY_ELEMENTWISE_ASSERT_APIS:
+      _add_dispatch_for_binary_elementwise_api(api, x_type, y_type, handler)
+
+    return handler
+
+  return decorator
+
+
+def register_unary_elementwise_api(func):
+  """Decorator that registers a TensorFlow op as a unary elementwise API."""
+  _UNARY_ELEMENTWISE_APIS.append(func)
+  for args, handler in _ELEMENTWISE_API_HANDLERS.items():
+    if len(args) == 1:
+      _add_dispatch_for_unary_elementwise_api(func, args[0], handler)
+  return func
+
+
+def register_binary_elementwise_api(func):
+  """Decorator that registers a TensorFlow op as a binary elementwise API."""
+  _BINARY_ELEMENTWISE_APIS.append(func)
+  for args, handler in _ELEMENTWISE_API_HANDLERS.items():
+    if len(args) == 2:
+      _add_dispatch_for_binary_elementwise_api(func, args[0], args[1], handler)
+  return func
+
+
+def register_binary_elementwise_assert_api(func):
+  """Decorator that registers a TensorFlow op as a binary elementwise assert API.
+
+  Different from `dispatch_for_binary_elementwise_apis`, this decorator is used
+  for assert apis, such as assert_equal, assert_none_equal, etc, which return
+  None in eager mode and an op in graph mode.
+
+  Args:
+    func: The function that implements the binary elementwise assert API.
+
+  Returns:
+    `func`
+  """
+  _BINARY_ELEMENTWISE_ASSERT_APIS.append(func)
+  for args, handler in _ELEMENTWISE_API_HANDLERS.items():
+    if len(args) == 3 and args[2] is _ASSERT_API_TAG:
+      _add_dispatch_for_binary_elementwise_api(func, args[0], args[1], handler)
+  return func
+
+
+def unary_elementwise_apis():
+  """Returns a list of APIs that have been registered as unary elementwise."""
+  return tuple(_UNARY_ELEMENTWISE_APIS)
+
+
+def binary_elementwise_apis():
+  """Returns a list of APIs that have been registered as binary elementwise."""
+  return tuple(_BINARY_ELEMENTWISE_APIS)
+
+
+def _add_dispatch_for_unary_elementwise_api(api, x_type,
+                                            elementwise_api_handler):
+  """Registers a unary elementwise handler as a dispatcher for a given API."""
+  api_signature = tf_inspect.signature(api)
+  x_name = list(api_signature.parameters)[0]
+  name_index = _find_name_index(api_signature)
+
+  need_to_bind_api_args = (
+      len(api_signature.parameters) > 2 or
+      "name" not in api_signature.parameters)
+
+  @dispatch_for_api(api, {x_name: x_type})
+  def dispatch_target(*args, **kwargs):
+    args, kwargs, name = _extract_name_arg(args, kwargs, name_index)
+    if args:
+      x, args = args[0], args[1:]
+    else:
+      x = kwargs.pop(x_name)
+
+    if need_to_bind_api_args:
+      tensor_api = lambda v: api(v, *args, **kwargs)
+    else:
+      tensor_api = api
+
+    if name is None:
+      return elementwise_api_handler(tensor_api, x)
+    else:
+      with ops.name_scope(name, None, [x]):
+        return elementwise_api_handler(tensor_api, x)
+
+  dispatch_target.__name__ = "elementwise_dispatch_target_for_" + api.__name__
+  dispatch_target.__qualname__ = dispatch_target.__name__
+  # Keep track of what targets we've registered (so we can unregister them).
+  target_list = _ELEMENTWISE_API_TARGETS.setdefault((x_type,), [])
+  target_list.append((api, dispatch_target))
+
+
+def _add_dispatch_for_binary_elementwise_api(api, x_type, y_type,
+                                             elementwise_api_handler):
+  """Registers a binary elementwise handler as a dispatcher for a given API."""
+  api_signature = tf_inspect.signature(api)
+  x_name, y_name = list(api_signature.parameters)[:2]
+  name_index = _find_name_index(api_signature)
+
+  need_to_bind_api_args = (len(api_signature.parameters) > 3 or
+                           "name" not in api_signature.parameters)
+
+  @dispatch_for_api(api, {x_name: x_type, y_name: y_type})
+  def dispatch_target(*args, **kwargs):
+    args, kwargs, name = _extract_name_arg(args, kwargs, name_index)
+    if len(args) > 1:
+      x, y, args = args[0], args[1], args[2:]
+    elif args:
+      x, args = args[0], args[1:]
+      y = kwargs.pop(y_name, None)
+    else:
+      x = kwargs.pop(x_name, None)
+      y = kwargs.pop(y_name, None)
+
+    if need_to_bind_api_args:
+      tensor_api = lambda v1, v2: api(v1, v2, *args, **kwargs)
+    else:
+      tensor_api = api
+
+    if name is None:
+      return elementwise_api_handler(tensor_api, x, y)
+    else:
+      with ops.name_scope(name, None, [x, y]):
+        return elementwise_api_handler(tensor_api, x, y)
+
+  dispatch_target.__name__ = "elementwise_dispatch_target_for_" + api.__name__
+  dispatch_target.__qualname__ = dispatch_target.__name__
+  # Keep track of what targets we've registered (so we can unregister them).
+  target_list = _ELEMENTWISE_API_TARGETS.setdefault((x_type, y_type), [])
+  target_list.append((api, dispatch_target))
+
+
+def _find_name_index(signature):
+  """Returns the index of the `name` parameter, or -1 if it's not present."""
+  try:
+    return list(signature.parameters).index("name")
+  except ValueError:
+    return -1
+
+
+def _extract_name_arg(args, kwargs, name_index):
+  """Extracts the parameter `name` and returns `(args, kwargs, name_value)`."""
+  if name_index < 0:
+    name_value = None
+  elif name_index < len(args):
+    name_value = args[name_index]
+    args = args[:name_index] + args[name_index + 1:]
+  else:
+    name_value = kwargs.pop("name", None)
+  return args, kwargs, name_value
+
+
+def update_docstrings_with_api_lists():
+  """Updates the docstrings of dispatch decorators with API lists.
+
+  Updates docstrings for `dispatch_for_api`,
+  `dispatch_for_unary_elementwise_apis`, and
+  `dispatch_for_binary_elementwise_apis`, by replacing the string '<<API_LIST>>'
+  with a list of APIs that have been registered for that decorator.
+  """
+  _update_docstring_with_api_list(dispatch_for_unary_elementwise_apis,
+                                  _UNARY_ELEMENTWISE_APIS)
+  _update_docstring_with_api_list(dispatch_for_binary_elementwise_apis,
+                                  _BINARY_ELEMENTWISE_APIS)
+  _update_docstring_with_api_list(dispatch_for_binary_elementwise_assert_apis,
+                                  _BINARY_ELEMENTWISE_ASSERT_APIS)
+  _update_docstring_with_api_list(dispatch_for_api,
+                                  _TYPE_BASED_DISPATCH_SIGNATURES)
+
+
+def _update_docstring_with_api_list(target, api_list):
+  """Replaces `<<API_LIST>>` in target.__doc__ with the given list of APIs."""
+  lines = []
+  for func in api_list:
+    name = tf_export_lib.get_canonical_name_for_symbol(
+        func, add_prefix_to_v1_names=True)
+    if name is not None:
+      params = tf_inspect.signature(func).parameters.keys()
+      lines.append(f"  * `tf.{name}({', '.join(params)})`")
+  lines.sort()
+  target.__doc__ = target.__doc__.replace("  <<API_LIST>>", "\n".join(lines))
+
+
+################################################################################
+# Dispatch Support
+################################################################################
+@tf_export("__internal__.dispatch.add_dispatch_support", v1=[])
+def add_dispatch_support(target=None, iterable_parameters=None):
+  """Decorator that adds a dispatch handling wrapper to a TensorFlow Python API.
+
+  This wrapper adds the decorated function as an API that can be overridden
+  using the `@dispatch_for_api` decorator.  In the following example, we first
+  define a new API (`double`) that supports dispatch, then define a custom type
+  (`MaskedTensor`) and finally use `dispatch_for_api` to override the default
+  implementation of `double` when called with `MaskedTensor` values:
+
+  >>> @add_dispatch_support
+  ... def double(x):
+  ...   return x * 2
+  >>> class MaskedTensor(tf.experimental.ExtensionType):
+  ...   values: tf.Tensor
+  ...   mask: tf.Tensor
+  >>> @dispatch_for_api(double, {'x': MaskedTensor})
+  ... def masked_double(x):
+  ...   return MaskedTensor(x.values * 2, y.mask)
+
+  The optional `iterable_parameter` argument can be used to mark parameters that
+  can take arbitrary iterable values (such as generator expressions).  These
+  need to be handled specially during dispatch, since just iterating over an
+  iterable uses up its values.  In the following example, we define a new API
+  whose second argument can be an iterable value; and then override the default
+  implementatio of that API when the iterable contains MaskedTensors:
+
+  >>> @add_dispatch_support(iterable_parameters=['ys'])
+  ... def add_tensor_to_list_of_tensors(x, ys):
+  ...   return [x + y for y in ys]
+  >>> @dispatch_for_api(add_tensor_to_list_of_tensors,
+  ...               {'ys': typing.List[MaskedTensor]})
+  ... def masked_add_tensor_to_list_of_tensors(x, ys):
+  ...   return [MaskedTensor(x+y.values, y.mask) for y in ys]
+
+  (Note: the only TensorFlow API that currently supports iterables is `add_n`.)
+
+  Args:
+    target: The TensorFlow API that should support dispatch.
+    iterable_parameters: Optional list of parameter names that may be called
+      with iterables (such as the `inputs` parameter for `tf.add_n`).
+
+  Returns:
+    A decorator.
+  """
+
+  if not (iterable_parameters is None or
+          (isinstance(iterable_parameters, (list, tuple)) and
+           all(isinstance(p, str) for p in iterable_parameters))):
+    raise TypeError("iterable_parameters should be a list or tuple of string.")
+
+  def decorator(dispatch_target):
+
+    # Get the name & index for each iterable parameter.
+    if iterable_parameters is None:
+      iterable_params = None
+    else:
+      arg_names = tf_inspect.getargspec(dispatch_target).args
+      iterable_params = [
+          (name, arg_names.index(name)) for name in iterable_parameters
+      ]
+
+    @traceback_utils.filter_traceback
+    def op_dispatch_handler(*args, **kwargs):
+      """Call `dispatch_target`, peforming dispatch when appropriate."""
+
+      # Type-based dispatch system (dispatch v2):
+      if api_dispatcher is not None:
+        if iterable_params is not None:
+          args, kwargs = replace_iterable_params(args, kwargs, iterable_params)
+        result = api_dispatcher.Dispatch(args, kwargs)
+        if result is not NotImplemented:
+          return result
+
+      # Fallback dispatch system (dispatch v1):
+      try:
+        return dispatch_target(*args, **kwargs)
+      except (TypeError, ValueError):
+        # Note: convert_to_eager_tensor currently raises a ValueError, not a
+        # TypeError, when given unexpected types.  So we need to catch both.
+        result = dispatch(op_dispatch_handler, args, kwargs)
+        if result is not OpDispatcher.NOT_SUPPORTED:
+          return result
+        else:
+          raise
+
+    add_fallback_dispatch_list(op_dispatch_handler)
+    op_dispatch_handler = tf_decorator.make_decorator(dispatch_target,
+                                                      op_dispatch_handler)
+    add_type_based_api_dispatcher(op_dispatch_handler)
+    api_dispatcher = getattr(op_dispatch_handler, TYPE_BASED_DISPATCH_ATTR,
+                             None)
+    return op_dispatch_handler
+
+  if target is None:
+    return decorator
+  else:
+    return decorator(target)
+
+
+def replace_iterable_params(args, kwargs, iterable_params):
+  """Returns (args, kwargs) with any iterable parameters converted to lists.
+
+  Args:
+    args: Positional rguments to a function
+    kwargs: Keyword arguments to a function.
+    iterable_params: A list of (name, index) tuples for iterable parameters.
+
+  Returns:
+    A tuple (args, kwargs), where any positional or keyword parameters in
+    `iterable_params` have their value converted to a `list`.
+  """
+  args = list(args)
+  for name, index in iterable_params:
+    if index < len(args):
+      args[index] = list(args[index])
+    elif name in kwargs:
+      kwargs[name] = list(kwargs[name])
+  return tuple(args), kwargs

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/example_parser_configuration.py

@@ -0,0 +1,206 @@
+# 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.
+# ==============================================================================
+"""Extract parse_example op configuration to a proto."""
+
+from tensorflow.core.example import example_parser_configuration_pb2
+from tensorflow.python.framework import tensor_shape
+from tensorflow.python.framework import tensor_util
+
+
+def extract_example_parser_configuration(parse_example_op, sess):
+  """Returns an ExampleParserConfig proto.
+
+  Args:
+    parse_example_op: A ParseExample or ParseExampleV2 `Operation`
+    sess: A tf.compat.v1.Session needed to obtain some configuration values.
+  Returns:
+    A ExampleParserConfig proto.
+
+  Raises:
+    ValueError: If attributes are inconsistent.
+  """
+  if parse_example_op.type == "ParseExample":
+    return _extract_from_parse_example(parse_example_op, sess)
+  elif parse_example_op.type == "ParseExampleV2":
+    return _extract_from_parse_example_v2(parse_example_op, sess)
+  else:
+    raise ValueError(
+        "Found unexpected type when parsing example. Expected `ParseExample` "
+        f"object. Received type: {parse_example_op.type}")
+
+
+def _extract_from_parse_example(parse_example_op, sess):
+  """Extract ExampleParserConfig from ParseExample op."""
+  config = example_parser_configuration_pb2.ExampleParserConfiguration()
+
+  num_sparse = parse_example_op.get_attr("Nsparse")
+  num_dense = parse_example_op.get_attr("Ndense")
+  total_features = num_dense + num_sparse
+
+  sparse_types = parse_example_op.get_attr("sparse_types")
+  dense_types = parse_example_op.get_attr("Tdense")
+  dense_shapes = parse_example_op.get_attr("dense_shapes")
+
+  if len(sparse_types) != num_sparse:
+    raise ValueError("len(sparse_types) attribute does not match "
+                     "Nsparse attribute (%d vs %d)" %
+                     (len(sparse_types), num_sparse))
+
+  if len(dense_types) != num_dense:
+    raise ValueError("len(dense_types) attribute does not match "
+                     "Ndense attribute (%d vs %d)" %
+                     (len(dense_types), num_dense))
+
+  if len(dense_shapes) != num_dense:
+    raise ValueError("len(dense_shapes) attribute does not match "
+                     "Ndense attribute (%d vs %d)" %
+                     (len(dense_shapes), num_dense))
+
+  # Skip over the serialized input, and the names input.
+  fetch_list = parse_example_op.inputs[2:]
+
+  # Fetch total_features key names and num_dense default values.
+  if len(fetch_list) != (total_features + num_dense):
+    raise ValueError("len(fetch_list) does not match total features + "
+                     "num_dense (%d vs %d)" %
+                     (len(fetch_list), (total_features + num_dense)))
+
+  fetched = sess.run(fetch_list)
+
+  if len(fetched) != len(fetch_list):
+    raise ValueError("len(fetched) does not match len(fetch_list) "
+                     "(%d vs %d)" % (len(fetched), len(fetch_list)))
+
+  # Fetch indices.
+  sparse_keys_start = 0
+  dense_keys_start = sparse_keys_start + num_sparse
+  dense_def_start = dense_keys_start + num_dense
+
+  # Output tensor indices.
+  sparse_indices_start = 0
+  sparse_values_start = num_sparse
+  sparse_shapes_start = sparse_values_start + num_sparse
+  dense_values_start = sparse_shapes_start + num_sparse
+
+  # Dense features.
+  for i in range(num_dense):
+    key = fetched[dense_keys_start + i]
+    feature_config = config.feature_map[key]
+    # Convert the default value numpy array fetched from the session run
+    # into a TensorProto.
+    fixed_config = feature_config.fixed_len_feature
+
+    fixed_config.default_value.CopyFrom(
+        tensor_util.make_tensor_proto(fetched[dense_def_start + i]))
+    # Convert the shape from the attributes
+    # into a TensorShapeProto.
+    fixed_config.shape.CopyFrom(
+        tensor_shape.TensorShape(dense_shapes[i]).as_proto())
+
+    fixed_config.dtype = dense_types[i].as_datatype_enum
+    # Get the output tensor name.
+    fixed_config.values_output_tensor_name = parse_example_op.outputs[
+        dense_values_start + i].name
+
+  # Sparse features.
+  for i in range(num_sparse):
+    key = fetched[sparse_keys_start + i]
+    feature_config = config.feature_map[key]
+    var_len_feature = feature_config.var_len_feature
+    var_len_feature.dtype = sparse_types[i].as_datatype_enum
+    var_len_feature.indices_output_tensor_name = parse_example_op.outputs[
+        sparse_indices_start + i].name
+    var_len_feature.values_output_tensor_name = parse_example_op.outputs[
+        sparse_values_start + i].name
+    var_len_feature.shapes_output_tensor_name = parse_example_op.outputs[
+        sparse_shapes_start + i].name
+
+  return config
+
+
+def _extract_from_parse_example_v2(parse_example_op, sess):
+  """Extract ExampleParserConfig from ParseExampleV2 op."""
+  config = example_parser_configuration_pb2.ExampleParserConfiguration()
+
+  dense_types = parse_example_op.get_attr("Tdense")
+  num_sparse = parse_example_op.get_attr("num_sparse")
+  sparse_types = parse_example_op.get_attr("sparse_types")
+  ragged_value_types = parse_example_op.get_attr("ragged_value_types")
+  ragged_split_types = parse_example_op.get_attr("ragged_split_types")
+  dense_shapes = parse_example_op.get_attr("dense_shapes")
+
+  num_dense = len(dense_types)
+  num_ragged = len(ragged_value_types)
+  assert len(ragged_value_types) == len(ragged_split_types)
+  assert len(parse_example_op.inputs) == 5 + num_dense
+
+  # Skip over the serialized input, and the names input.
+  fetched = sess.run(parse_example_op.inputs[2:])
+  sparse_keys = fetched[0].tolist()
+  dense_keys = fetched[1].tolist()
+  ragged_keys = fetched[2].tolist()
+  dense_defaults = fetched[3:]
+  assert len(sparse_keys) == num_sparse
+  assert len(dense_keys) == num_dense
+  assert len(ragged_keys) == num_ragged
+
+  # Output tensor indices.
+  sparse_indices_start = 0
+  sparse_values_start = num_sparse
+  sparse_shapes_start = sparse_values_start + num_sparse
+  dense_values_start = sparse_shapes_start + num_sparse
+  ragged_values_start = dense_values_start + num_dense
+  ragged_row_splits_start = ragged_values_start + num_ragged
+
+  # Dense features.
+  for i in range(num_dense):
+    key = dense_keys[i]
+    feature_config = config.feature_map[key]
+    # Convert the default value numpy array fetched from the session run
+    # into a TensorProto.
+    fixed_config = feature_config.fixed_len_feature
+
+    fixed_config.default_value.CopyFrom(
+        tensor_util.make_tensor_proto(dense_defaults[i]))
+    # Convert the shape from the attributes
+    # into a TensorShapeProto.
+    fixed_config.shape.CopyFrom(
+        tensor_shape.TensorShape(dense_shapes[i]).as_proto())
+
+    fixed_config.dtype = dense_types[i].as_datatype_enum
+    # Get the output tensor name.
+    fixed_config.values_output_tensor_name = parse_example_op.outputs[
+        dense_values_start + i].name
+
+  # Sparse features.
+  for i in range(num_sparse):
+    key = sparse_keys[i]
+    feature_config = config.feature_map[key]
+    var_len_feature = feature_config.var_len_feature
+    var_len_feature.dtype = sparse_types[i].as_datatype_enum
+    var_len_feature.indices_output_tensor_name = parse_example_op.outputs[
+        sparse_indices_start + i].name
+    var_len_feature.values_output_tensor_name = parse_example_op.outputs[
+        sparse_values_start + i].name
+    var_len_feature.shapes_output_tensor_name = parse_example_op.outputs[
+        sparse_shapes_start + i].name
+
+  if num_ragged != 0:
+    del ragged_values_start  # unused
+    del ragged_row_splits_start  # unused
+    raise ValueError("Ragged features are not yet supported by "
+                     "example_parser_configuration.proto")
+
+  return config

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/tensorflow/python/util/fast_module_type.pyi

@@ -0,0 +1,16 @@
+# Copyright 2023 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.
+# ==============================================================================
+
+def get_fast_module_type_class() -> object: ...