basedpyright 1.36.2 → 1.37.0-961d59bacff1958014fe4e9ed2ef3116fe2266e2

package/dist/typeshed-fallback/stubs/tensorflow/tensorflow/feature_column/__init__.pyi

@@ -0,0 +1,95 @@
+from collections.abc import Callable, Iterable, Sequence
+
+import tensorflow as tf
+from tensorflow._aliases import ShapeLike
+from tensorflow.python.feature_column import feature_column_v2 as fc, sequence_feature_column as seq_fc
+
+def numeric_column(
+    key: str,
+    shape: ShapeLike = (1,),
+    default_value: float | None = None,
+    dtype: tf.DType = ...,
+    normalizer_fn: Callable[[tf.Tensor], tf.Tensor] | None = None,
+) -> fc.NumericColumn: ...
+def bucketized_column(source_column: fc.NumericColumn, boundaries: list[float] | tuple[float, ...]) -> fc.BucketizedColumn: ...
+def embedding_column(
+    categorical_column: fc.CategoricalColumn,
+    dimension: int,
+    combiner: fc._Combiners = "mean",
+    initializer: Callable[[ShapeLike], tf.Tensor] | None = None,
+    ckpt_to_load_from: str | None = None,
+    tensor_name_in_ckpt: str | None = None,
+    max_norm: float | None = None,
+    trainable: bool = True,
+    use_safe_embedding_lookup: bool = True,
+) -> fc.EmbeddingColumn: ...
+def shared_embeddings(
+    categorical_columns: Iterable[fc.CategoricalColumn],
+    dimension: int,
+    combiner: fc._Combiners = "mean",
+    initializer: Callable[[ShapeLike], tf.Tensor] | None = None,
+    shared_embedding_collection_name: str | None = None,
+    ckpt_to_load_from: str | None = None,
+    tensor_name_in_ckpt: str | None = None,
+    max_norm: float | None = None,
+    trainable: bool = True,
+    use_safe_embedding_lookup: bool = True,
+) -> list[fc.SharedEmbeddingColumn]: ...
+def categorical_column_with_identity(
+    key: str, num_buckets: int, default_value: int | None = None
+) -> fc.IdentityCategoricalColumn: ...
+def categorical_column_with_hash_bucket(key: str, hash_bucket_size: int, dtype: tf.DType = ...) -> fc.HashedCategoricalColumn: ...
+def categorical_column_with_vocabulary_file(
+    key: str,
+    vocabulary_file: str,
+    vocabulary_size: int | None = None,
+    dtype: tf.DType = ...,
+    default_value: str | int | None = None,
+    num_oov_buckets: int = 0,
+    file_format: str | None = None,
+) -> fc.VocabularyFileCategoricalColumn: ...
+def categorical_column_with_vocabulary_list(
+    key: str,
+    vocabulary_list: Sequence[str] | Sequence[int],
+    dtype: tf.DType | None = None,
+    default_value: str | int | None = -1,
+    num_oov_buckets: int = 0,
+) -> fc.VocabularyListCategoricalColumn: ...
+def indicator_column(categorical_column: fc.CategoricalColumn) -> fc.IndicatorColumn: ...
+def weighted_categorical_column(
+    categorical_column: fc.CategoricalColumn, weight_feature_key: str, dtype: tf.DType = ...
+) -> fc.WeightedCategoricalColumn: ...
+def crossed_column(
+    keys: Iterable[str | fc.CategoricalColumn], hash_bucket_size: int, hash_key: int | None = None
+) -> fc.CrossedColumn: ...
+def sequence_numeric_column(
+    key: str,
+    shape: ShapeLike = (1,),
+    default_value: float = 0.0,
+    dtype: tf.DType = ...,
+    normalizer_fn: Callable[[tf.Tensor], tf.Tensor] | None = None,
+) -> seq_fc.SequenceNumericColumn: ...
+def sequence_categorical_column_with_identity(
+    key: str, num_buckets: int, default_value: int | None = None
+) -> fc.SequenceCategoricalColumn: ...
+def sequence_categorical_column_with_hash_bucket(
+    key: str, hash_bucket_size: int, dtype: tf.DType = ...
+) -> fc.SequenceCategoricalColumn: ...
+def sequence_categorical_column_with_vocabulary_file(
+    key: str,
+    vocabulary_file: str,
+    vocabulary_size: int | None = None,
+    num_oov_buckets: int = 0,
+    default_value: str | int | None = None,
+    dtype: tf.DType = ...,
+) -> fc.SequenceCategoricalColumn: ...
+def sequence_categorical_column_with_vocabulary_list(
+    key: str,
+    vocabulary_list: Sequence[str] | Sequence[int],
+    dtype: tf.DType | None = None,
+    default_value: str | int | None = -1,
+    num_oov_buckets: int = 0,
+) -> fc.SequenceCategoricalColumn: ...
+def make_parse_example_spec(
+    feature_columns: Iterable[fc._FeatureColumn],
+) -> dict[str, tf.io.FixedLenFeature | tf.io.VarLenFeature]: ...

