"""
@generated by mypy-protobuf.  Do not edit manually!
isort:skip_file
"""

import builtins
import collections.abc
import sys
import typing

import google.protobuf.descriptor
import google.protobuf.internal.containers
import google.protobuf.internal.enum_type_wrapper
import google.protobuf.message
import tensorflow.core.framework.cost_graph_pb2
import tensorflow.core.framework.graph_pb2
import tensorflow.core.framework.step_stats_pb2
import tensorflow.core.protobuf.cluster_pb2
import tensorflow.core.protobuf.debug_pb2
import tensorflow.core.protobuf.rewriter_config_pb2
import tensorflow.tsl.protobuf.coordination_config_pb2
import tensorflow.tsl.protobuf.rpc_options_pb2

if sys.version_info >= (3, 10):
    import typing as typing_extensions
else:
    import typing_extensions

DESCRIPTOR: google.protobuf.descriptor.FileDescriptor

@typing.final
class GPUOptions(google.protobuf.message.Message):
    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    @typing.final
    class Experimental(google.protobuf.message.Message):
        DESCRIPTOR: google.protobuf.descriptor.Descriptor

        @typing.final
        class VirtualDevices(google.protobuf.message.Message):
            """Configuration for breaking down a visible GPU into multiple "virtual"
            devices.
            """

            DESCRIPTOR: google.protobuf.descriptor.Descriptor

            MEMORY_LIMIT_MB_FIELD_NUMBER: builtins.int
            PRIORITY_FIELD_NUMBER: builtins.int
            DEVICE_ORDINAL_FIELD_NUMBER: builtins.int
            @property
            def memory_limit_mb(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.float]:
                """Per "virtual" device memory limit, in MB. The number of elements in
                the list is the number of virtual devices to create on the
                corresponding visible GPU (see "virtual_devices" below).
                If empty and `num_virtual_devices_per_gpu` is not set, it will create
                single virtual device taking all available memory from the device.

                For the concept of "visible" and "virtual" GPU, see the comments for
                "visible_device_list" above for more information.
                """

            @property
            def priority(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
                """Priority values to use with the virtual devices. Use the cuda function
                cudaDeviceGetStreamPriorityRange to query for valid range of values for
                priority.

                On a P4000 GPU with cuda 10.1, the priority range reported was 0 for
                least priority and -1 for greatest priority.

                If this field is not specified, then the virtual devices will be
                created with the default. If this field has values set, then the size
                of this must match with the above memory_limit_mb.
                """

            @property
            def device_ordinal(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
                """Virtual Device ordinal number determines the device ID of the device.
                A Virtual device with a lower ordinal number always receives the a
                smaller device id. The phyiscal device id and location in the
                virtual device list is used to break ties.
                """

            def __init__(
                self,
                *,
                memory_limit_mb: collections.abc.Iterable[builtins.float] | None = ...,
                priority: collections.abc.Iterable[builtins.int] | None = ...,
                device_ordinal: collections.abc.Iterable[builtins.int] | None = ...,
            ) -> None: ...
            def ClearField(
                self,
                field_name: typing.Literal[
                    "device_ordinal", b"device_ordinal", "memory_limit_mb", b"memory_limit_mb", "priority", b"priority"
                ],
            ) -> None: ...

        @typing.final
        class StreamMergeOptions(google.protobuf.message.Message):
            """Whether to merge data transfer streams into the compute stream in the
            same stream group. Stream merging helps reduce the overhead caused by
            stream synchronization, especially when data transfers are frequent. For
            example, setting "merge_host_to_device_stream = true" will make the
            compute stream responsible for both computation and host to device memory
            copy.
            """

            DESCRIPTOR: google.protobuf.descriptor.Descriptor

            MERGE_HOST_TO_DEVICE_STREAM_FIELD_NUMBER: builtins.int
            MERGE_DEVICE_TO_HOST_STREAM_FIELD_NUMBER: builtins.int
            MERGE_DEVICE_TO_DEVICE_STREAM_FIELD_NUMBER: builtins.int
            merge_host_to_device_stream: builtins.bool
            """If true, the compute stream will be used for host_to_device copy as
            well. It's no longer necessary to record an event before the copy to
            let the copy stream wait for the compute stream to finish. There is
            also no need to wait for the copy to complete before executing the
            callback function.
            """
            merge_device_to_host_stream: builtins.bool
            """If true, the compute stream will be used for device_to_host copy as
            well. It's no longer necessary to record an event before the copy to
            let the copy stream wait for the compute stream to finish.
            """
            merge_device_to_device_stream: builtins.bool
            """If true, the compute stream will be used for device_to_device copy as
            well. It's no longer necessary to record an event before the copy to
            let the copy stream wait for the compute stream of the sending device
            to finish. There is also no need to wait for the compute stream of the
            receiving device to finish if the copy is within the same device.
            """
            def __init__(
                self,
                *,
                merge_host_to_device_stream: builtins.bool | None = ...,
                merge_device_to_host_stream: builtins.bool | None = ...,
                merge_device_to_device_stream: builtins.bool | None = ...,
            ) -> None: ...
            def ClearField(
                self,
                field_name: typing.Literal[
                    "merge_device_to_device_stream",
                    b"merge_device_to_device_stream",
                    "merge_device_to_host_stream",
                    b"merge_device_to_host_stream",
                    "merge_host_to_device_stream",
                    b"merge_host_to_device_stream",
                ],
            ) -> None: ...

        VIRTUAL_DEVICES_FIELD_NUMBER: builtins.int
        NUM_VIRTUAL_DEVICES_PER_GPU_FIELD_NUMBER: builtins.int
        USE_UNIFIED_MEMORY_FIELD_NUMBER: builtins.int
        NUM_DEV_TO_DEV_COPY_STREAMS_FIELD_NUMBER: builtins.int
        COLLECTIVE_RING_ORDER_FIELD_NUMBER: builtins.int
        TIMESTAMPED_ALLOCATOR_FIELD_NUMBER: builtins.int
        KERNEL_TRACKER_MAX_INTERVAL_FIELD_NUMBER: builtins.int
        KERNEL_TRACKER_MAX_BYTES_FIELD_NUMBER: builtins.int
        KERNEL_TRACKER_MAX_PENDING_FIELD_NUMBER: builtins.int
        INTERNAL_FRAGMENTATION_FRACTION_FIELD_NUMBER: builtins.int
        USE_CUDA_MALLOC_ASYNC_FIELD_NUMBER: builtins.int
        DISALLOW_RETRY_ON_ALLOCATION_FAILURE_FIELD_NUMBER: builtins.int
        GPU_HOST_MEM_LIMIT_IN_MB_FIELD_NUMBER: builtins.int
        GPU_HOST_MEM_DISALLOW_GROWTH_FIELD_NUMBER: builtins.int
        GPU_SYSTEM_MEMORY_SIZE_IN_MB_FIELD_NUMBER: builtins.int
        POPULATE_PJRT_GPU_CLIENT_CREATION_INFO_FIELD_NUMBER: builtins.int
        NODE_ID_FIELD_NUMBER: builtins.int
        STREAM_MERGE_OPTIONS_FIELD_NUMBER: builtins.int
        num_virtual_devices_per_gpu: builtins.int
        """The number of virtual devices to create on each visible GPU. The
        available memory will be split equally among all virtual devices. If the
        field `memory_limit_mb` in `VirtualDevices` is not empty, this field will
        be ignored.
        """
        use_unified_memory: builtins.bool
        """If true, uses CUDA unified memory for memory allocations. If
        per_process_gpu_memory_fraction option is greater than 1.0, then unified
        memory is used regardless of the value for this field. See comments for
        per_process_gpu_memory_fraction field for more details and requirements
        of the unified memory. This option is useful to oversubscribe memory if
        multiple processes are sharing a single GPU while individually using less
        than 1.0 per process memory fraction.
        """
        num_dev_to_dev_copy_streams: builtins.int
        """If > 1, the number of device-to-device copy streams to create
        for each GPUDevice.  Default value is 0, which is automatically
        converted to 1.
        """
        collective_ring_order: builtins.str
        """If non-empty, defines a good GPU ring order on a single worker based on
        device interconnect.  This assumes that all workers have the same GPU
        topology.  Specify as a comma-separated string, e.g. "3,2,1,0,7,6,5,4".
        This ring order is used by the RingReducer implementation of
        CollectiveReduce, and serves as an override to automatic ring order
        generation in OrderTaskDeviceMap() during CollectiveParam resolution.
        """
        timestamped_allocator: builtins.bool
        """If true then extra work is done by GPUDevice and GPUBFCAllocator to
        keep track of when GPU memory is freed and when kernels actually
        complete so that we can know when a nominally free memory chunk
        is really not subject to pending use.
        """
        kernel_tracker_max_interval: builtins.int
        """reserved id: 6

        Parameters for GPUKernelTracker.  By default no kernel tracking is done.
        Note that timestamped_allocator is only effective if some tracking is
        specified.

        If kernel_tracker_max_interval = n > 0, then a tracking event
        is inserted after every n kernels without an event.
        """
        kernel_tracker_max_bytes: builtins.int
        """If kernel_tracker_max_bytes = n > 0, then a tracking event is
        inserted after every series of kernels allocating a sum of
        memory >= n.  If one kernel allocates b * n bytes, then one
        event will be inserted after it, but it will count as b against
        the pending limit.
        """
        kernel_tracker_max_pending: builtins.int
        """If kernel_tracker_max_pending > 0 then no more than this many
        tracking events can be outstanding at a time.  An attempt to
        launch an additional kernel will stall until an event
        completes.
        """
        internal_fragmentation_fraction: builtins.float
        """BFC Allocator can return an allocated chunk of memory upto 2x the
        requested size. For virtual devices with tight memory constraints, and
        proportionately large allocation requests, this can lead to a significant
        reduction in available memory. The threshold below controls when a chunk
        should be split if the chunk size exceeds requested memory size. It is
        expressed as a fraction of total available memory for the tf device. For
        example setting it to 0.05 would imply a chunk needs to be split if its
        size exceeds the requested memory by 5% of the total virtual device/gpu
        memory size.
        """
        use_cuda_malloc_async: builtins.bool
        """When true, use CUDA cudaMallocAsync API instead of TF gpu allocator."""
        disallow_retry_on_allocation_failure: builtins.bool
        """By default, BFCAllocator may sleep when it runs out of memory, in the
        hopes that another thread will free up memory in the meantime.  Setting
        this to true disables the sleep; instead we'll OOM immediately.
        """
        gpu_host_mem_limit_in_mb: builtins.float
        """Memory limit for "GPU host allocator", aka pinned memory allocator.  This
        can also be set via the envvar TF_GPU_HOST_MEM_LIMIT_IN_MB.
        """
        gpu_host_mem_disallow_growth: builtins.bool
        """If true, then the host allocator allocates its max memory all upfront and
        never grows.  This can be useful for latency-sensitive systems, because
        growing the GPU host memory pool can be expensive.

        You probably only want to use this in combination with
        gpu_host_mem_limit_in_mb, because the default GPU host memory limit is
        quite high.
        """
        gpu_system_memory_size_in_mb: builtins.int
        """Memory limit for gpu system. This can also be set by
        TF_DEVICE_MIN_SYS_MEMORY_IN_MB, which takes precedence over
        gpu_system_memory_size_in_mb. With this, user can configure the gpu
        system memory size for better resource estimation of multi-tenancy(one
        gpu with multiple model) use case.
        """
        populate_pjrt_gpu_client_creation_info: builtins.bool
        """If true, save information needed for created a PjRt GPU client for
        creating a client with remote devices.
        """
        node_id: builtins.int
        """node_id for use when creating a PjRt GPU client with remote devices,
        which enumerates jobs*tasks from a ServerDef.
        """
        @property
        def virtual_devices(
            self,
        ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___GPUOptions.Experimental.VirtualDevices]:
            """The multi virtual device settings. If empty (not set), it will create
            single virtual device on each visible GPU, according to the settings
            in "visible_device_list" above. Otherwise, the number of elements in the
            list must be the same as the number of visible GPUs (after
            "visible_device_list" filtering if it is set), and the string represented
            device names (e.g. /device:GPU:<id>) will refer to the virtual
            devices and have the <id> field assigned sequentially starting from 0,
            according to the order of the virtual devices determined by
            device_ordinal and the location in the virtual device list.

            For example,
              visible_device_list = "1,0"
              virtual_devices { memory_limit: 1GB memory_limit: 2GB }
              virtual_devices { memory_limit: 3GB memory_limit: 4GB }
            will create 4 virtual devices as:
              /device:GPU:0 -> visible GPU 1 with 1GB memory
              /device:GPU:1 -> visible GPU 1 with 2GB memory
              /device:GPU:2 -> visible GPU 0 with 3GB memory
              /device:GPU:3 -> visible GPU 0 with 4GB memory

            but
              visible_device_list = "1,0"
              virtual_devices { memory_limit: 1GB memory_limit: 2GB
                                device_ordinal: 10 device_ordinal: 20}
              virtual_devices { memory_limit: 3GB memory_limit: 4GB
                                device_ordinal: 10 device_ordinal: 20}
            will create 4 virtual devices as:
              /device:GPU:0 -> visible GPU 1 with 1GB memory  (ordinal 10)
              /device:GPU:1 -> visible GPU 0 with 3GB memory  (ordinal 10)
              /device:GPU:2 -> visible GPU 1 with 2GB memory  (ordinal 20)
              /device:GPU:3 -> visible GPU 0 with 4GB memory  (ordinal 20)

            NOTE:
            1. It's invalid to set both this and "per_process_gpu_memory_fraction"
               at the same time.
            2. Currently this setting is per-process, not per-session. Using
               different settings in different sessions within same process will
               result in undefined behavior.
            """

        @property
        def stream_merge_options(self) -> global___GPUOptions.Experimental.StreamMergeOptions: ...
        def __init__(
            self,
            *,
            virtual_devices: collections.abc.Iterable[global___GPUOptions.Experimental.VirtualDevices] | None = ...,
            num_virtual_devices_per_gpu: builtins.int | None = ...,
            use_unified_memory: builtins.bool | None = ...,
            num_dev_to_dev_copy_streams: builtins.int | None = ...,
            collective_ring_order: builtins.str | None = ...,
            timestamped_allocator: builtins.bool | None = ...,
            kernel_tracker_max_interval: builtins.int | None = ...,
            kernel_tracker_max_bytes: builtins.int | None = ...,
            kernel_tracker_max_pending: builtins.int | None = ...,
            internal_fragmentation_fraction: builtins.float | None = ...,
            use_cuda_malloc_async: builtins.bool | None = ...,
            disallow_retry_on_allocation_failure: builtins.bool | None = ...,
            gpu_host_mem_limit_in_mb: builtins.float | None = ...,
            gpu_host_mem_disallow_growth: builtins.bool | None = ...,
            gpu_system_memory_size_in_mb: builtins.int | None = ...,
            populate_pjrt_gpu_client_creation_info: builtins.bool | None = ...,
            node_id: builtins.int | None = ...,
            stream_merge_options: global___GPUOptions.Experimental.StreamMergeOptions | None = ...,
        ) -> None: ...
        def HasField(self, field_name: typing.Literal["stream_merge_options", b"stream_merge_options"]) -> builtins.bool: ...
        def ClearField(
            self,
            field_name: typing.Literal[
                "collective_ring_order",
                b"collective_ring_order",
                "disallow_retry_on_allocation_failure",
                b"disallow_retry_on_allocation_failure",
                "gpu_host_mem_disallow_growth",
                b"gpu_host_mem_disallow_growth",
                "gpu_host_mem_limit_in_mb",
                b"gpu_host_mem_limit_in_mb",
                "gpu_system_memory_size_in_mb",
                b"gpu_system_memory_size_in_mb",
                "internal_fragmentation_fraction",
                b"internal_fragmentation_fraction",
                "kernel_tracker_max_bytes",
                b"kernel_tracker_max_bytes",
                "kernel_tracker_max_interval",
                b"kernel_tracker_max_interval",
                "kernel_tracker_max_pending",
                b"kernel_tracker_max_pending",
                "node_id",
                b"node_id",
                "num_dev_to_dev_copy_streams",
                b"num_dev_to_dev_copy_streams",
                "num_virtual_devices_per_gpu",
                b"num_virtual_devices_per_gpu",
                "populate_pjrt_gpu_client_creation_info",
                b"populate_pjrt_gpu_client_creation_info",
                "stream_merge_options",
                b"stream_merge_options",
                "timestamped_allocator",
                b"timestamped_allocator",
                "use_cuda_malloc_async",
                b"use_cuda_malloc_async",
                "use_unified_memory",
                b"use_unified_memory",
                "virtual_devices",
                b"virtual_devices",
            ],
        ) -> None: ...

    PER_PROCESS_GPU_MEMORY_FRACTION_FIELD_NUMBER: builtins.int
    ALLOW_GROWTH_FIELD_NUMBER: builtins.int
    ALLOCATOR_TYPE_FIELD_NUMBER: builtins.int
    DEFERRED_DELETION_BYTES_FIELD_NUMBER: builtins.int
    VISIBLE_DEVICE_LIST_FIELD_NUMBER: builtins.int
    POLLING_ACTIVE_DELAY_USECS_FIELD_NUMBER: builtins.int
    POLLING_INACTIVE_DELAY_MSECS_FIELD_NUMBER: builtins.int
    FORCE_GPU_COMPATIBLE_FIELD_NUMBER: builtins.int
    EXPERIMENTAL_FIELD_NUMBER: builtins.int
    per_process_gpu_memory_fraction: builtins.float
    """Fraction of the total GPU memory to allocate for each process.
    1 means to allocate all of the GPU memory, 0.5 means the process
    allocates up to ~50% of the total GPU memory.

    GPU memory is pre-allocated unless the allow_growth option is enabled.

    If greater than 1.0, uses CUDA unified memory to potentially oversubscribe
    the amount of memory available on the GPU device by using host memory as a
    swap space. Accessing memory not available on the device will be
    significantly slower as that would require memory transfer between the host
    and the device. Options to reduce the memory requirement should be
    considered before enabling this option as this may come with a negative
    performance impact. Oversubscription using the unified memory requires
    Pascal class or newer GPUs and it is currently only supported on the Linux
    operating system. See
    https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#um-requirements
    for the detailed requirements.
    """
    allow_growth: builtins.bool
    """If true, the allocator does not pre-allocate the entire specified
    GPU memory region, instead starting small and growing as needed.
    """
    allocator_type: builtins.str
    """The type of GPU allocation strategy to use.

    Allowed values:
    "": The empty string (default) uses a system-chosen default
        which may change over time.

    "BFC": A "Best-fit with coalescing" algorithm, simplified from a
           version of dlmalloc.
    """
    deferred_deletion_bytes: builtins.int
    """Delay deletion of up to this many bytes to reduce the number of
    interactions with gpu driver code.  If 0, the system chooses
    a reasonable default (several MBs).
    """
    visible_device_list: builtins.str
    """A comma-separated list of GPU ids that determines the 'visible'
    to 'virtual' mapping of GPU devices.  For example, if TensorFlow
    can see 8 GPU devices in the process, and one wanted to map
    visible GPU devices 5 and 3 as "/device:GPU:0", and "/device:GPU:1",
    then one would specify this field as "5,3".  This field is similar in
    spirit to the CUDA_VISIBLE_DEVICES environment variable, except
    it applies to the visible GPU devices in the process.

    NOTE:
    1. The GPU driver provides the process with the visible GPUs
       in an order which is not guaranteed to have any correlation to
       the *physical* GPU id in the machine.  This field is used for
       remapping "visible" to "virtual", which means this operates only
       after the process starts.  Users are required to use vendor
       specific mechanisms (e.g., CUDA_VISIBLE_DEVICES) to control the
       physical to visible device mapping prior to invoking TensorFlow.
    2. In the code, the ids in this list are also called "platform GPU id"s,
       and the 'virtual' ids of GPU devices (i.e. the ids in the device
       name "/device:GPU:<id>") are also called "TF GPU id"s. Please
       refer to third_party/tensorflow/core/common_runtime/gpu/gpu_id.h
       for more information.
    """
    polling_active_delay_usecs: builtins.int
    """In the event polling loop sleep this many microseconds between
    PollEvents calls, when the queue is not empty.  If value is not
    set or set to 0, gets set to a non-zero default.
    """
    polling_inactive_delay_msecs: builtins.int
    """This field is deprecated and ignored."""
    force_gpu_compatible: builtins.bool
    """Force all tensors to be gpu_compatible. On a GPU-enabled TensorFlow,
    enabling this option forces all CPU tensors to be allocated with Cuda
    pinned memory. Normally, TensorFlow will infer which tensors should be
    allocated as the pinned memory. But in case where the inference is
    incomplete, this option can significantly speed up the cross-device memory
    copy performance as long as it fits the memory.
    Note that this option is not something that should be
    enabled by default for unknown or very large models, since all Cuda pinned
    memory is unpageable, having too much pinned memory might negatively impact
    the overall host system performance.
    """
    @property
    def experimental(self) -> global___GPUOptions.Experimental:
        """Everything inside experimental is subject to change and is not subject
        to API stability guarantees in
        https://www.tensorflow.org/guide/version_compat.
        """

    def __init__(
        self,
        *,
        per_process_gpu_memory_fraction: builtins.float | None = ...,
        allow_growth: builtins.bool | None = ...,
        allocator_type: builtins.str | None = ...,
        deferred_deletion_bytes: builtins.int | None = ...,
        visible_device_list: builtins.str | None = ...,
        polling_active_delay_usecs: builtins.int | None = ...,
        polling_inactive_delay_msecs: builtins.int | None = ...,
        force_gpu_compatible: builtins.bool | None = ...,
        experimental: global___GPUOptions.Experimental | None = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["experimental", b"experimental"]) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "allocator_type",
            b"allocator_type",
            "allow_growth",
            b"allow_growth",
            "deferred_deletion_bytes",
            b"deferred_deletion_bytes",
            "experimental",
            b"experimental",
            "force_gpu_compatible",
            b"force_gpu_compatible",
            "per_process_gpu_memory_fraction",
            b"per_process_gpu_memory_fraction",
            "polling_active_delay_usecs",
            b"polling_active_delay_usecs",
            "polling_inactive_delay_msecs",
            b"polling_inactive_delay_msecs",
            "visible_device_list",
            b"visible_device_list",
        ],
    ) -> None: ...

