basedpyright 1.36.2 → 1.37.0-961d59bacff1958014fe4e9ed2ef3116fe2266e2

package/dist/typeshed-fallback/stubs/tensorflow/tensorflow/core/framework/model_pb2.pyi

@@ -0,0 +1,368 @@
+"""
+@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
+
+if sys.version_info >= (3, 10):
+    import typing as typing_extensions
+else:
+    import typing_extensions
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+class _NodeClass:
+    ValueType = typing.NewType("ValueType", builtins.int)
+    V: typing_extensions.TypeAlias = ValueType
+
+class _NodeClassEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_NodeClass.ValueType], builtins.type):
+    DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+    UNKNOWN: _NodeClass.ValueType  # 0
+    INTERLEAVE_MANY: _NodeClass.ValueType  # 1
+    ASYNC_INTERLEAVE_MANY: _NodeClass.ValueType  # 2
+    KNOWN_RATIO: _NodeClass.ValueType  # 3
+    ASYNC_KNOWN_RATIO: _NodeClass.ValueType  # 4
+    UNKNOWN_RATIO: _NodeClass.ValueType  # 5
+    ASYNC_UNKNOWN_RATIO: _NodeClass.ValueType  # 6
+
+class NodeClass(_NodeClass, metaclass=_NodeClassEnumTypeWrapper):
+    """Class of a node in the performance model."""
+
+UNKNOWN: NodeClass.ValueType  # 0
+INTERLEAVE_MANY: NodeClass.ValueType  # 1
+ASYNC_INTERLEAVE_MANY: NodeClass.ValueType  # 2
+KNOWN_RATIO: NodeClass.ValueType  # 3
+ASYNC_KNOWN_RATIO: NodeClass.ValueType  # 4
+UNKNOWN_RATIO: NodeClass.ValueType  # 5
+ASYNC_UNKNOWN_RATIO: NodeClass.ValueType  # 6
+global___NodeClass = NodeClass
+
+class _AutotuneAlgorithm:
+    ValueType = typing.NewType("ValueType", builtins.int)
+    V: typing_extensions.TypeAlias = ValueType
+
+class _AutotuneAlgorithmEnumTypeWrapper(
+    google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_AutotuneAlgorithm.ValueType], builtins.type
+):
+    DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+    DEFAULT: _AutotuneAlgorithm.ValueType  # 0
+    HILL_CLIMB: _AutotuneAlgorithm.ValueType  # 1
+    GRADIENT_DESCENT: _AutotuneAlgorithm.ValueType  # 2
+    MAX_PARALLELISM: _AutotuneAlgorithm.ValueType  # 3
+    STAGE_BASED: _AutotuneAlgorithm.ValueType  # 4
+
+class AutotuneAlgorithm(_AutotuneAlgorithm, metaclass=_AutotuneAlgorithmEnumTypeWrapper):
+    """Algorithm used for model autotuning optimization."""
+
+DEFAULT: AutotuneAlgorithm.ValueType  # 0
+HILL_CLIMB: AutotuneAlgorithm.ValueType  # 1
+GRADIENT_DESCENT: AutotuneAlgorithm.ValueType  # 2
+MAX_PARALLELISM: AutotuneAlgorithm.ValueType  # 3
+STAGE_BASED: AutotuneAlgorithm.ValueType  # 4
+global___AutotuneAlgorithm = AutotuneAlgorithm
+
+@typing.final
+class ModelProto(google.protobuf.message.Message):
+    """Protocol buffer representing the data used by the autotuning modeling
+    framework.
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    @typing.final
+    class Node(google.protobuf.message.Message):
+        """General representation of a node in the model."""
+
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        @typing.final
+        class Parameter(google.protobuf.message.Message):
+            """Represents a node parameter."""
+
+            DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+            NAME_FIELD_NUMBER: builtins.int
+            VALUE_FIELD_NUMBER: builtins.int
+            STATE_VALUE_FIELD_NUMBER: builtins.int
+            MIN_FIELD_NUMBER: builtins.int
+            MAX_FIELD_NUMBER: builtins.int
+            TUNABLE_FIELD_NUMBER: builtins.int
+            name: builtins.str
+            """Human-readable name of the parameter."""
+            value: builtins.float
+            """Identifies the model value of the parameter. This can be different from
+            the actual value (e.g. during optimization search).
+            """
+            state_value: builtins.float
+            """The actual value of the parameter."""
+            min: builtins.float
+            """Minimum value of the parameter."""
+            max: builtins.float
+            """Maximum value of the parameter."""
+            tunable: builtins.bool
+            """Identifies whether the parameter should participate in autotuning."""
+            def __init__(
+                self,
+                *,
+                name: builtins.str | None = ...,
+                value: builtins.float | None = ...,
+                state_value: builtins.float | None = ...,
+                min: builtins.float | None = ...,
+                max: builtins.float | None = ...,
+                tunable: builtins.bool | None = ...,
+            ) -> None: ...
+            def ClearField(
+                self,
+                field_name: typing.Literal[
+                    "max",
+                    b"max",
+                    "min",
+                    b"min",
+                    "name",
+                    b"name",
+                    "state_value",
+                    b"state_value",
+                    "tunable",
+                    b"tunable",
+                    "value",
+                    b"value",
+                ],
+            ) -> None: ...
+
+        ID_FIELD_NUMBER: builtins.int
+        NAME_FIELD_NUMBER: builtins.int
+        AUTOTUNE_FIELD_NUMBER: builtins.int
+        BUFFERED_BYTES_FIELD_NUMBER: builtins.int
+        BUFFERED_ELEMENTS_FIELD_NUMBER: builtins.int
+        BYTES_CONSUMED_FIELD_NUMBER: builtins.int
+        BYTES_PRODUCED_FIELD_NUMBER: builtins.int
+        NUM_ELEMENTS_FIELD_NUMBER: builtins.int
+        PROCESSING_TIME_FIELD_NUMBER: builtins.int
+        RECORD_METRICS_FIELD_NUMBER: builtins.int
+        PARAMETERS_FIELD_NUMBER: builtins.int
+        INPUT_PROCESSING_TIME_SUM_FIELD_NUMBER: builtins.int
+        INPUT_PROCESSING_TIME_COUNT_FIELD_NUMBER: builtins.int
+        INPUTS_FIELD_NUMBER: builtins.int
+        NODE_CLASS_FIELD_NUMBER: builtins.int
+        RATIO_FIELD_NUMBER: builtins.int
+        MEMORY_RATIO_FIELD_NUMBER: builtins.int
+        id: builtins.int
+        """Unique node ID."""
+        name: builtins.str
+        """Human-readable name of the node."""
+        autotune: builtins.bool
+        """An indication whether autotuning is enabled for this node."""
+        buffered_bytes: builtins.int
+        """The number of bytes stored in this node's buffer."""
+        buffered_elements: builtins.int
+        """The number of elements stored in this node's buffer."""
+        bytes_consumed: builtins.int
+        """The number of bytes consumed by the node."""
+        bytes_produced: builtins.int
+        """The number of bytes produced by the node."""
+        num_elements: builtins.int
+        """The number of elements produced by the node."""
+        processing_time: builtins.int
+        """The aggregate processing time spent in this node in nanoseconds."""
+        record_metrics: builtins.bool
+        """An indication whether this node records metrics about produced and
+        consumed elements.
+        """
+        input_processing_time_sum: builtins.float
+        """Statistic of inputs processing time history."""
+        input_processing_time_count: builtins.int
+        node_class: global___NodeClass.ValueType
+        """Class of this node."""
+        ratio: builtins.float
+        """Ratio of input to output elements. This is only used by KNOWN_RATIO and
+        ASYNC_KNOWN_RATIO nodes.
+        """
+        memory_ratio: builtins.float
+        """Ratio identifies how many parallelism calls are introduced by one
+        buffered element. This is only used by ASYNC_KNOWN_RATIO nodes.
+        """
+        @property
+        def parameters(
+            self,
+        ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ModelProto.Node.Parameter]:
+            """Parameters of this node."""
+
+        @property
+        def inputs(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
+            """IDs of inputs of this node."""
+
+        def __init__(
+            self,
+            *,
+            id: builtins.int | None = ...,
+            name: builtins.str | None = ...,
+            autotune: builtins.bool | None = ...,
+            buffered_bytes: builtins.int | None = ...,
+            buffered_elements: builtins.int | None = ...,
+            bytes_consumed: builtins.int | None = ...,
+            bytes_produced: builtins.int | None = ...,
+            num_elements: builtins.int | None = ...,
+            processing_time: builtins.int | None = ...,
+            record_metrics: builtins.bool | None = ...,
+            parameters: collections.abc.Iterable[global___ModelProto.Node.Parameter] | None = ...,
+            input_processing_time_sum: builtins.float | None = ...,
+            input_processing_time_count: builtins.int | None = ...,
+            inputs: collections.abc.Iterable[builtins.int] | None = ...,
+            node_class: global___NodeClass.ValueType | None = ...,
+            ratio: builtins.float | None = ...,
+            memory_ratio: builtins.float | None = ...,
+        ) -> None: ...
+        def ClearField(
+            self,
+            field_name: typing.Literal[
+                "autotune",
+                b"autotune",
+                "buffered_bytes",
+                b"buffered_bytes",
+                "buffered_elements",
+                b"buffered_elements",
+                "bytes_consumed",
+                b"bytes_consumed",
+                "bytes_produced",
+                b"bytes_produced",
+                "id",
+                b"id",
+                "input_processing_time_count",
+                b"input_processing_time_count",
+                "input_processing_time_sum",
+                b"input_processing_time_sum",
+                "inputs",
+                b"inputs",
+                "memory_ratio",
+                b"memory_ratio",
+                "name",
+                b"name",
+                "node_class",
+                b"node_class",
+                "num_elements",
+                b"num_elements",
+                "parameters",
+                b"parameters",
+                "processing_time",
+                b"processing_time",
+                "ratio",
+                b"ratio",
+                "record_metrics",
+                b"record_metrics",
+            ],
+        ) -> None: ...
+
+    @typing.final
+    class NodesEntry(google.protobuf.message.Message):
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        KEY_FIELD_NUMBER: builtins.int
+        VALUE_FIELD_NUMBER: builtins.int
+        key: builtins.int
+        @property
+        def value(self) -> global___ModelProto.Node: ...
+        def __init__(self, *, key: builtins.int | None = ..., value: global___ModelProto.Node | None = ...) -> None: ...
+        def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ...
+
+    @typing.final
+    class OptimizationParams(google.protobuf.message.Message):
+        """Contains parameters of the model autotuning optimization."""
+
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        ALGORITHM_FIELD_NUMBER: builtins.int
+        CPU_BUDGET_FIELD_NUMBER: builtins.int
+        RAM_BUDGET_FIELD_NUMBER: builtins.int
+        MODEL_INPUT_TIME_FIELD_NUMBER: builtins.int
+        algorithm: global___AutotuneAlgorithm.ValueType
+        """Algorithm used for autotuning optimization."""
+        cpu_budget: builtins.int
+        """Number of available logical threads."""
+        ram_budget: builtins.int
+        """Amount of available memory in bytes."""
+        model_input_time: builtins.float
+        """Time between two consecutive `GetNext` calls to the iterator represented
+        by the output node.
+        """
+        def __init__(
+            self,
+            *,
+            algorithm: global___AutotuneAlgorithm.ValueType | None = ...,
+            cpu_budget: builtins.int | None = ...,
+            ram_budget: builtins.int | None = ...,
+            model_input_time: builtins.float | None = ...,
+        ) -> None: ...
+        def ClearField(
+            self,
+            field_name: typing.Literal[
+                "algorithm",
+                b"algorithm",
+                "cpu_budget",
+                b"cpu_budget",
+                "model_input_time",
+                b"model_input_time",
+                "ram_budget",
+                b"ram_budget",
+            ],
+        ) -> None: ...
+
+    DATASET_NAME_FIELD_NUMBER: builtins.int
+    NODES_FIELD_NUMBER: builtins.int
+    OUTPUT_FIELD_NUMBER: builtins.int
+    ID_COUNTER_FIELD_NUMBER: builtins.int
+    OPTIMIZATION_PARAMS_FIELD_NUMBER: builtins.int
+    GAP_TIMES_FIELD_NUMBER: builtins.int
+    dataset_name: builtins.str
+    """User-defined name for the dataset. Empty if no name was set."""
+    output: builtins.int
+    """ID of the output node of this model."""
+    id_counter: builtins.int
+    """Counter for node IDs of this model."""
+    @property
+    def nodes(self) -> google.protobuf.internal.containers.MessageMap[builtins.int, global___ModelProto.Node]:
+        """Map of node IDs to nodes of this model."""
+
+    @property
+    def optimization_params(self) -> global___ModelProto.OptimizationParams: ...
+    @property
+    def gap_times(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: ...
+    def __init__(
+        self,
+        *,
+        dataset_name: builtins.str | None = ...,
+        nodes: collections.abc.Mapping[builtins.int, global___ModelProto.Node] | None = ...,
+        output: builtins.int | None = ...,
+        id_counter: builtins.int | None = ...,
+        optimization_params: global___ModelProto.OptimizationParams | None = ...,
+        gap_times: collections.abc.Iterable[builtins.int] | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["optimization_params", b"optimization_params"]) -> builtins.bool: ...
+    def ClearField(
+        self,
+        field_name: typing.Literal[
+            "dataset_name",
+            b"dataset_name",
+            "gap_times",
+            b"gap_times",
+            "id_counter",
+            b"id_counter",
+            "nodes",
+            b"nodes",
+            "optimization_params",
+            b"optimization_params",
+            "output",
+            b"output",
+        ],
+    ) -> None: ...
+
+global___ModelProto = ModelProto

package/dist/typeshed-fallback/stubs/tensorflow/tensorflow/core/framework/node_def_pb2.pyi

@@ -0,0 +1,192 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+
+import builtins
+import collections.abc
+import typing
+
+import google.protobuf.descriptor
+import google.protobuf.internal.containers
+import google.protobuf.message
+import tensorflow.core.framework.attr_value_pb2
+import tensorflow.core.framework.full_type_pb2
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+@typing.final
+class NodeDef(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    @typing.final
+    class AttrEntry(google.protobuf.message.Message):
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        KEY_FIELD_NUMBER: builtins.int
+        VALUE_FIELD_NUMBER: builtins.int
+        key: builtins.str
+        @property
+        def value(self) -> tensorflow.core.framework.attr_value_pb2.AttrValue: ...
+        def __init__(
+            self, *, key: builtins.str | None = ..., value: tensorflow.core.framework.attr_value_pb2.AttrValue | None = ...
+        ) -> None: ...
+        def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ...
+
+    @typing.final
+    class ExperimentalDebugInfo(google.protobuf.message.Message):
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        ORIGINAL_NODE_NAMES_FIELD_NUMBER: builtins.int
+        ORIGINAL_FUNC_NAMES_FIELD_NUMBER: builtins.int
+        @property
+        def original_node_names(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
+            """Opaque string inserted into error messages created by the runtime.
+
+            This is intended to store the list of names of the nodes from the
+            original graph that this node was derived. For example if this node, say
+            C, was result of a fusion of 2 nodes A and B, then 'original_node' would
+            be {A, B}. This information can be used to map errors originating at the
+            current node to some top level source code.
+            """
+
+        @property
+        def original_func_names(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
+            """This is intended to store the list of names of the functions from the
+            original graph that this node was derived. For example if this node, say
+            C, was result of a fusion of node A in function FA and node B in function
+            FB, then `original_funcs` would be {FA, FB}. If the node is in the top
+            level graph, the `original_func` is empty. This information, with the
+            `original_node_names` can be used to map errors originating at the
+            current ndoe to some top level source code.
+            """
+
+        def __init__(
+            self,
+            *,
+            original_node_names: collections.abc.Iterable[builtins.str] | None = ...,
+            original_func_names: collections.abc.Iterable[builtins.str] | None = ...,
+        ) -> None: ...
+        def ClearField(
+            self,
+            field_name: typing.Literal[
+                "original_func_names", b"original_func_names", "original_node_names", b"original_node_names"
+            ],
+        ) -> None: ...
+
+    NAME_FIELD_NUMBER: builtins.int
+    OP_FIELD_NUMBER: builtins.int
+    INPUT_FIELD_NUMBER: builtins.int
+    DEVICE_FIELD_NUMBER: builtins.int
+    ATTR_FIELD_NUMBER: builtins.int
+    EXPERIMENTAL_DEBUG_INFO_FIELD_NUMBER: builtins.int
+    EXPERIMENTAL_TYPE_FIELD_NUMBER: builtins.int
+    name: builtins.str
+    """The name given to this operator. Used for naming inputs,
+    logging, visualization, etc.  Unique within a single GraphDef.
+    Must match the regexp "[A-Za-z0-9.][A-Za-z0-9_>./]*".
+    """
+    op: builtins.str
+    """The operation name.  There may be custom parameters in attrs.
+    Op names starting with an underscore are reserved for internal use.
+    """
+    device: builtins.str
+    """A (possibly partial) specification for the device on which this
+    node should be placed.
+    The expected syntax for this string is as follows:
+
+    DEVICE_SPEC ::= PARTIAL_SPEC
+
+    PARTIAL_SPEC ::= ("/" CONSTRAINT) *
+    CONSTRAINT ::= ("job:" JOB_NAME)
+                 | ("replica:" [1-9][0-9]*)
+                 | ("task:" [1-9][0-9]*)
+                 | ("device:" [A-Za-z]* ":" ([1-9][0-9]* | "*") )
+
+    Valid values for this string include:
+    * "/job:worker/replica:0/task:1/device:GPU:3"  (full specification)
+    * "/job:worker/device:GPU:3"                   (partial specification)
+    * ""                                    (no specification)
+
+    If the constraints do not resolve to a single device (or if this
+    field is empty or not present), the runtime will attempt to
+    choose a device automatically.
+    """
+    @property
+    def input(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
+        """Each input is "node:src_output" with "node" being a string name and
+        "src_output" indicating which output tensor to use from "node". If
+        "src_output" is 0 the ":0" suffix can be omitted.  Regular inputs
+        may optionally be followed by control inputs that have the format
+        "^node".
+        """
+
+    @property
+    def attr(
+        self,
+    ) -> google.protobuf.internal.containers.MessageMap[builtins.str, tensorflow.core.framework.attr_value_pb2.AttrValue]:
+        """Operation-specific graph-construction-time configuration.
+        Note that this should include all attrs defined in the
+        corresponding OpDef, including those with a value matching
+        the default -- this allows the default to change and makes
+        NodeDefs easier to interpret on their own.  However, if
+        an attr with a default is not specified in this list, the
+        default will be used.
+        The "names" (keys) must match the regexp "[a-z][a-z0-9_]+" (and
+        one of the names from the corresponding OpDef's attr field).
+        The values must have a type matching the corresponding OpDef
+        attr's type field.
+        TODO(josh11b): Add some examples here showing best practices.
+        """
+
+    @property
+    def experimental_debug_info(self) -> global___NodeDef.ExperimentalDebugInfo:
+        """This stores debug information associated with the node."""
+
+    @property
+    def experimental_type(self) -> tensorflow.core.framework.full_type_pb2.FullTypeDef:
+        """The complete type of this node. Experimental and subject to change.
+        Currently, the field only contains the return types of the node. That will
+        extend in the future to contain the entire signature of the node, as a
+        function type.
+        """
+
+    def __init__(
+        self,
+        *,
+        name: builtins.str | None = ...,
+        op: builtins.str | None = ...,
+        input: collections.abc.Iterable[builtins.str] | None = ...,
+        device: builtins.str | None = ...,
+        attr: collections.abc.Mapping[builtins.str, tensorflow.core.framework.attr_value_pb2.AttrValue] | None = ...,
+        experimental_debug_info: global___NodeDef.ExperimentalDebugInfo | None = ...,
+        experimental_type: tensorflow.core.framework.full_type_pb2.FullTypeDef | None = ...,
+    ) -> None: ...
+    def HasField(
+        self,
+        field_name: typing.Literal[
+            "experimental_debug_info", b"experimental_debug_info", "experimental_type", b"experimental_type"
+        ],
+    ) -> builtins.bool: ...
+    def ClearField(
+        self,
+        field_name: typing.Literal[
+            "attr",
+            b"attr",
+            "device",
+            b"device",
+            "experimental_debug_info",
+            b"experimental_debug_info",
+            "experimental_type",
+            b"experimental_type",
+            "input",
+            b"input",
+            "name",
+            b"name",
+            "op",
+            b"op",
+        ],
+    ) -> None: ...
+
+global___NodeDef = NodeDef