package/dist/typeshed-fallback/stubs/tensorflow/tensorflow/initializers.pyi

@@ -0,0 +1 @@
+from tensorflow.keras.initializers import *

package/dist/typeshed-fallback/stubs/tensorflow/tensorflow/io/__init__.pyi

@@ -0,0 +1,104 @@
+from collections.abc import Iterable, Mapping
+from types import TracebackType
+from typing import Literal, NamedTuple
+from typing_extensions import Self, TypeAlias
+
+from tensorflow._aliases import DTypeLike, ShapeLike, TensorCompatible, TensorLike
+from tensorflow.io import gfile as gfile
+
+_FeatureSpecs: TypeAlias = Mapping[str, FixedLenFeature | FixedLenSequenceFeature | VarLenFeature | RaggedFeature | SparseFeature]
+
+_CompressionTypes: TypeAlias = Literal["ZLIB", "GZIP", "AUTO", "", 0, 1, 2] | None
+_CompressionLevels: TypeAlias = Literal[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] | None
+_MemoryLevels: TypeAlias = Literal[1, 2, 3, 4, 5, 6, 7, 8, 9] | None
+
+class TFRecordOptions:
+    compression_type: _CompressionTypes | TFRecordOptions
+    flush_mode: int | None  # The exact values allowed comes from zlib
+    input_buffer_size: int | None
+    output_buffer_size: int | None
+    window_bits: int | None
+    compression_level: _CompressionLevels
+    compression_method: str | None
+    mem_level: _MemoryLevels
+    compression_strategy: int | None  # The exact values allowed comes from zlib
+
+    def __init__(
+        self,
+        compression_type: _CompressionTypes | TFRecordOptions = None,
+        flush_mode: int | None = None,
+        input_buffer_size: int | None = None,
+        output_buffer_size: int | None = None,
+        window_bits: int | None = None,
+        compression_level: _CompressionLevels = None,
+        compression_method: str | None = None,
+        mem_level: _MemoryLevels = None,
+        compression_strategy: int | None = None,
+    ) -> None: ...
+    @classmethod
+    def get_compression_type_string(cls, options: _CompressionTypes | TFRecordOptions) -> str: ...
+
+class TFRecordWriter:
+    def __init__(self, path: str, options: _CompressionTypes | TFRecordOptions | None = None) -> None: ...
+    def write(self, record: bytes) -> None: ...
+    def flush(self) -> None: ...
+    def close(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+
+class FixedLenFeature(NamedTuple):
+    shape: ShapeLike
+    dtype: DTypeLike
+    default_value: TensorCompatible | None = None
+
+class FixedLenSequenceFeature(NamedTuple):
+    shape: ShapeLike
+    dtype: DTypeLike
+    allow_missing: bool = False
+    default_value: TensorCompatible | None = None
+
+class VarLenFeature(NamedTuple):
+    dtype: DTypeLike
+
+class SparseFeature(NamedTuple):
+    index_key: str | list[str]
+    value_key: str
+    dtype: DTypeLike
+    size: int | list[int]
+    already_sorted: bool = False
+
+class RaggedFeature(NamedTuple):
+    # Mypy doesn't support nested NamedTuples, but at runtime they actually do use
+    # nested collections.namedtuple.
+    class RowSplits(NamedTuple):  # type: ignore[misc]
+        key: str
+
+    class RowLengths(NamedTuple):  # type: ignore[misc]
+        key: str
+
+    class RowStarts(NamedTuple):  # type: ignore[misc]
+        key: str
+
+    class RowLimits(NamedTuple):  # type: ignore[misc]
+        key: str
+
+    class ValueRowIds(NamedTuple):  # type: ignore[misc]
+        key: str
+
+    class UniformRowLength(NamedTuple):  # type: ignore[misc]
+        length: int
+
+    dtype: DTypeLike
+    value_key: str | None = None
+    partitions: tuple[  # type: ignore[name-defined]
+        RowSplits | RowLengths | RowStarts | RowLimits | ValueRowIds | UniformRowLength, ...
+    ] = ()
+    row_splits_dtype: DTypeLike = ...
+    validate: bool = False
+
+def parse_example(
+    serialized: TensorCompatible, features: _FeatureSpecs, example_names: Iterable[str] | None = None, name: str | None = None
+) -> dict[str, TensorLike]: ...
+def __getattr__(name: str): ...  # incomplete module

package/dist/typeshed-fallback/stubs/tensorflow/tensorflow/io/gfile.pyi

@@ -0,0 +1,11 @@
+from _typeshed import StrOrBytesPath
+from collections.abc import Iterable
+
+def rmtree(path: StrOrBytesPath) -> None: ...
+def isdir(path: StrOrBytesPath) -> bool: ...
+def listdir(path: StrOrBytesPath) -> list[str]: ...
+def exists(path: StrOrBytesPath) -> bool: ...
+def copy(src: StrOrBytesPath, dst: StrOrBytesPath, overwrite: bool = False) -> None: ...
+def makedirs(path: StrOrBytesPath) -> None: ...
+def glob(pattern: str | bytes | Iterable[str | bytes]) -> list[str]: ...
+def __getattr__(name: str): ...  # incomplete module

package/dist/typeshed-fallback/stubs/tensorflow/tensorflow/keras/__init__.pyi

@@ -0,0 +1,15 @@
+from tensorflow.keras import (
+    activations as activations,
+    callbacks as callbacks,
+    constraints as constraints,
+    initializers as initializers,
+    layers as layers,
+    losses as losses,
+    metrics as metrics,
+    models as models,
+    optimizers as optimizers,
+    regularizers as regularizers,
+)
+from tensorflow.keras.models import Model as Model
+
+def __getattr__(name: str): ...  # incomplete module

package/dist/typeshed-fallback/stubs/tensorflow/tensorflow/keras/activations.pyi

@@ -0,0 +1,35 @@
+from collections.abc import Callable
+from typing import Any
+from typing_extensions import TypeAlias
+
+import numpy as np
+from tensorflow import Tensor
+from tensorflow._aliases import FloatArray, FloatDataSequence, FloatTensorCompatible, Integer
+
+# The implementation uses isinstance so it must be dict and not any Mapping.
+_Activation: TypeAlias = str | None | Callable[[Tensor], Tensor] | dict[str, Any]
+# Ints are not allowed.
+_ActivationInput: TypeAlias = Tensor | FloatDataSequence | FloatArray | np.number[Any] | float
+
+def deserialize(config: dict[str, Any], custom_objects: dict[str, Callable[..., Any]] | None = None) -> Callable[..., Any]: ...
+def elu(x: _ActivationInput, alpha: FloatTensorCompatible | FloatDataSequence = 1.0) -> Tensor: ...
+def exponential(x: _ActivationInput) -> Tensor: ...
+def gelu(x: _ActivationInput, approximate: bool = False) -> Tensor: ...
+def get(identifier: _Activation) -> Callable[[Tensor], Tensor]: ...
+def hard_sigmoid(x: _ActivationInput) -> Tensor: ...
+def linear(x: _ActivationInput) -> Tensor: ...
+def mish(x: _ActivationInput) -> Tensor: ...
+def relu(
+    x: _ActivationInput,
+    negative_slope: FloatTensorCompatible = 0.0,
+    max_value: FloatTensorCompatible | FloatDataSequence | None = None,
+    threshold: FloatTensorCompatible | FloatDataSequence = 0.0,
+) -> Tensor: ...
+def selu(x: _ActivationInput) -> Tensor: ...
+def serialize(activation: Callable[..., Any]) -> str | dict[str, Any]: ...
+def sigmoid(x: _ActivationInput) -> Tensor: ...
+def softmax(x: Tensor, axis: Integer = -1) -> Tensor: ...
+def softplus(x: _ActivationInput) -> Tensor: ...
+def softsign(x: _ActivationInput) -> Tensor: ...
+def swish(x: _ActivationInput) -> Tensor: ...
+def tanh(x: _ActivationInput) -> Tensor: ...

package/dist/typeshed-fallback/stubs/tensorflow/tensorflow/keras/callbacks.pyi

@@ -0,0 +1,170 @@
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any, Literal
+from typing_extensions import TypeAlias
+
+import tensorflow as tf
+from requests.api import _HeadersMapping
+from tensorflow.keras import Model
+from tensorflow.keras.optimizers.schedules import LearningRateSchedule
+
+_Logs: TypeAlias = Mapping[str, Any] | None | Any
+
+class Callback:
+    params: dict[str, Any]
+    def set_params(self, params: dict[str, Any]) -> None: ...
+    def set_model(self, model: Model[Any, Any]) -> None: ...
+    @property
+    def model(self) -> Model[Any, Any]: ...
+    def on_batch_begin(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_batch_end(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_epoch_begin(self, epoch: int, logs: _Logs = None) -> None: ...
+    def on_epoch_end(self, epoch: int, logs: _Logs = None) -> None: ...
+    def on_train_batch_begin(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_train_batch_end(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_test_batch_begin(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_test_batch_end(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_predict_batch_begin(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_predict_batch_end(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_train_begin(self, logs: _Logs = None) -> None: ...
+    def on_train_end(self, logs: _Logs = None) -> None: ...
+    def on_test_begin(self, logs: _Logs = None) -> None: ...
+    def on_test_end(self, logs: _Logs = None) -> None: ...
+    def on_predict_begin(self, logs: _Logs = None) -> None: ...
+    def on_predict_end(self, logs: _Logs = None) -> None: ...
+
+class CallbackList(Callback):
+    def __init__(
+        self,
+        callbacks: Sequence[Callback] | None = None,
+        add_history: bool = False,
+        add_progbar: bool = False,
+        # model: Model[Any, object] | None = None,
+        model: Model[Any, Any] | None = None,
+        **params: Any,
+    ) -> None: ...
+    def set_params(self, params: dict[str, Any]) -> None: ...
+    def set_model(self, model: Model[Any, Any]) -> None: ...
+    def on_batch_begin(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_batch_end(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_epoch_begin(self, epoch: int, logs: _Logs = None) -> None: ...
+    def on_epoch_end(self, epoch: int, logs: _Logs = None) -> None: ...
+    def on_train_batch_begin(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_train_batch_end(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_test_batch_begin(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_test_batch_end(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_predict_batch_begin(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_predict_batch_end(self, batch: int, logs: _Logs = None) -> None: ...
+    def on_train_begin(self, logs: _Logs = None) -> None: ...
+    def on_train_end(self, logs: _Logs = None) -> None: ...
+    def on_test_begin(self, logs: _Logs = None) -> None: ...
+    def on_test_end(self, logs: _Logs = None) -> None: ...
+    def on_predict_begin(self, logs: _Logs = None) -> None: ...
+    def on_predict_end(self, logs: _Logs = None) -> None: ...
+
+class BackupAndRestore(Callback):
+    def __init__(self, backup_dir: str, save_freq: str = "epoch", delete_checkpoint: bool = True) -> None: ...
+
+class CSVLogger(Callback):
+    def __init__(self, filename: str, separator: str = ",", append: bool = False) -> None: ...
+
+class EarlyStopping(Callback):
+    monitor_op: Any
+    def __init__(
+        self,
+        monitor: str = "val_loss",
+        min_delta: float = 0,
+        patience: int = 0,
+        verbose: Literal[0, 1] = 0,
+        mode: Literal["auto", "min", "max"] = "auto",
+        baseline: float | None = None,
+        restore_best_weights: bool = False,
+        start_from_epoch: int = 0,
+    ) -> None: ...
+
+class History(Callback):
+    history: dict[str, list[Any]]
+
+class LambdaCallback(Callback):
+    def __init__(
+        self,
+        on_epoch_begin: Callable[[int, _Logs], object] | None = None,
+        on_epoch_end: Callable[[int, _Logs], object] | None = None,
+        on_train_begin: Callable[[_Logs], object] | None = None,
+        on_train_end: Callable[[_Logs], object] | None = None,
+        on_train_batch_begin: Callable[[int, _Logs], object] | None = None,
+        on_train_batch_end: Callable[[int, _Logs], object] | None = None,
+        **kwargs: Any,
+    ) -> None: ...
+
+class LearningRateScheduler(Callback):
+    def __init__(
+        self,
+        schedule: LearningRateSchedule | Callable[[int], float | tf.Tensor] | Callable[[int, float], float | tf.Tensor],
+        verbose: Literal[0, 1] = 0,
+    ) -> None: ...
+
+class ModelCheckpoint(Callback):
+    monitor_op: Any
+    filepath: str
+    def __init__(
+        self,
+        filepath: str,
+        monitor: str = "val_loss",
+        verbose: Literal[0, 1] = 0,
+        save_best_only: bool = False,
+        save_weights_only: bool = False,
+        mode: Literal["auto", "min", "max"] = "auto",
+        save_freq: str | int = "epoch",
+        initial_value_threshold: float | None = None,
+    ) -> None: ...
+    def _save_model(self, epoch: int, batch: int | None, logs: _Logs) -> None: ...
+
+class ProgbarLogger(Callback):
+    use_steps: bool
+    def __init__(self) -> None: ...
+
+class ReduceLROnPlateau(Callback):
+    def __init__(
+        self,
+        monitor: str = "val_loss",
+        factor: float = 0.1,
+        patience: int = 10,
+        verbose: Literal[0, 1] = 0,
+        mode: Literal["auto", "min", "max"] = "auto",
+        min_delta: float = 1e-4,
+        cooldown: int = 0,
+        min_lr: float = 0.0,
+        **kwargs,
+    ) -> None: ...
+    def in_cooldown(self) -> bool: ...
+
+class RemoteMonitor(Callback):
+    def __init__(
+        self,
+        root: str = "http://localhost:9000",
+        path: str = "/publish/epoch/end/",
+        field: str = "data",
+        headers: _HeadersMapping | None = None,
+        send_as_json: bool = False,
+    ) -> None: ...
+
+class TensorBoard(Callback):
+    write_steps_per_second: bool
+    update_freq: int | Literal["epoch"]
+
+    def __init__(
+        self,
+        log_dir: str = "logs",
+        histogram_freq: int = 0,
+        write_graph: bool = True,
+        write_images: bool = False,
+        write_steps_per_second: bool = False,
+        update_freq: int | Literal["epoch"] = "epoch",
+        profile_batch: int | tuple[int, int] = 0,
+        embeddings_freq: int = 0,
+        embeddings_metadata: dict[str, None] | None = None,
+    ) -> None: ...
+    def _write_keras_model_train_graph(self) -> None: ...
+    def _stop_trace(self, batch: int | None = None) -> None: ...
+
+class TerminateOnNaN(Callback): ...

package/dist/typeshed-fallback/stubs/tensorflow/tensorflow/keras/constraints.pyi

@@ -0,0 +1,16 @@
+from collections.abc import Callable
+from typing import Any, overload
+
+from tensorflow import Tensor
+
+class Constraint:
+    def get_config(self) -> dict[str, Any]: ...
+    def __call__(self, w: Tensor, /) -> Tensor: ...
+
+@overload
+def get(identifier: None) -> None: ...
+@overload
+def get(identifier: str | dict[str, Any] | Constraint) -> Constraint: ...
+@overload
+def get(identifier: Callable[[Tensor], Tensor]) -> Callable[[Tensor], Tensor]: ...
+def __getattr__(name: str): ...  # incomplete module

package/dist/typeshed-fallback/stubs/tensorflow/tensorflow/keras/initializers.pyi

@@ -0,0 +1,50 @@
+from collections.abc import Callable
+from typing import Any, overload
+from typing_extensions import Self, TypeAlias
+
+from tensorflow import Tensor
+from tensorflow._aliases import DTypeLike, ShapeLike, TensorCompatible
+
+class Initializer:
+    def __call__(self, shape: ShapeLike, dtype: DTypeLike | None = None) -> Tensor: ...
+    def get_config(self) -> dict[str, Any]: ...
+    @classmethod
+    def from_config(cls, config: dict[str, Any]) -> Self: ...
+
+class Constant(Initializer):
+    def __init__(self, value: TensorCompatible = 0.0) -> None: ...
+
+class GlorotNormal(Initializer):
+    def __init__(self, seed: int | None = None) -> None: ...
+
+class GlorotUniform(Initializer):
+    def __init__(self, seed: int | None = None) -> None: ...
+
+class TruncatedNormal(Initializer):
+    def __init__(self, mean: TensorCompatible = 0.0, stddev: TensorCompatible = 0.05, seed: int | None = None) -> None: ...
+
+class RandomNormal(Initializer):
+    def __init__(self, mean: TensorCompatible = 0.0, stddev: TensorCompatible = 0.05, seed: int | None = None) -> None: ...
+
+class RandomUniform(Initializer):
+    def __init__(self, minval: TensorCompatible = -0.05, maxval: TensorCompatible = 0.05, seed: int | None = None) -> None: ...
+
+class Zeros(Initializer): ...
+
+constant = Constant
+glorot_normal = GlorotNormal
+glorot_uniform = GlorotUniform
+truncated_normal = TruncatedNormal
+zeros = Zeros
+
+_Initializer: TypeAlias = (  # noqa: Y047
+    str | Initializer | type[Initializer] | Callable[[ShapeLike], Tensor] | dict[str, Any] | None
+)
+
+@overload
+def get(identifier: None) -> None: ...
+@overload
+def get(identifier: str | Initializer | dict[str, Any] | type[Initializer]) -> Initializer: ...
+@overload
+def get(identifier: Callable[[ShapeLike], Tensor]) -> Callable[[ShapeLike], Tensor]: ...
+def __getattr__(name: str): ...  # incomplete module