global___GPUOptions = GPUOptions

@typing.final
class OptimizerOptions(google.protobuf.message.Message):
    """Options passed to the graph optimizer"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    class _Level:
        ValueType = typing.NewType("ValueType", builtins.int)
        V: typing_extensions.TypeAlias = ValueType

    class _LevelEnumTypeWrapper(
        google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[OptimizerOptions._Level.ValueType], builtins.type
    ):
        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
        L1: OptimizerOptions._Level.ValueType  # 0
        """L1 is the default level.
        Optimization performed at L1 :
        1. Common subexpression elimination
        2. Constant folding
        """
        L0: OptimizerOptions._Level.ValueType  # -1
        """No optimizations"""

    class Level(_Level, metaclass=_LevelEnumTypeWrapper):
        """Optimization level"""

    L1: OptimizerOptions.Level.ValueType  # 0
    """L1 is the default level.
    Optimization performed at L1 :
    1. Common subexpression elimination
    2. Constant folding
    """
    L0: OptimizerOptions.Level.ValueType  # -1
    """No optimizations"""

    class _GlobalJitLevel:
        ValueType = typing.NewType("ValueType", builtins.int)
        V: typing_extensions.TypeAlias = ValueType

    class _GlobalJitLevelEnumTypeWrapper(
        google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[OptimizerOptions._GlobalJitLevel.ValueType], builtins.type
    ):
        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
        DEFAULT: OptimizerOptions._GlobalJitLevel.ValueType  # 0
        """Default setting ("off" now, but later expected to be "on")"""
        OFF: OptimizerOptions._GlobalJitLevel.ValueType  # -1
        ON_1: OptimizerOptions._GlobalJitLevel.ValueType  # 1
        """The following settings turn on compilation, with higher values being
        more aggressive.  Higher values may reduce opportunities for parallelism
        and may use more memory.  (At present, there is no distinction, but this
        is expected to change.)
        """
        ON_2: OptimizerOptions._GlobalJitLevel.ValueType  # 2

    class GlobalJitLevel(_GlobalJitLevel, metaclass=_GlobalJitLevelEnumTypeWrapper):
        """Control the use of the compiler/jit.  Experimental."""

    DEFAULT: OptimizerOptions.GlobalJitLevel.ValueType  # 0
    """Default setting ("off" now, but later expected to be "on")"""
    OFF: OptimizerOptions.GlobalJitLevel.ValueType  # -1
    ON_1: OptimizerOptions.GlobalJitLevel.ValueType  # 1
    """The following settings turn on compilation, with higher values being
    more aggressive.  Higher values may reduce opportunities for parallelism
    and may use more memory.  (At present, there is no distinction, but this
    is expected to change.)
    """
    ON_2: OptimizerOptions.GlobalJitLevel.ValueType  # 2

    DO_COMMON_SUBEXPRESSION_ELIMINATION_FIELD_NUMBER: builtins.int
    DO_CONSTANT_FOLDING_FIELD_NUMBER: builtins.int
    MAX_FOLDED_CONSTANT_IN_BYTES_FIELD_NUMBER: builtins.int
    DO_FUNCTION_INLINING_FIELD_NUMBER: builtins.int
    OPT_LEVEL_FIELD_NUMBER: builtins.int
    GLOBAL_JIT_LEVEL_FIELD_NUMBER: builtins.int
    CPU_GLOBAL_JIT_FIELD_NUMBER: builtins.int
    do_common_subexpression_elimination: builtins.bool
    """If true, optimize the graph using common subexpression elimination.
    Note: the optimization Level L1 will override this setting to true. So in
    order to disable common subexpression elimination the opt_level has to be
    set to L0.
    """
    do_constant_folding: builtins.bool
    """If true, perform constant folding optimization on the graph.
    Note: the optimization Level L1 will override this setting to true. So in
    order to disable constant folding the opt_level has to be set to L0.
    """
    max_folded_constant_in_bytes: builtins.int
    """Constant folding optimization replaces tensors whose values can be
    predetermined, with constant nodes. To avoid inserting too large constants,
    the size of each constant created can be limited. If this value is zero, a
    default limit of 10 MiB will be applied. If constant folding optimization
    is disabled, this value is ignored.
    """
    do_function_inlining: builtins.bool
    """If true, perform function inlining on the graph."""
    opt_level: global___OptimizerOptions.Level.ValueType
    """Overall optimization level. The actual optimizations applied will be the
    logical OR of the flags that this level implies and any flags already set.
    """
    global_jit_level: global___OptimizerOptions.GlobalJitLevel.ValueType
    cpu_global_jit: builtins.bool
    """CPU code will be autoclustered only if global_jit_level >= ON_1 and either:
     - this flag is true, or
     - TF_XLA_FLAGS contains --tf_xla_cpu_global_jit=true.
    """
    def __init__(
        self,
        *,
        do_common_subexpression_elimination: builtins.bool | None = ...,
        do_constant_folding: builtins.bool | None = ...,
        max_folded_constant_in_bytes: builtins.int | None = ...,
        do_function_inlining: builtins.bool | None = ...,
        opt_level: global___OptimizerOptions.Level.ValueType | None = ...,
        global_jit_level: global___OptimizerOptions.GlobalJitLevel.ValueType | None = ...,
        cpu_global_jit: builtins.bool | None = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "cpu_global_jit",
            b"cpu_global_jit",
            "do_common_subexpression_elimination",
            b"do_common_subexpression_elimination",
            "do_constant_folding",
            b"do_constant_folding",
            "do_function_inlining",
            b"do_function_inlining",
            "global_jit_level",
            b"global_jit_level",
            "max_folded_constant_in_bytes",
            b"max_folded_constant_in_bytes",
            "opt_level",
            b"opt_level",
        ],
    ) -> None: ...

global___OptimizerOptions = OptimizerOptions

@typing.final
class GraphOptions(google.protobuf.message.Message):
    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    ENABLE_RECV_SCHEDULING_FIELD_NUMBER: builtins.int
    OPTIMIZER_OPTIONS_FIELD_NUMBER: builtins.int
    BUILD_COST_MODEL_FIELD_NUMBER: builtins.int
    BUILD_COST_MODEL_AFTER_FIELD_NUMBER: builtins.int
    INFER_SHAPES_FIELD_NUMBER: builtins.int
    PLACE_PRUNED_GRAPH_FIELD_NUMBER: builtins.int
    ENABLE_BFLOAT16_SENDRECV_FIELD_NUMBER: builtins.int
    TIMELINE_STEP_FIELD_NUMBER: builtins.int
    REWRITE_OPTIONS_FIELD_NUMBER: builtins.int
    enable_recv_scheduling: builtins.bool
    """If true, use control flow to schedule the activation of Recv nodes.
    (Currently ignored.)
    """
    build_cost_model: builtins.int
    """The number of steps to run before returning a cost model detailing
    the memory usage and performance of each node of the graph. 0 means
    no cost model.
    """
    build_cost_model_after: builtins.int
    """The number of steps to skip before collecting statistics for the
    cost model.
    """
    infer_shapes: builtins.bool
    """Annotate each Node with Op output shape data, to the extent it can
    be statically inferred.
    """
    place_pruned_graph: builtins.bool
    """Only place the subgraphs that are run, rather than the entire graph.

    This is useful for interactive graph building, where one might
    produce graphs that cannot be placed during the debugging
    process.  In particular, it allows the client to continue work in
    a session after adding a node to a graph whose placement
    constraints are unsatisfiable.
    """
    enable_bfloat16_sendrecv: builtins.bool
    """If true, transfer float values between processes as bfloat16."""
    timeline_step: builtins.int
    """If > 0, record a timeline every this many steps.
    EXPERIMENTAL: This currently has no effect in MasterSession.
    """
    @property
    def optimizer_options(self) -> global___OptimizerOptions:
        """Options controlling how graph is optimized."""

    @property
    def rewrite_options(self) -> tensorflow.core.protobuf.rewriter_config_pb2.RewriterConfig:
        """Options that control the type and amount of graph rewriting.
        Not currently configurable via the public Python API (i.e. there is no API
        stability guarantee if you import RewriterConfig explicitly).
        """

    def __init__(
        self,
        *,
        enable_recv_scheduling: builtins.bool | None = ...,
        optimizer_options: global___OptimizerOptions | None = ...,
        build_cost_model: builtins.int | None = ...,
        build_cost_model_after: builtins.int | None = ...,
        infer_shapes: builtins.bool | None = ...,
        place_pruned_graph: builtins.bool | None = ...,
        enable_bfloat16_sendrecv: builtins.bool | None = ...,
        timeline_step: builtins.int | None = ...,
        rewrite_options: tensorflow.core.protobuf.rewriter_config_pb2.RewriterConfig | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["optimizer_options", b"optimizer_options", "rewrite_options", b"rewrite_options"]
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "build_cost_model",
            b"build_cost_model",
            "build_cost_model_after",
            b"build_cost_model_after",
            "enable_bfloat16_sendrecv",
            b"enable_bfloat16_sendrecv",
            "enable_recv_scheduling",
            b"enable_recv_scheduling",
            "infer_shapes",
            b"infer_shapes",
            "optimizer_options",
            b"optimizer_options",
            "place_pruned_graph",
            b"place_pruned_graph",
            "rewrite_options",
            b"rewrite_options",
            "timeline_step",
            b"timeline_step",
        ],
    ) -> None: ...

global___GraphOptions = GraphOptions

@typing.final
class ThreadPoolOptionProto(google.protobuf.message.Message):
    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    NUM_THREADS_FIELD_NUMBER: builtins.int
    GLOBAL_NAME_FIELD_NUMBER: builtins.int
    num_threads: builtins.int
    """The number of threads in the pool.

    0 means the system picks a value based on where this option proto is used
    (see the declaration of the specific field for more info).
    """
    global_name: builtins.str
    """The global name of the threadpool.

    If empty, then the threadpool is made and used according to the scope it's
    in - e.g., for a session threadpool, it is used by that session only.

    If non-empty, then:
    - a global threadpool associated with this name is looked
      up or created. This allows, for example, sharing one threadpool across
      many sessions (e.g., like the default behavior, if
      inter_op_parallelism_threads is not configured), but still partitioning
      into a large and small pool.
    - if the threadpool for this global_name already exists, then it is an
      error if the existing pool was created using a different num_threads
      value as is specified on this call.
    - threadpools created this way are never garbage collected.
    """
    def __init__(self, *, num_threads: builtins.int | None = ..., global_name: builtins.str | None = ...) -> None: ...
    def ClearField(self, field_name: typing.Literal["global_name", b"global_name", "num_threads", b"num_threads"]) -> None: ...

global___ThreadPoolOptionProto = ThreadPoolOptionProto

@typing.final
class SessionMetadata(google.protobuf.message.Message):
    """Metadata about the session.

    This can be used by the runtime and the Ops for debugging, monitoring, etc.

    The (name, version) tuple is expected to be a unique identifier for
    sessions within the same process.

    NOTE: This is currently used and propagated only by the direct session.
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    NAME_FIELD_NUMBER: builtins.int
    VERSION_FIELD_NUMBER: builtins.int
    name: builtins.str
    version: builtins.int
    """The version is optional. If set, needs to be >= 0."""
    def __init__(self, *, name: builtins.str | None = ..., version: builtins.int | None = ...) -> None: ...
    def ClearField(self, field_name: typing.Literal["name", b"name", "version", b"version"]) -> None: ...

global___SessionMetadata = SessionMetadata

@typing.final
class ConfigProto(google.protobuf.message.Message):
    """Session configuration parameters.
    The system picks appropriate values for fields that are not set.
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    @typing.final
    class DeviceCountEntry(google.protobuf.message.Message):
        DESCRIPTOR: google.protobuf.descriptor.Descriptor

        KEY_FIELD_NUMBER: builtins.int
        VALUE_FIELD_NUMBER: builtins.int
        key: builtins.str
        value: builtins.int
        def __init__(self, *, key: builtins.str | None = ..., value: builtins.int | None = ...) -> None: ...
        def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ...

    @typing.final
    class Experimental(google.protobuf.message.Message):
        """Everything inside Experimental is subject to change and is not subject
        to API stability guarantees in
        https://www.tensorflow.org/guide/version_compat.
        """

        DESCRIPTOR: google.protobuf.descriptor.Descriptor

        class _MlirBridgeRollout:
            ValueType = typing.NewType("ValueType", builtins.int)
            V: typing_extensions.TypeAlias = ValueType

        class _MlirBridgeRolloutEnumTypeWrapper(
            google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[ConfigProto.Experimental._MlirBridgeRollout.ValueType],
            builtins.type,
        ):
            DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
            MLIR_BRIDGE_ROLLOUT_UNSPECIFIED: ConfigProto.Experimental._MlirBridgeRollout.ValueType  # 0
            """If this field is left unspecified, the MLIR bridge may be selectively
            enabled on a per graph basis.
            """
            MLIR_BRIDGE_ROLLOUT_ENABLED: ConfigProto.Experimental._MlirBridgeRollout.ValueType  # 1
            """Enabling the MLIR bridge enables it for all graphs in this session."""
            MLIR_BRIDGE_ROLLOUT_DISABLED: ConfigProto.Experimental._MlirBridgeRollout.ValueType  # 2
            """Disabling the MLIR bridge disables it for all graphs in this session."""

        class MlirBridgeRollout(_MlirBridgeRollout, metaclass=_MlirBridgeRolloutEnumTypeWrapper):
            """An enum that describes the state of the MLIR bridge rollout."""

        MLIR_BRIDGE_ROLLOUT_UNSPECIFIED: ConfigProto.Experimental.MlirBridgeRollout.ValueType  # 0
        """If this field is left unspecified, the MLIR bridge may be selectively
        enabled on a per graph basis.
        """
        MLIR_BRIDGE_ROLLOUT_ENABLED: ConfigProto.Experimental.MlirBridgeRollout.ValueType  # 1
        """Enabling the MLIR bridge enables it for all graphs in this session."""
        MLIR_BRIDGE_ROLLOUT_DISABLED: ConfigProto.Experimental.MlirBridgeRollout.ValueType  # 2
        """Disabling the MLIR bridge disables it for all graphs in this session."""

        COLLECTIVE_GROUP_LEADER_FIELD_NUMBER: builtins.int
        EXECUTOR_TYPE_FIELD_NUMBER: builtins.int
        RECV_BUF_MAX_CHUNK_FIELD_NUMBER: builtins.int
        USE_NUMA_AFFINITY_FIELD_NUMBER: builtins.int
        COLLECTIVE_DETERMINISTIC_SEQUENTIAL_EXECUTION_FIELD_NUMBER: builtins.int
        COLLECTIVE_NCCL_FIELD_NUMBER: builtins.int
        SHARE_SESSION_STATE_IN_CLUSTERSPEC_PROPAGATION_FIELD_NUMBER: builtins.int
        DISABLE_THREAD_SPINNING_FIELD_NUMBER: builtins.int
        SHARE_CLUSTER_DEVICES_IN_SESSION_FIELD_NUMBER: builtins.int
        SESSION_METADATA_FIELD_NUMBER: builtins.int
        OPTIMIZE_FOR_STATIC_GRAPH_FIELD_NUMBER: builtins.int
        ENABLE_MLIR_BRIDGE_FIELD_NUMBER: builtins.int
        MLIR_BRIDGE_ROLLOUT_FIELD_NUMBER: builtins.int
        ENABLE_MLIR_GRAPH_OPTIMIZATION_FIELD_NUMBER: builtins.int
        DISABLE_OUTPUT_PARTITION_GRAPHS_FIELD_NUMBER: builtins.int
        XLA_FUSION_AUTOTUNER_THRESH_FIELD_NUMBER: builtins.int
        USE_TFRT_FIELD_NUMBER: builtins.int
        ENABLE_MULTI_HOST_FIELD_NUMBER: builtins.int
        TFRT_USE_IFRT_FIELD_NUMBER: builtins.int
        BACKEND_SERVER_PORT_FIELD_NUMBER: builtins.int
        TARGET_TPU_FIELD_NUMBER: builtins.int
        TARGET_GPU_FIELD_NUMBER: builtins.int
        STREAM_MERGE_THRESHOLD_FIELD_NUMBER: builtins.int
        DISABLE_FUNCTIONAL_OPS_LOWERING_FIELD_NUMBER: builtins.int
        XLA_PREFER_SINGLE_GRAPH_CLUSTER_FIELD_NUMBER: builtins.int
        COORDINATION_CONFIG_FIELD_NUMBER: builtins.int
        DISABLE_OPTIMIZE_FOR_STATIC_GRAPH_FIELD_NUMBER: builtins.int
        DISABLE_EAGER_EXECUTOR_STREAMING_ENQUEUE_FIELD_NUMBER: builtins.int
        collective_group_leader: builtins.str
        """Task name for group resolution."""
        executor_type: builtins.str
        """Which executor to use, the default executor will be used
        if it is an empty string or "DEFAULT"
        """
        recv_buf_max_chunk: builtins.int
        """Guidance to formatting of large RecvBuf fields for transfer.
        Any positive value sets the max chunk size.  0 defaults to 4096.
        Any negative value indicates no max, i.e. one chunk only.
        """
        use_numa_affinity: builtins.bool
        """If true, and supported by the platform, the runtime will attempt to
        use NUMA affinity where applicable.  One consequence will be the
        existence of as many CPU devices as there are available NUMA nodes.
        """
        collective_deterministic_sequential_execution: builtins.bool
        """If true, make collective op execution order sequential and deterministic
        for potentially concurrent collective instances.
        """
        collective_nccl: builtins.bool
        """If true, use NCCL for CollectiveOps.  This feature is highly
        experimental.
        """
        share_session_state_in_clusterspec_propagation: builtins.bool
        """In the following, session state means the value of a variable, elements
        in a hash table, or any other resource, accessible by worker sessions
        held by a TF server.

        When ClusterSpec propagation is enabled, the value of
        isolate_session_state is ignored when deciding whether to share session
        states in a TF server (for backwards compatibility reasons).
        - If share_session_state_in_clusterspec_propagation is true, the session
        states are shared.
        - If share_session_state_in_clusterspec_propagation is false, session
        states are isolated.

        When clusterspec propagation is not used, the value of
        share_session_state_in_clusterspec_propagation is ignored when deciding
        whether to share session states in a TF server.
        - If isolate_session_state is true, session states are isolated.
        - If isolate_session_state is false, session states are shared.

        TODO(b/129330037): Add a single API that consistently treats
        isolate_session_state and ClusterSpec propagation.
        """
        disable_thread_spinning: builtins.bool
        """If using a direct session, disable spinning while waiting for work in
        the thread pool. This may result in higher latency for completing ops,
        but in the case where there is a lot of spinning may result in lower
        CPU usage.
        """
        share_cluster_devices_in_session: builtins.bool
        """This was promoted to a non-experimental API. Please use
        ConfigProto.share_cluster_devices_in_session instead.
        """
        optimize_for_static_graph: builtins.bool
        """If true, the session may treat the graph as being static for optimization
        purposes.

        If this option is set to true when a session is created, the full
        GraphDef must be passed in a single call to Session::Create(), and
        Session::Extend() may not be supported.
        """
        enable_mlir_bridge: builtins.bool
        """Whether to enable the MLIR-based TF->XLA bridge. This is only used if set
        to true. Default value or false is ignored. Use mlir_bridge_rollout for
        finer control.

        If this option is set to true when a session is created, MLIR is used to
        perform the set of graph transformations to put the graph in a form that
        can be executed with delegation of some computations to an accelerator.
        This builds on the model of XLA where a subset of the graph is
        encapsulated and attached to a "compile" operation, whose result is fed
        to an "execute" operation. The kernel for these operations is responsible
        to lower the encapsulated graph to a particular device.
        """
        mlir_bridge_rollout: global___ConfigProto.Experimental.MlirBridgeRollout.ValueType
        """Whether to enable the MLIR-based TF->XLA bridge."""
        enable_mlir_graph_optimization: builtins.bool
        """Whether to enable the MLIR-based Graph optimizations.

        This will become a part of standard Tensorflow graph optimization
        pipeline, currently this is only used for gradual migration and testing
        new passes that are replacing existing optimizations in Grappler.
        """
        disable_output_partition_graphs: builtins.bool
        """If true, the session will not store an additional copy of the graph for
        each subgraph.

        If this option is set to true when a session is created, the
        `RunOptions.output_partition_graphs` options must not be set.
        """
        xla_fusion_autotuner_thresh: builtins.int
        """Minimum number of batches run through the XLA graph before XLA fusion
        autotuner is enabled. Default value of zero disables the autotuner.

        The XLA fusion autotuner can improve performance by executing a heuristic
        search on the compiler parameters.
        """
        use_tfrt: builtins.bool
        """Whether runtime execution uses TFRT."""
        enable_multi_host: builtins.bool
        """If true, use Pathways with TFRT API for multi host support."""
        tfrt_use_ifrt: builtins.bool
        """If true, use ifrt as the backend for TFRT. This is only used when
        `use_tfrt` is true.
        """
        backend_server_port: builtins.int
        """Port for the Pathways server. Ignored if enable_multi_host=false."""
        target_tpu: builtins.bool
        """If true, TFRT will use TPU specific compiler passes and perform TPU
        specific initialization.
        """
        target_gpu: builtins.bool
        """If true, TFRT will use GPU specific compiler passes and perform GPU
        specific initialization.
        """
        stream_merge_threshold: builtins.int
        """The threshold to merge small streams in TFRT. The stream with cost
        smaller than the threshold will be merged. Setting it to value 1
        disables all merges.
        """
        disable_functional_ops_lowering: builtins.bool
        """Whether functional control flow op lowering should be disabled. This is
        useful when executing within a portable runtime where control flow op
        kernels may not be loaded due to selective registration.
        """
        xla_prefer_single_graph_cluster: builtins.bool
        """Provides a hint to XLA auto clustering to prefer forming a single large
        cluster that encompases most of the graph.
        """
        disable_optimize_for_static_graph: builtins.bool
        """If true, the session will treat the graph as being non-static for
        optimization purposes.

        If this option is set to true when a session is created, the full
        GraphDef will be retained to enable calls to Session::Extend().
        Calling Extend() without setting this flag will result in errors.

        This option is meant to replace `optimize_for_static_graph` and it
        aims to negate its value.
        """
        disable_eager_executor_streaming_enqueue: builtins.bool
        """Whether eager remote execution will stream all the function calls or
        allow them to happen in parallel. When true, streaming execution is
        disabled, and parallel execution is allowed.
        """
        @property
        def session_metadata(self) -> global___SessionMetadata:
            """Metadata about the session.

            If set, this can be used by the runtime and the Ops for debugging,
            monitoring, etc.

            NOTE: This is currently used and propagated only by the direct session
            and EagerContext.
            """

        @property
        def coordination_config(self) -> tensorflow.tsl.protobuf.coordination_config_pb2.CoordinationServiceConfig:
            """Distributed coordination service configurations."""

        def __init__(
            self,
            *,
            collective_group_leader: builtins.str | None = ...,
            executor_type: builtins.str | None = ...,
            recv_buf_max_chunk: builtins.int | None = ...,
            use_numa_affinity: builtins.bool | None = ...,
            collective_deterministic_sequential_execution: builtins.bool | None = ...,
            collective_nccl: builtins.bool | None = ...,
            share_session_state_in_clusterspec_propagation: builtins.bool | None = ...,
            disable_thread_spinning: builtins.bool | None = ...,
            share_cluster_devices_in_session: builtins.bool | None = ...,
            session_metadata: global___SessionMetadata | None = ...,
            optimize_for_static_graph: builtins.bool | None = ...,
            enable_mlir_bridge: builtins.bool | None = ...,
            mlir_bridge_rollout: global___ConfigProto.Experimental.MlirBridgeRollout.ValueType | None = ...,
            enable_mlir_graph_optimization: builtins.bool | None = ...,
            disable_output_partition_graphs: builtins.bool | None = ...,
            xla_fusion_autotuner_thresh: builtins.int | None = ...,
            use_tfrt: builtins.bool | None = ...,
            enable_multi_host: builtins.bool | None = ...,
            tfrt_use_ifrt: builtins.bool | None = ...,
            backend_server_port: builtins.int | None = ...,
            target_tpu: builtins.bool | None = ...,
            target_gpu: builtins.bool | None = ...,
            stream_merge_threshold: builtins.int | None = ...,
            disable_functional_ops_lowering: builtins.bool | None = ...,
            xla_prefer_single_graph_cluster: builtins.bool | None = ...,
            coordination_config: tensorflow.tsl.protobuf.coordination_config_pb2.CoordinationServiceConfig | None = ...,
            disable_optimize_for_static_graph: builtins.bool | None = ...,
            disable_eager_executor_streaming_enqueue: builtins.bool | None = ...,
        ) -> None: ...
        def HasField(
            self,
            field_name: typing.Literal["coordination_config", b"coordination_config", "session_metadata", b"session_metadata"],
        ) -> builtins.bool: ...
        def ClearField(
            self,
            field_name: typing.Literal[
                "backend_server_port",
                b"backend_server_port",
                "collective_deterministic_sequential_execution",
                b"collective_deterministic_sequential_execution",
                "collective_group_leader",
                b"collective_group_leader",
                "collective_nccl",
                b"collective_nccl",
                "coordination_config",
                b"coordination_config",
                "disable_eager_executor_streaming_enqueue",
                b"disable_eager_executor_streaming_enqueue",
                "disable_functional_ops_lowering",
                b"disable_functional_ops_lowering",
                "disable_optimize_for_static_graph",
                b"disable_optimize_for_static_graph",
                "disable_output_partition_graphs",
                b"disable_output_partition_graphs",
                "disable_thread_spinning",
                b"disable_thread_spinning",
                "enable_mlir_bridge",
                b"enable_mlir_bridge",
                "enable_mlir_graph_optimization",
                b"enable_mlir_graph_optimization",
                "enable_multi_host",
                b"enable_multi_host",
                "executor_type",
                b"executor_type",
                "mlir_bridge_rollout",
                b"mlir_bridge_rollout",
                "optimize_for_static_graph",
                b"optimize_for_static_graph",
                "recv_buf_max_chunk",
                b"recv_buf_max_chunk",
                "session_metadata",
                b"session_metadata",
                "share_cluster_devices_in_session",
                b"share_cluster_devices_in_session",
                "share_session_state_in_clusterspec_propagation",
                b"share_session_state_in_clusterspec_propagation",
                "stream_merge_threshold",
                b"stream_merge_threshold",
                "target_gpu",
                b"target_gpu",
                "target_tpu",
                b"target_tpu",
                "tfrt_use_ifrt",
                b"tfrt_use_ifrt",
                "use_numa_affinity",
                b"use_numa_affinity",
                "use_tfrt",
                b"use_tfrt",
                "xla_fusion_autotuner_thresh",
                b"xla_fusion_autotuner_thresh",
                "xla_prefer_single_graph_cluster",
                b"xla_prefer_single_graph_cluster",
            ],
        ) -> None: ...

    DEVICE_COUNT_FIELD_NUMBER: builtins.int
    INTRA_OP_PARALLELISM_THREADS_FIELD_NUMBER: builtins.int
    INTER_OP_PARALLELISM_THREADS_FIELD_NUMBER: builtins.int
    USE_PER_SESSION_THREADS_FIELD_NUMBER: builtins.int
    SESSION_INTER_OP_THREAD_POOL_FIELD_NUMBER: builtins.int
    PLACEMENT_PERIOD_FIELD_NUMBER: builtins.int
    DEVICE_FILTERS_FIELD_NUMBER: builtins.int
    GPU_OPTIONS_FIELD_NUMBER: builtins.int
    PLUGGABLE_DEVICE_OPTIONS_FIELD_NUMBER: builtins.int
    ALLOW_SOFT_PLACEMENT_FIELD_NUMBER: builtins.int
    LOG_DEVICE_PLACEMENT_FIELD_NUMBER: builtins.int
    GRAPH_OPTIONS_FIELD_NUMBER: builtins.int
    OPERATION_TIMEOUT_IN_MS_FIELD_NUMBER: builtins.int
    RPC_OPTIONS_FIELD_NUMBER: builtins.int
    CLUSTER_DEF_FIELD_NUMBER: builtins.int
    ISOLATE_SESSION_STATE_FIELD_NUMBER: builtins.int
    SHARE_CLUSTER_DEVICES_IN_SESSION_FIELD_NUMBER: builtins.int
    EXPERIMENTAL_FIELD_NUMBER: builtins.int
    intra_op_parallelism_threads: builtins.int
    """The execution of an individual op (for some op types) can be
    parallelized on a pool of intra_op_parallelism_threads.
    0 means the system picks an appropriate number.

    If you create an ordinary session, e.g., from Python or C++,
    then there is exactly one intra op thread pool per process.
    The first session created determines the number of threads in this pool.
    All subsequent sessions reuse/share this one global pool.

    There are notable exceptions to the default behavior described above:
    1. There is an environment variable  for overriding this thread pool,
       named TF_OVERRIDE_GLOBAL_THREADPOOL.
    2. When connecting to a server, such as a remote `tf.train.Server`
       instance, then this option will be ignored altogether.
    """
    inter_op_parallelism_threads: builtins.int
    """Nodes that perform blocking operations are enqueued on a pool of
    inter_op_parallelism_threads available in each process.

    0 means the system picks an appropriate number.
    Negative means all operations are performed in caller's thread.

    Note that the first Session created in the process sets the
    number of threads for all future sessions unless use_per_session_threads is
    true or session_inter_op_thread_pool is configured.
    """
    use_per_session_threads: builtins.bool
    """If true, use a new set of threads for this session rather than the global
    pool of threads. Only supported by direct sessions.

    If false, use the global threads created by the first session, or the
    per-session thread pools configured by session_inter_op_thread_pool.

    This option is deprecated. The same effect can be achieved by setting
    session_inter_op_thread_pool to have one element, whose num_threads equals
    inter_op_parallelism_threads.
    """
    placement_period: builtins.int
    """Assignment of Nodes to Devices is recomputed every placement_period
    steps until the system warms up (at which point the recomputation
    typically slows down automatically).
    """
    allow_soft_placement: builtins.bool
    """Whether soft placement is allowed. If allow_soft_placement is true,
    an op will be placed on CPU if
      1. there's no GPU implementation for the OP
    or
      2. no GPU devices are known or registered
    or
      3. need to co-locate with reftype input(s) which are from CPU.
    """
    log_device_placement: builtins.bool
    """Whether device placements should be logged."""
    operation_timeout_in_ms: builtins.int
    """Global timeout for all blocking operations in this session.  If non-zero,
    and not overridden on a per-operation basis, this value will be used as the
    deadline for all blocking operations.
    """
    isolate_session_state: builtins.bool
    """If true, any resources such as Variables used in the session will not be
    shared with other sessions. However, when clusterspec propagation is
    enabled, this field is ignored and sessions are always isolated.
    """
    share_cluster_devices_in_session: builtins.bool
    """When true, WorkerSessions are created with device attributes from the
    full cluster.
    This is helpful when a worker wants to partition a graph
    (for example during a PartitionedCallOp).
    """
    @property
    def device_count(self) -> google.protobuf.internal.containers.ScalarMap[builtins.str, builtins.int]:
        """Map from device type name (e.g., "CPU" or "GPU" ) to maximum
        number of devices of that type to use.  If a particular device
        type is not found in the map, the system picks an appropriate
        number.
        """

    @property
    def session_inter_op_thread_pool(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ThreadPoolOptionProto]:
        """This option is experimental - it may be replaced with a different mechanism
        in the future.

        Configures session thread pools. If this is configured, then RunOptions for
        a Run call can select the thread pool to use.

        The intended use is for when some session invocations need to run in a
        background pool limited to a small number of threads:
        - For example, a session may be configured to have one large pool (for
        regular compute) and one small pool (for periodic, low priority work);
        using the small pool is currently the mechanism for limiting the inter-op
        parallelism of the low priority work.  Note that it does not limit the
        parallelism of work spawned by a single op kernel implementation.
        - Using this setting is normally not needed in training, but may help some
        serving use cases.
        - It is also generally recommended to set the global_name field of this
        proto, to avoid creating multiple large pools. It is typically better to
        run the non-low-priority work, even across sessions, in a single large
        pool.
        """

    @property
    def device_filters(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
        """When any filters are present sessions will ignore all devices which do not
        match the filters. Each filter can be partially specified, e.g. "/job:ps"
        "/job:worker/replica:3", etc.
        """

    @property
    def gpu_options(self) -> global___GPUOptions:
        """Options that apply to all GPUs."""

    @property
    def pluggable_device_options(self) -> global___GPUOptions:
        """Options that apply to pluggable devices."""

    @property
    def graph_options(self) -> global___GraphOptions:
        """Options that apply to all graphs."""

    @property
    def rpc_options(self) -> tensorflow.tsl.protobuf.rpc_options_pb2.RPCOptions:
        """Options that apply when this session uses the distributed runtime."""

    @property
    def cluster_def(self) -> tensorflow.core.protobuf.cluster_pb2.ClusterDef:
        """Optional list of all workers to use in this session."""

    @property
    def experimental(self) -> global___ConfigProto.Experimental: ...
    def __init__(
        self,
        *,
        device_count: collections.abc.Mapping[builtins.str, builtins.int] | None = ...,
        intra_op_parallelism_threads: builtins.int | None = ...,
        inter_op_parallelism_threads: builtins.int | None = ...,
        use_per_session_threads: builtins.bool | None = ...,
        session_inter_op_thread_pool: collections.abc.Iterable[global___ThreadPoolOptionProto] | None = ...,
        placement_period: builtins.int | None = ...,
        device_filters: collections.abc.Iterable[builtins.str] | None = ...,
        gpu_options: global___GPUOptions | None = ...,
        pluggable_device_options: global___GPUOptions | None = ...,
        allow_soft_placement: builtins.bool | None = ...,
        log_device_placement: builtins.bool | None = ...,
        graph_options: global___GraphOptions | None = ...,
        operation_timeout_in_ms: builtins.int | None = ...,
        rpc_options: tensorflow.tsl.protobuf.rpc_options_pb2.RPCOptions | None = ...,
        cluster_def: tensorflow.core.protobuf.cluster_pb2.ClusterDef | None = ...,
        isolate_session_state: builtins.bool | None = ...,
        share_cluster_devices_in_session: builtins.bool | None = ...,
        experimental: global___ConfigProto.Experimental | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing.Literal[
            "cluster_def",
            b"cluster_def",
            "experimental",
            b"experimental",
            "gpu_options",
            b"gpu_options",
            "graph_options",
            b"graph_options",
            "pluggable_device_options",
            b"pluggable_device_options",
            "rpc_options",
            b"rpc_options",
        ],
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "allow_soft_placement",
            b"allow_soft_placement",
            "cluster_def",
            b"cluster_def",
            "device_count",
            b"device_count",
            "device_filters",
            b"device_filters",
            "experimental",
            b"experimental",
            "gpu_options",
            b"gpu_options",
            "graph_options",
            b"graph_options",
            "inter_op_parallelism_threads",
            b"inter_op_parallelism_threads",
            "intra_op_parallelism_threads",
            b"intra_op_parallelism_threads",
            "isolate_session_state",
            b"isolate_session_state",
            "log_device_placement",
            b"log_device_placement",
            "operation_timeout_in_ms",
            b"operation_timeout_in_ms",
            "placement_period",
            b"placement_period",
            "pluggable_device_options",
            b"pluggable_device_options",
            "rpc_options",
            b"rpc_options",
            "session_inter_op_thread_pool",
            b"session_inter_op_thread_pool",
            "share_cluster_devices_in_session",
            b"share_cluster_devices_in_session",
            "use_per_session_threads",
            b"use_per_session_threads",
        ],
    ) -> None: ...

global___ConfigProto = ConfigProto

@typing.final
class RunOptions(google.protobuf.message.Message):
    """Options for a single Run() call."""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    class _TraceLevel:
        ValueType = typing.NewType("ValueType", builtins.int)
        V: typing_extensions.TypeAlias = ValueType

    class _TraceLevelEnumTypeWrapper(
        google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[RunOptions._TraceLevel.ValueType], builtins.type
    ):
        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
        NO_TRACE: RunOptions._TraceLevel.ValueType  # 0
        SOFTWARE_TRACE: RunOptions._TraceLevel.ValueType  # 1
        HARDWARE_TRACE: RunOptions._TraceLevel.ValueType  # 2
        FULL_TRACE: RunOptions._TraceLevel.ValueType  # 3

    class TraceLevel(_TraceLevel, metaclass=_TraceLevelEnumTypeWrapper):
        """TODO(pbar) Turn this into a TraceOptions proto which allows
        tracing to be controlled in a more orthogonal manner?
        """

    NO_TRACE: RunOptions.TraceLevel.ValueType  # 0
    SOFTWARE_TRACE: RunOptions.TraceLevel.ValueType  # 1
    HARDWARE_TRACE: RunOptions.TraceLevel.ValueType  # 2
    FULL_TRACE: RunOptions.TraceLevel.ValueType  # 3

    @typing.final
    class Experimental(google.protobuf.message.Message):
        """Everything inside Experimental is subject to change and is not subject
        to API stability guarantees in
        https://www.tensorflow.org/guide/version_compat.
        """

        DESCRIPTOR: google.protobuf.descriptor.Descriptor

        @typing.final
        class RunHandlerPoolOptions(google.protobuf.message.Message):
            """Options for run handler thread pool."""

            DESCRIPTOR: google.protobuf.descriptor.Descriptor

            PRIORITY_FIELD_NUMBER: builtins.int
            priority: builtins.int
            """Priority of the request. The run handler thread pool will schedule ops
            based on the priority number. The larger number means higher priority.
            """
            def __init__(self, *, priority: builtins.int | None = ...) -> None: ...
            def ClearField(self, field_name: typing.Literal["priority", b"priority"]) -> None: ...

        COLLECTIVE_GRAPH_KEY_FIELD_NUMBER: builtins.int
        USE_RUN_HANDLER_POOL_FIELD_NUMBER: builtins.int
        RUN_HANDLER_POOL_OPTIONS_FIELD_NUMBER: builtins.int
        collective_graph_key: builtins.int
        """If non-zero, declares that this graph is going to use collective
        ops and must synchronize step_ids with any other graph with this
        same group_key value (in a distributed computation where tasks
        run disjoint graphs).
        """
        use_run_handler_pool: builtins.bool
        """If true, then operations (using the inter-op pool) across all
        session::run() calls will be centrally scheduled, optimizing for (median
        and tail) latency.
        Consider using this option for CPU-bound workloads like inference.
        """
        @property
        def run_handler_pool_options(self) -> global___RunOptions.Experimental.RunHandlerPoolOptions: ...
        def __init__(
            self,
            *,
            collective_graph_key: builtins.int | None = ...,
            use_run_handler_pool: builtins.bool | None = ...,
            run_handler_pool_options: global___RunOptions.Experimental.RunHandlerPoolOptions | None = ...,
        ) -> None: ...
        def HasField(
            self, field_name: typing.Literal["run_handler_pool_options", b"run_handler_pool_options"]
        ) -> builtins.bool: ...
        def ClearField(
            self,
            field_name: typing.Literal[
                "collective_graph_key",
                b"collective_graph_key",
                "run_handler_pool_options",
                b"run_handler_pool_options",
                "use_run_handler_pool",
                b"use_run_handler_pool",
            ],
        ) -> None: ...

    TRACE_LEVEL_FIELD_NUMBER: builtins.int
    TIMEOUT_IN_MS_FIELD_NUMBER: builtins.int
    INTER_OP_THREAD_POOL_FIELD_NUMBER: builtins.int
    OUTPUT_PARTITION_GRAPHS_FIELD_NUMBER: builtins.int
    DEBUG_OPTIONS_FIELD_NUMBER: builtins.int
    REPORT_TENSOR_ALLOCATIONS_UPON_OOM_FIELD_NUMBER: builtins.int
    EXPERIMENTAL_FIELD_NUMBER: builtins.int
    trace_level: global___RunOptions.TraceLevel.ValueType
    timeout_in_ms: builtins.int
    """Time to wait for operation to complete in milliseconds."""
    inter_op_thread_pool: builtins.int
    """The thread pool to use, if session_inter_op_thread_pool is configured.
    To use the caller thread set this to -1 - this uses the caller thread
    to execute Session::Run() and thus avoids a context switch. Using the
    caller thread to execute Session::Run() should be done ONLY for simple
    graphs, where the overhead of an additional context switch is
    comparable with the overhead of Session::Run().
    """
    output_partition_graphs: builtins.bool
    """Whether the partition graph(s) executed by the executor(s) should be
    outputted via RunMetadata.
    """
    report_tensor_allocations_upon_oom: builtins.bool
    """When enabled, causes tensor allocation information to be included in
    the error message when the Run() call fails because the allocator ran
    out of memory (OOM).

    Enabling this option can slow down the Run() call.
    """
    @property
    def debug_options(self) -> tensorflow.core.protobuf.debug_pb2.DebugOptions:
        """EXPERIMENTAL.  Options used to initialize DebuggerState, if enabled."""

    @property
    def experimental(self) -> global___RunOptions.Experimental: ...
    def __init__(
        self,
        *,
        trace_level: global___RunOptions.TraceLevel.ValueType | None = ...,
        timeout_in_ms: builtins.int | None = ...,
        inter_op_thread_pool: builtins.int | None = ...,
        output_partition_graphs: builtins.bool | None = ...,
        debug_options: tensorflow.core.protobuf.debug_pb2.DebugOptions | None = ...,
        report_tensor_allocations_upon_oom: builtins.bool | None = ...,
        experimental: global___RunOptions.Experimental | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["debug_options", b"debug_options", "experimental", b"experimental"]
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "debug_options",
            b"debug_options",
            "experimental",
            b"experimental",
            "inter_op_thread_pool",
            b"inter_op_thread_pool",
            "output_partition_graphs",
            b"output_partition_graphs",
            "report_tensor_allocations_upon_oom",
            b"report_tensor_allocations_upon_oom",
            "timeout_in_ms",
            b"timeout_in_ms",
            "trace_level",
            b"trace_level",
        ],
    ) -> None: ...

global___RunOptions = RunOptions

@typing.final
class RunMetadata(google.protobuf.message.Message):
    """Metadata output (i.e., non-Tensor) for a single Run() call."""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    @typing.final
    class FunctionGraphs(google.protobuf.message.Message):
        DESCRIPTOR: google.protobuf.descriptor.Descriptor

        PARTITION_GRAPHS_FIELD_NUMBER: builtins.int
        PRE_OPTIMIZATION_GRAPH_FIELD_NUMBER: builtins.int
        POST_OPTIMIZATION_GRAPH_FIELD_NUMBER: builtins.int
        @property
        def partition_graphs(
            self,
        ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[tensorflow.core.framework.graph_pb2.GraphDef]:
            """TODO(nareshmodi): Include some sort of function/cache-key identifier?"""

        @property
        def pre_optimization_graph(self) -> tensorflow.core.framework.graph_pb2.GraphDef: ...
        @property
        def post_optimization_graph(self) -> tensorflow.core.framework.graph_pb2.GraphDef: ...
        def __init__(
            self,
            *,
            partition_graphs: collections.abc.Iterable[tensorflow.core.framework.graph_pb2.GraphDef] | None = ...,
            pre_optimization_graph: tensorflow.core.framework.graph_pb2.GraphDef | None = ...,
            post_optimization_graph: tensorflow.core.framework.graph_pb2.GraphDef | None = ...,
        ) -> None: ...
        def HasField(
            self,
            field_name: typing.Literal[
                "post_optimization_graph", b"post_optimization_graph", "pre_optimization_graph", b"pre_optimization_graph"
            ],
        ) -> builtins.bool: ...
        def ClearField(
            self,
            field_name: typing.Literal[
                "partition_graphs",
                b"partition_graphs",
                "post_optimization_graph",
                b"post_optimization_graph",
                "pre_optimization_graph",
                b"pre_optimization_graph",
            ],
        ) -> None: ...

    STEP_STATS_FIELD_NUMBER: builtins.int
    COST_GRAPH_FIELD_NUMBER: builtins.int
    PARTITION_GRAPHS_FIELD_NUMBER: builtins.int
    FUNCTION_GRAPHS_FIELD_NUMBER: builtins.int
    SESSION_METADATA_FIELD_NUMBER: builtins.int
    @property
    def step_stats(self) -> tensorflow.core.framework.step_stats_pb2.StepStats:
        """Statistics traced for this step. Populated if tracing is turned on via the
        "RunOptions" proto.
        EXPERIMENTAL: The format and set of events may change in future versions.
        """

    @property
    def cost_graph(self) -> tensorflow.core.framework.cost_graph_pb2.CostGraphDef:
        """The cost graph for the computation defined by the run call."""

    @property
    def partition_graphs(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[tensorflow.core.framework.graph_pb2.GraphDef]:
        """Graphs of the partitions executed by executors."""

    @property
    def function_graphs(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___RunMetadata.FunctionGraphs]:
        """This is only populated for graphs that are run as functions in TensorFlow
        V2. There will be an entry below for each function that is traced.
        The main use cases of the post_optimization_graph and the partition_graphs
        is to give the caller insight into the graphs that were actually run by the
        runtime. Additional information (such as those in step_stats) will match
        these graphs.
        We also include the pre_optimization_graph since it is usually easier to
        read, and is helpful in situations where the caller wants to get a high
        level idea of what the built graph looks like (since the various graph
        optimization passes might change the structure of the graph significantly).
        """

    @property
    def session_metadata(self) -> global___SessionMetadata:
        """Metadata about the session."""

    def __init__(
        self,
        *,
        step_stats: tensorflow.core.framework.step_stats_pb2.StepStats | None = ...,
        cost_graph: tensorflow.core.framework.cost_graph_pb2.CostGraphDef | None = ...,
        partition_graphs: collections.abc.Iterable[tensorflow.core.framework.graph_pb2.GraphDef] | None = ...,
        function_graphs: collections.abc.Iterable[global___RunMetadata.FunctionGraphs] | None = ...,
        session_metadata: global___SessionMetadata | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing.Literal[
            "cost_graph", b"cost_graph", "session_metadata", b"session_metadata", "step_stats", b"step_stats"
        ],
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "cost_graph",
            b"cost_graph",
            "function_graphs",
            b"function_graphs",
            "partition_graphs",
            b"partition_graphs",
            "session_metadata",
            b"session_metadata",
            "step_stats",
            b"step_stats",
        ],
    ) -> None: ...

global___RunMetadata = RunMetadata

@typing.final
class TensorConnection(google.protobuf.message.Message):
    """Defines a connection between two tensors in a `GraphDef`."""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    FROM_TENSOR_FIELD_NUMBER: builtins.int
    TO_TENSOR_FIELD_NUMBER: builtins.int
    from_tensor: builtins.str
    """A tensor name. The value of this tensor will be substituted for
    the tensor named in `to_tensor`.
    """
    to_tensor: builtins.str
    """A tensor name. The value of this tensor will be bound to the
    value of the tensor named in `from_tensor`.
    """
    def __init__(self, *, from_tensor: builtins.str | None = ..., to_tensor: builtins.str | None = ...) -> None: ...
    def ClearField(self, field_name: typing.Literal["from_tensor", b"from_tensor", "to_tensor", b"to_tensor"]) -> None: ...

global___TensorConnection = TensorConnection

@typing.final
class CallableOptions(google.protobuf.message.Message):
    """Defines a subgraph in another `GraphDef` as a set of feed points and nodes
    to be fetched or executed.

    Compare with the arguments to `Session::Run()`.
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    @typing.final
    class FeedDevicesEntry(google.protobuf.message.Message):
        DESCRIPTOR: google.protobuf.descriptor.Descriptor

        KEY_FIELD_NUMBER: builtins.int
        VALUE_FIELD_NUMBER: builtins.int
        key: builtins.str
        value: builtins.str
        def __init__(self, *, key: builtins.str | None = ..., value: builtins.str | None = ...) -> None: ...
        def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ...

    @typing.final
    class FetchDevicesEntry(google.protobuf.message.Message):
        DESCRIPTOR: google.protobuf.descriptor.Descriptor

        KEY_FIELD_NUMBER: builtins.int
        VALUE_FIELD_NUMBER: builtins.int
        key: builtins.str
        value: builtins.str
        def __init__(self, *, key: builtins.str | None = ..., value: builtins.str | None = ...) -> None: ...
        def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ...

    FEED_FIELD_NUMBER: builtins.int
    FETCH_FIELD_NUMBER: builtins.int
    TARGET_FIELD_NUMBER: builtins.int
    RUN_OPTIONS_FIELD_NUMBER: builtins.int
    TENSOR_CONNECTION_FIELD_NUMBER: builtins.int
    FEED_DEVICES_FIELD_NUMBER: builtins.int
    FETCH_DEVICES_FIELD_NUMBER: builtins.int
    FETCH_SKIP_SYNC_FIELD_NUMBER: builtins.int
    fetch_skip_sync: builtins.bool
    """By default, RunCallable() will synchronize the GPU stream before returning
    fetched tensors on a GPU device, to ensure that the values in those tensors
    have been produced. This simplifies interacting with the tensors, but
    potentially incurs a performance hit.

    If this options is set to true, the caller is responsible for ensuring
    that the values in the fetched tensors have been produced before they are
    used. The caller can do this by invoking `Device::Sync()` on the underlying
    device(s), or by feeding the tensors back to the same Session using
    `feed_devices` with the same corresponding device name.
    """
    @property
    def feed(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
        """Tensors to be fed in the callable. Each feed is the name of a tensor."""

    @property
    def fetch(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
        """Fetches. A list of tensor names. The caller of the callable expects a
        tensor to be returned for each fetch[i] (see RunStepResponse.tensor). The
        order of specified fetches does not change the execution order.
        """

    @property
    def target(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
        """Target Nodes. A list of node names. The named nodes will be run by the
        callable but their outputs will not be returned.
        """

    @property
    def run_options(self) -> global___RunOptions:
        """Options that will be applied to each run."""

    @property
    def tensor_connection(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___TensorConnection]:
        """Tensors to be connected in the callable. Each TensorConnection denotes
        a pair of tensors in the graph, between which an edge will be created
        in the callable.
        """

    @property
    def feed_devices(self) -> google.protobuf.internal.containers.ScalarMap[builtins.str, builtins.str]:
        """The Tensor objects fed in the callable and fetched from the callable
        are expected to be backed by host (CPU) memory by default.

        The options below allow changing that - feeding tensors backed by
        device memory, or returning tensors that are backed by device memory.

        The maps below map the name of a feed/fetch tensor (which appears in
        'feed' or 'fetch' fields above), to the fully qualified name of the device
        owning the memory backing the contents of the tensor.

        For example, creating a callable with the following options:

        CallableOptions {
          feed: "a:0"
          feed: "b:0"

          fetch: "x:0"
          fetch: "y:0"

          feed_devices: {
            "a:0": "/job:localhost/replica:0/task:0/device:GPU:0"
          }

          fetch_devices: {
            "y:0": "/job:localhost/replica:0/task:0/device:GPU:0"
         }
        }

        means that the Callable expects:
        - The first argument ("a:0") is a Tensor backed by GPU memory.
        - The second argument ("b:0") is a Tensor backed by host memory.
        and of its return values:
        - The first output ("x:0") will be backed by host memory.
        - The second output ("y:0") will be backed by GPU memory.

        FEEDS:
        It is the responsibility of the caller to ensure that the memory of the fed
        tensors will be correctly initialized and synchronized before it is
        accessed by operations executed during the call to Session::RunCallable().

        This is typically ensured by using the TensorFlow memory allocators
        (Device::GetAllocator()) to create the Tensor to be fed.

        Alternatively, for CUDA-enabled GPU devices, this typically means that the
        operation that produced the contents of the tensor has completed, i.e., the
        CUDA stream has been synchronized (e.g., via cuCtxSynchronize() or
        cuStreamSynchronize()).
        """

    @property
    def fetch_devices(self) -> google.protobuf.internal.containers.ScalarMap[builtins.str, builtins.str]: ...
    def __init__(
        self,
        *,
        feed: collections.abc.Iterable[builtins.str] | None = ...,
        fetch: collections.abc.Iterable[builtins.str] | None = ...,
        target: collections.abc.Iterable[builtins.str] | None = ...,
        run_options: global___RunOptions | None = ...,
        tensor_connection: collections.abc.Iterable[global___TensorConnection] | None = ...,
        feed_devices: collections.abc.Mapping[builtins.str, builtins.str] | None = ...,
        fetch_devices: collections.abc.Mapping[builtins.str, builtins.str] | None = ...,
        fetch_skip_sync: builtins.bool | None = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["run_options", b"run_options"]) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "feed",
            b"feed",
            "feed_devices",
            b"feed_devices",
            "fetch",
            b"fetch",
            "fetch_devices",
            b"fetch_devices",
            "fetch_skip_sync",
            b"fetch_skip_sync",
            "run_options",
            b"run_options",
            "target",
            b"target",
            "tensor_connection",
            b"tensor_connection",
        ],
    ) -> None: ...

global___CallableOptions = CallableOptions
