Add files using upload-large-folder tool

.gitattributes

@@ -881,3 +881,4 @@ videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/sparse
 videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/gen_training_ops.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/nn_ops.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/tensorflow/python/ops/ragged/__pycache__/ragged_tensor.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/tensorflow/python/ops/__pycache__/gen_nn_ops.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

videochat2/lib/python3.10/site-packages/tensorflow/python/data/__init__.py

@@ -0,0 +1,33 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""`tf.data.Dataset` API for input pipelines.
+
+See [Importing Data](https://tensorflow.org/guide/data) for an overview.
+"""
+
+# pylint: disable=unused-import
+from tensorflow.python.data import experimental
+from tensorflow.python.data.ops.dataset_ops import AUTOTUNE
+from tensorflow.python.data.ops.dataset_ops import Dataset
+from tensorflow.python.data.ops.dataset_ops import INFINITE as INFINITE_CARDINALITY
+from tensorflow.python.data.ops.dataset_ops import make_initializable_iterator
+from tensorflow.python.data.ops.dataset_ops import make_one_shot_iterator
+from tensorflow.python.data.ops.dataset_ops import UNKNOWN as UNKNOWN_CARDINALITY
+from tensorflow.python.data.ops.iterator_ops import Iterator
+from tensorflow.python.data.ops.options import Options
+from tensorflow.python.data.ops.readers import FixedLengthRecordDataset
+from tensorflow.python.data.ops.readers import TextLineDataset
+from tensorflow.python.data.ops.readers import TFRecordDataset
+# pylint: enable=unused-import

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/__init__.py

@@ -0,0 +1,172 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Experimental API for building input pipelines.
+
+This module contains experimental `Dataset` sources and transformations that can
+be used in conjunction with the `tf.data.Dataset` API. Note that the
+`tf.data.experimental` API is not subject to the same backwards compatibility
+guarantees as `tf.data`, but we will provide deprecation advice in advance of
+removing existing functionality.
+
+See [Importing Data](https://tensorflow.org/guide/datasets) for an overview.
+
+@@AutoShardPolicy
+@@AutotuneAlgorithm
+@@AutotuneOptions
+@@Counter
+@@CsvDataset
+@@DatasetInitializer
+@@DatasetStructure
+@@DistributeOptions
+@@ExternalStatePolicy
+@@OptimizationOptions
+@@Optional
+@@OptionalStructure
+@@RaggedTensorStructure
+@@RandomDataset
+@@Reducer
+@@SparseTensorStructure
+@@SqlDataset
+@@Structure
+@@TFRecordWriter
+@@TensorArrayStructure
+@@TensorStructure
+@@ThreadingOptions
+
+@@assert_cardinality
+@@at
+@@bucket_by_sequence_length
+@@cardinality
+@@choose_from_datasets
+@@copy_to_device
+@@dense_to_ragged_batch
+@@dense_to_sparse_batch
+@@distribute
+@@enable_debug_mode
+@@enumerate_dataset
+@@from_list
+@@from_variant
+@@get_next_as_optional
+@@get_single_element
+@@get_structure
+@@group_by_reducer
+@@group_by_window
+@@ignore_errors
+@@index_table_from_dataset
+@@load
+@@make_batched_features_dataset
+@@make_csv_dataset
+@@make_saveable_from_iterator
+@@map_and_batch
+@@map_and_batch_with_legacy_function
+@@pad_to_cardinality
+@@parallel_interleave
+@@parse_example_dataset
+@@prefetch_to_device
+@@rejection_resample
+@@sample_from_datasets
+@@save
+@@scan
+@@shuffle_and_repeat
+@@snapshot
+@@table_from_dataset
+@@take_while
+@@to_variant
+@@unbatch
+@@unique
+
+@@AUTOTUNE
+@@INFINITE_CARDINALITY
+@@SHARD_HINT
+@@UNKNOWN_CARDINALITY
+"""
+
+# pylint: disable=unused-import
+from tensorflow.python.data.experimental import service
+from tensorflow.python.data.experimental.ops.batching import dense_to_ragged_batch
+from tensorflow.python.data.experimental.ops.batching import dense_to_sparse_batch
+from tensorflow.python.data.experimental.ops.batching import map_and_batch
+from tensorflow.python.data.experimental.ops.batching import map_and_batch_with_legacy_function
+from tensorflow.python.data.experimental.ops.batching import unbatch
+from tensorflow.python.data.experimental.ops.cardinality import assert_cardinality
+from tensorflow.python.data.experimental.ops.cardinality import cardinality
+from tensorflow.python.data.experimental.ops.cardinality import INFINITE as INFINITE_CARDINALITY
+from tensorflow.python.data.experimental.ops.cardinality import UNKNOWN as UNKNOWN_CARDINALITY
+from tensorflow.python.data.experimental.ops.counter import Counter
+from tensorflow.python.data.experimental.ops.distribute import SHARD_HINT
+from tensorflow.python.data.experimental.ops.enumerate_ops import enumerate_dataset
+from tensorflow.python.data.experimental.ops.error_ops import ignore_errors
+from tensorflow.python.data.experimental.ops.from_list import from_list
+from tensorflow.python.data.experimental.ops.get_single_element import get_single_element
+from tensorflow.python.data.experimental.ops.grouping import bucket_by_sequence_length
+from tensorflow.python.data.experimental.ops.grouping import group_by_reducer
+from tensorflow.python.data.experimental.ops.grouping import group_by_window
+from tensorflow.python.data.experimental.ops.grouping import Reducer
+from tensorflow.python.data.experimental.ops.interleave_ops import choose_from_datasets
+from tensorflow.python.data.experimental.ops.interleave_ops import parallel_interleave
+from tensorflow.python.data.experimental.ops.interleave_ops import sample_from_datasets
+from tensorflow.python.data.experimental.ops.io import load
+from tensorflow.python.data.experimental.ops.io import save
+from tensorflow.python.data.experimental.ops.iterator_ops import make_saveable_from_iterator
+from tensorflow.python.data.experimental.ops.lookup_ops import DatasetInitializer
+from tensorflow.python.data.experimental.ops.lookup_ops import index_table_from_dataset
+from tensorflow.python.data.experimental.ops.lookup_ops import table_from_dataset
+from tensorflow.python.data.experimental.ops.pad_to_cardinality import pad_to_cardinality
+from tensorflow.python.data.experimental.ops.parsing_ops import parse_example_dataset
+from tensorflow.python.data.experimental.ops.prefetching_ops import copy_to_device
+from tensorflow.python.data.experimental.ops.prefetching_ops import prefetch_to_device
+from tensorflow.python.data.experimental.ops.random_access import at
+from tensorflow.python.data.experimental.ops.random_ops import RandomDataset
+from tensorflow.python.data.experimental.ops.readers import CsvDataset
+from tensorflow.python.data.experimental.ops.readers import make_batched_features_dataset
+from tensorflow.python.data.experimental.ops.readers import make_csv_dataset
+from tensorflow.python.data.experimental.ops.readers import SqlDataset
+from tensorflow.python.data.experimental.ops.resampling import rejection_resample
+from tensorflow.python.data.experimental.ops.scan_ops import scan
+from tensorflow.python.data.experimental.ops.shuffle_ops import shuffle_and_repeat
+from tensorflow.python.data.experimental.ops.snapshot import snapshot
+from tensorflow.python.data.experimental.ops.take_while_ops import take_while
+from tensorflow.python.data.experimental.ops.unique import unique
+from tensorflow.python.data.experimental.ops.writers import TFRecordWriter
+from tensorflow.python.data.ops.dataset_ops import AUTOTUNE
+from tensorflow.python.data.ops.dataset_ops import DatasetSpec as DatasetStructure
+from tensorflow.python.data.ops.dataset_ops import from_variant
+from tensorflow.python.data.ops.dataset_ops import get_structure
+from tensorflow.python.data.ops.dataset_ops import to_variant
+from tensorflow.python.data.ops.debug_mode import enable_debug_mode
+from tensorflow.python.data.ops.iterator_ops import get_next_as_optional
+from tensorflow.python.data.ops.optional_ops import Optional
+from tensorflow.python.data.ops.optional_ops import OptionalSpec as OptionalStructure
+from tensorflow.python.data.ops.options import AutoShardPolicy
+from tensorflow.python.data.ops.options import AutotuneAlgorithm
+from tensorflow.python.data.ops.options import AutotuneOptions
+from tensorflow.python.data.ops.options import DistributeOptions
+from tensorflow.python.data.ops.options import ExternalStatePolicy
+from tensorflow.python.data.ops.options import OptimizationOptions
+from tensorflow.python.data.ops.options import ThreadingOptions
+from tensorflow.python.data.util.structure import _RaggedTensorStructure as RaggedTensorStructure
+from tensorflow.python.data.util.structure import _SparseTensorStructure as SparseTensorStructure
+from tensorflow.python.data.util.structure import _TensorArrayStructure as TensorArrayStructure
+from tensorflow.python.data.util.structure import _TensorStructure as TensorStructure
+from tensorflow.python.framework.type_spec import TypeSpec as Structure
+# pylint: enable=unused-import
+
+from tensorflow.python.util.all_util import remove_undocumented
+
+_allowed_symbols = [
+    "service",
+]
+
+remove_undocumented(__name__, _allowed_symbols)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/kernel_tests/service/multi_process_cluster.py

@@ -0,0 +1,165 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""tf.data service test-cluster with local and remote workers."""
+
+import tempfile
+
+from tensorflow.core.protobuf import data_service_pb2
+from tensorflow.core.protobuf import service_config_pb2
+from tensorflow.python.data.experimental.kernel_tests.service import test_base as data_service_test_base
+from tensorflow.python.data.experimental.service import server_lib
+from tensorflow.python.distribute import multi_process_lib
+from tensorflow.python.framework import test_util
+from tensorflow.python.platform import googletest
+
+_WORKER_SHUTDOWN_QUIET_PERIOD_MS = 100
+
+
+# pylint: disable=protected-access
+class _RemoteWorkerProcess(multi_process_lib.Process):
+  """Runs a worker server in a new process to simulate a remote worker."""
+
+  def __init__(self, dispatcher_address, port, worker_tags, pipe_writer):
+    super(_RemoteWorkerProcess, self).__init__()
+    self._dispatcher_address = dispatcher_address
+    self._port = port
+    self._worker_tags = worker_tags
+    self._pipe_writer = pipe_writer
+
+  def run(self):
+    self.start_worker()
+
+  def start_worker(self):
+    self._worker = data_service_test_base.TestWorker(
+        self._dispatcher_address,
+        _WORKER_SHUTDOWN_QUIET_PERIOD_MS,
+        port=self._port,
+        worker_tags=self._worker_tags)
+    self._worker.start()
+    self._pipe_writer.send(self._worker.worker_address())
+    self._worker.join()
+
+
+class MultiProcessCluster:
+  """tf.data service cluster with local and remote workers.
+
+  Represents a cluster with a dispatcher, `num_local_workers` local workers, and
+  `num_remote_workers` remote workers. Remote workers run in separate processes.
+  This is useful to test reading from local in-process workers. For example:
+
+  ```
+  cluster = multi_process_cluster.MultiProcessCluster(
+      num_local_workers=1, num_remote_workers=3)
+  num_elements = 10
+  dataset = self.make_distributed_range_dataset(
+      num_elements, cluster, target_workers="LOCAL")
+  self.assertDatasetProduces(dataset, list(range(num_elements)))
+  ```
+  """
+
+  def __init__(self,
+               num_local_workers,
+               num_remote_workers,
+               worker_tags=None,
+               worker_addresses=None,
+               deployment_mode=data_service_pb2.DEPLOYMENT_MODE_COLOCATED):
+    self._work_dir = tempfile.mkdtemp(dir=googletest.GetTempDir())
+    self._deployment_mode = deployment_mode
+    self._start_dispatcher(worker_addresses)
+    self._start_local_workers(num_local_workers, worker_tags)
+    self._start_remote_workers(num_remote_workers, worker_tags)
+
+  def _start_dispatcher(self, worker_addresses, port=0):
+    if port == 0:
+      port = test_util.pick_unused_port()
+    self._dispatcher = server_lib.DispatchServer(
+        service_config_pb2.DispatcherConfig(
+            port=port,
+            protocol="grpc",
+            work_dir=self._work_dir,
+            fault_tolerant_mode=True,
+            worker_addresses=worker_addresses,
+            deployment_mode=self._deployment_mode),
+        start=True)
+
+  def _start_local_workers(self, num_workers, worker_tags=None):
+    self._local_workers = []
+    for _ in range(num_workers):
+      self.start_local_worker(worker_tags)
+
+  def _start_remote_workers(self, num_workers, worker_tags=None):
+    # List of (worker address, remote worker process) tuples.
+    self._remote_workers = []
+    for _ in range(num_workers):
+      self.start_remote_worker(worker_tags)
+
+  def start_local_worker(self, worker_tags=None):
+    worker = data_service_test_base.TestWorker(
+        self.dispatcher_address(),
+        _WORKER_SHUTDOWN_QUIET_PERIOD_MS,
+        port=test_util.pick_unused_port(),
+        worker_tags=worker_tags)
+    worker.start()
+    self._local_workers.append(worker)
+
+  def start_remote_worker(self, worker_tags=None):
+    """Runs a tf.data service worker in a remote process."""
+
+    pipe_reader, pipe_writer = multi_process_lib.multiprocessing.Pipe(
+        duplex=False)
+    worker_process = _RemoteWorkerProcess(
+        self.dispatcher_address(),
+        port=test_util.pick_unused_port(),
+        worker_tags=worker_tags,
+        pipe_writer=pipe_writer)
+    worker_process.start()
+    worker_address = pipe_reader.recv()
+    self._remote_workers.append((worker_address, worker_process))
+
+  def restart_dispatcher(self):
+    port = int(self.dispatcher_address().split(":")[1])
+    self._dispatcher._stop()
+    self._start_dispatcher(
+        worker_addresses=(self.local_worker_addresses() +
+                          self.remote_worker_addresses()),
+        port=port)
+
+  def restart_local_workers(self):
+    for worker in self._local_workers:
+      worker.restart()
+
+  def dispatcher_address(self):
+    return self._dispatcher._address
+
+  def local_worker_addresses(self):
+    return [worker.worker_address() for worker in self._local_workers]
+
+  def remote_worker_addresses(self):
+    return [worker_address for (worker_address, _) in self._remote_workers]
+
+  def _stop(self):
+    for worker in self._local_workers:
+      worker.stop()
+    for (_, worker_process) in self._remote_workers:
+      worker_process.kill()
+    self._dispatcher._stop()
+
+  def __del__(self):
+    self._stop()
+
+
+def test_main():
+  """Main function to be called within `__main__` of a test file."""
+  multi_process_lib.test_main()

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/kernel_tests/service/test_base.py

@@ -0,0 +1,456 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Test base for tf.data service tests."""
+
+import os
+import shutil
+import tempfile
+
+from tensorflow.core.protobuf import service_config_pb2
+from tensorflow.python.data.experimental.ops import data_service_ops
+from tensorflow.python.data.experimental.service import server_lib
+from tensorflow.python.data.kernel_tests import test_base
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.framework import combinations
+from tensorflow.python.framework import dtypes
+from tensorflow.python.ops import math_ops
+from tensorflow.python.platform import googletest
+
+# This will be resolved to a tmp directory by `start_dispatch_server`.
+TMP_WORK_DIR = "tmp_work_dir_placeholder"
+# `""` indicates not to use a work directory.
+NO_WORK_DIR = ""
+# We use a faster than normal heartbeat interval so that tests run faster.
+TEST_HEARTBEAT_INTERVAL_MS = 100
+TEST_DISPATCHER_TIMEOUT_MS = 5000
+TEST_WORKER_TIMEOUT_MS = 200
+TEST_JOB_GC_CHECK_INTERNAL_MS = 1000
+TEST_SNAPSHOT_MAX_CHUNK_SIZE_BYTES = 16 << 10  # 16 KB
+PROTOCOL = "grpc"
+
+
+def all_cluster_configurations():
+  with_work_dir = combinations.combine(
+      work_dir=TMP_WORK_DIR, fault_tolerant_mode=[True, False])
+  without_work_dir = combinations.combine(
+      work_dir=NO_WORK_DIR, fault_tolerant_mode=False)
+  return with_work_dir + without_work_dir
+
+
+def _make_worker(
+    dispatcher_address,
+    protocol,
+    data_transfer_protocol,
+    shutdown_quiet_period_ms=0,
+    port=0,
+    worker_tags=None,
+    cross_trainer_cache_size_bytes=None,
+    snapshot_max_chunk_size_bytes=TEST_SNAPSHOT_MAX_CHUNK_SIZE_BYTES,
+):
+  """Creates a worker server."""
+  defaults = server_lib.WorkerConfig(dispatcher_address=dispatcher_address)
+  config_proto = service_config_pb2.WorkerConfig(
+      dispatcher_address=dispatcher_address,
+      worker_address=defaults.worker_address,
+      port=port,
+      protocol=protocol,
+      worker_tags=worker_tags,
+      heartbeat_interval_ms=TEST_HEARTBEAT_INTERVAL_MS,
+      dispatcher_timeout_ms=TEST_DISPATCHER_TIMEOUT_MS,
+      data_transfer_protocol=data_transfer_protocol,
+      data_transfer_address=defaults.worker_address,
+      shutdown_quiet_period_ms=shutdown_quiet_period_ms,
+      cross_trainer_cache_size_bytes=cross_trainer_cache_size_bytes,
+      snapshot_max_chunk_size_bytes=snapshot_max_chunk_size_bytes,
+  )
+  return server_lib.WorkerServer(config_proto, start=False)
+
+
+# pylint: disable=protected-access
+class TestWorker:
+  """A tf.data service worker."""
+
+  def __init__(
+      self,
+      dispatcher_address,
+      shutdown_quiet_period_ms,
+      protocol=PROTOCOL,
+      data_transfer_protocol=None,
+      port=0,
+      worker_tags=None,
+      cross_trainer_cache_size_bytes=None,
+      snapshot_max_chunk_size_bytes=TEST_SNAPSHOT_MAX_CHUNK_SIZE_BYTES,
+  ):
+    self._dispatcher_address = dispatcher_address
+    self._shutdown_quiet_period_ms = shutdown_quiet_period_ms
+    self._server = _make_worker(
+        dispatcher_address,
+        protocol,
+        data_transfer_protocol,
+        shutdown_quiet_period_ms,
+        port=port,
+        worker_tags=worker_tags,
+        cross_trainer_cache_size_bytes=cross_trainer_cache_size_bytes,
+        snapshot_max_chunk_size_bytes=snapshot_max_chunk_size_bytes,
+    )
+    self._running = False
+    self._protocol = protocol
+    self._data_transfer_protocol = data_transfer_protocol
+
+  def stop(self):
+    self._server._stop()
+    self._running = False
+
+  def start(self):
+    self._server.start()
+    self._port = int(self._server._address.split(":")[1])
+    self._running = True
+
+  def restart(self, use_same_port=True):
+    """Restarts the worker, stopping it first if it is already running."""
+    if self._running:
+      self.stop()
+    port = 0
+    if use_same_port:
+      port = self._port
+    self._server = _make_worker(self._dispatcher_address,
+                                self._protocol,
+                                self._data_transfer_protocol,
+                                self._shutdown_quiet_period_ms, port)
+    self._server.start()
+    self._port = int(self._server._address.split(":")[1])
+    self._running = True
+
+  def join(self):
+    self._server.join()
+
+  def num_tasks(self):
+    return self._server._num_tasks()
+
+  def snapshot_task_progresses(self):
+    return self._server._snapshot_task_progresses()
+
+  def worker_address(self):
+    return self._server._address
+
+
+class TestCluster:
+  """Test tf.data service cluster."""
+
+  def __init__(
+      self,
+      num_workers,
+      dispatcher_port=0,
+      work_dir=TMP_WORK_DIR,
+      fault_tolerant_mode=True,
+      job_gc_check_interval_ms=TEST_JOB_GC_CHECK_INTERNAL_MS,
+      job_gc_timeout_ms=None,
+      worker_timeout_ms=TEST_WORKER_TIMEOUT_MS,
+      worker_shutdown_quiet_period_ms=0,
+      snapshot_max_chunk_size_bytes=TEST_SNAPSHOT_MAX_CHUNK_SIZE_BYTES,
+      worker_max_concurrent_snapshots=0,
+      start=True,
+      protocol=PROTOCOL,
+      data_transfer_protocol=None,
+  ):
+    """Creates a tf.data service test cluster.
+
+    Args:
+      num_workers: The number of workers to initially add to the cluster.
+      dispatcher_port: The port to use for the dispatcher.
+      work_dir: The work directory to use for the dispatcher. If set to
+        `TMP_WORK_DIR`, the cluster will create a new temporary directory to use
+        as the work directory. If set to `NO_WORK_DIR`, no work directory will
+        be used.
+      fault_tolerant_mode: Whether the dispatcher should write its state to a
+        journal so that it can recover from restarts.
+      job_gc_check_interval_ms: How often the dispatcher should scan through to
+        delete old and unused jobs, in milliseconds.
+      job_gc_timeout_ms: How long a job needs to be unused before it becomes a
+        candidate for garbage collection, in milliseconds.
+      worker_timeout_ms: How long to wait for a worker to heartbeat before
+        considering it missing, in milliseconds.
+      worker_shutdown_quiet_period_ms: When shutting down a worker, how long to
+        wait for the gRPC server to process the final requests.
+      snapshot_max_chunk_size_bytes: The maximum size of a distributed snapshot
+        chunk file.
+      worker_max_concurrent_snapshots: The maximum number of snapshots a worker
+        can concurrently process.
+      start: Whether to immediately start the servers in the cluster. If
+        `False`, the servers can be started later by calling
+        `start_dispatcher()` and `start_workers()`.
+      protocol: The protocol to use for communicating with the tf.data service,
+        e.g. "grpc".
+      data_transfer_protocol: (Optional.) The protocol to use for transferring
+        data with the tf.data service.
+    """
+    if work_dir == TMP_WORK_DIR:
+      work_dir = tempfile.mkdtemp(dir=googletest.GetTempDir())
+    self._worker_shutdown_quiet_period_ms = worker_shutdown_quiet_period_ms
+    self._snapshot_max_chunk_size_bytes = snapshot_max_chunk_size_bytes
+    self._protocol = protocol
+    self._data_transfer_protocol = data_transfer_protocol
+    self._job_gc_check_interval_ms = job_gc_check_interval_ms
+    self._job_gc_timeout_ms = job_gc_timeout_ms
+    self._worker_timeout_ms = worker_timeout_ms
+    self._worker_max_concurrent_snapshots = worker_max_concurrent_snapshots
+    self.dispatcher = server_lib.DispatchServer(
+        server_lib.DispatcherConfig(
+            port=dispatcher_port,
+            work_dir=work_dir,
+            protocol=protocol,
+            fault_tolerant_mode=fault_tolerant_mode,
+            job_gc_check_interval_ms=job_gc_check_interval_ms,
+            job_gc_timeout_ms=job_gc_timeout_ms,
+            worker_timeout_ms=worker_timeout_ms,
+            worker_max_concurrent_snapshots=worker_max_concurrent_snapshots,
+        ),
+        start=start,
+    )
+
+    self.workers = []
+    for _ in range(num_workers):
+      self.add_worker(start=start)
+
+  def dispatcher_address(self):
+    return self.dispatcher.target.split("://")[1]
+
+  def add_worker(self, start=True):
+    worker = TestWorker(
+        self.dispatcher_address(),
+        self._worker_shutdown_quiet_period_ms,
+        self._protocol,
+        self._data_transfer_protocol,
+        snapshot_max_chunk_size_bytes=self._snapshot_max_chunk_size_bytes,
+    )
+    if start:
+      worker.start()
+    self.workers.append(worker)
+
+  def start_dispatcher(self):
+    self.dispatcher.start()
+
+  def start_workers(self):
+    for worker in self.workers:
+      worker.start()
+
+  def stop_dispatcher(self):
+    # pylint: disable=protected-access
+    self.dispatcher._stop()
+
+  def restart_worker(self, index):
+    self.workers[index].restart()
+
+  def stop_worker(self, index):
+    self.workers[index].stop()
+
+  def stop_workers(self):
+    for worker in self.workers:
+      worker.stop()
+
+  # pylint: disable=protected-access
+  def restart_dispatcher(self):
+    """Stops `dispatcher` and creates a new dispatcher with the same port.
+
+    Restarting is supported only when the dispatcher is configured with
+    `fault_tolerant_mode=True`.
+    """
+    if not self.dispatcher._config.fault_tolerant_mode:
+      raise ValueError(
+          "Trying to restart the dispatcher without fault-tolerance.")
+    port = int(self.dispatcher_address().split(":")[1])
+    self.dispatcher._stop()
+    self.dispatcher = server_lib.DispatchServer(
+        server_lib.DispatcherConfig(
+            port=port,
+            work_dir=self.dispatcher._config.work_dir,
+            protocol=self._protocol,
+            fault_tolerant_mode=self.dispatcher._config.fault_tolerant_mode,
+            job_gc_check_interval_ms=self._job_gc_check_interval_ms,
+            job_gc_timeout_ms=self._job_gc_timeout_ms,
+            worker_timeout_ms=self._worker_timeout_ms,
+            worker_max_concurrent_snapshots=
+            self._worker_max_concurrent_snapshots,
+        )
+    )
+
+  def num_registered_workers(self):
+    return self.dispatcher._num_workers()
+
+  def num_tasks_on_workers(self):
+    return sum(worker.num_tasks() for worker in self.workers)
+
+  def snapshot_streams(self, path):
+    return self.dispatcher._snapshot_streams(path)
+
+  def __del__(self):
+    # Destroy workers before the dispatcher for clean shutdown.
+    self.workers.clear()
+    del self.dispatcher
+
+
+class TestBase(test_base.DatasetTestBase):
+  """Base class for tf.data service tests."""
+
+  def setUp(self):
+    self.default_data_transfer_protocol = None
+    self.default_compression = "AUTO"
+
+  def set_default_data_transfer_protocol(self, protocol):
+    self.default_data_transfer_protocol = protocol
+
+  def set_default_compression(self, compression):
+    self.default_compression = compression
+
+  def make_test_cluster(self, *args, **kwargs):
+    if "data_transfer_protocol" not in kwargs:
+      kwargs["data_transfer_protocol"] = self.default_data_transfer_protocol
+    return TestCluster(*args, **kwargs)
+
+  def make_distributed_dataset(self,
+                               dataset,
+                               cluster,
+                               processing_mode="parallel_epochs",
+                               **kwargs):
+    kwargs["task_refresh_interval_hint_ms"] = 20
+    if "data_transfer_protocol" not in kwargs:
+      kwargs["data_transfer_protocol"] = self.default_data_transfer_protocol
+    if "compression" not in kwargs:
+      kwargs["compression"] = self.default_compression
+
+    # pylint: disable=protected-access
+    return dataset.apply(
+        data_service_ops._distribute(
+            processing_mode,
+            cluster.dispatcher_address(),
+            **kwargs))
+
+  def make_distributed_range_dataset(self,
+                                     num_elements,
+                                     cluster,
+                                     **kwargs):
+    dataset = dataset_ops.Dataset.range(num_elements)
+    return self.make_distributed_dataset(dataset, cluster, **kwargs)
+
+  def make_coordinated_read_dataset(
+      self,
+      cluster,
+      num_consumers,
+      sharding_policy=data_service_ops.ShardingPolicy.OFF):
+    """Creates a dataset that performs coordinated reads.
+
+    The dataset simulates `num_consumers` consumers by using parallel
+    interleave to read with `num_consumers` threads, one for each consumer. The
+    nth element of the dataset is produced by consumer `n % num_consumers`.
+
+    The dataset executed on each worker will produce groups of `num_consumers`
+    sequentially increasing numbers. For example, if `num_consumers=3` a worker
+    dataset could produce [0, 1, 2, 9, 10, 11, 21, 22, 23]. This enables
+    `checkCoordinatedReadGroups` below to assess whether the values received in
+    each step came from the same group.
+
+    Args:
+      cluster: A tf.data service `TestCluster`.
+      num_consumers: The number of consumers to simulate.
+      sharding_policy: The sharding policy to use. Currently only OFF and
+        DYNAMIC are supported.
+
+    Returns:
+      A dataset that simulates reading with `num_consumers` consumers.
+    """
+    if sharding_policy not in [
+        data_service_ops.ShardingPolicy.OFF,
+        data_service_ops.ShardingPolicy.DYNAMIC
+    ]:
+      raise ValueError(f"Unsupported sharding policy: {sharding_policy}")
+    # Start from 0 so that we can detect when a new worker is added with
+    # ShardingPolicy.OFF.
+    ds = dataset_ops.Dataset.from_tensors(math_ops.cast(0, dtypes.int64))
+    ds = ds.concatenate(dataset_ops.Dataset.random())
+    # Ensure that all elements in the same group are consecutive.
+    def make_group(x):
+      # Avoid overflowing an int64 in (x+1)*num_consumers below.
+      x = x % (2**32)
+      return dataset_ops.Dataset.range(x*num_consumers, (x+1)*num_consumers)
+    ds = ds.flat_map(make_group)
+    consumers = []
+    for consumer_index in range(num_consumers):
+      consumers.append(
+          self.make_distributed_dataset(
+              ds,
+              cluster,
+              job_name="test",
+              processing_mode=sharding_policy,
+              consumer_index=consumer_index,
+              num_consumers=num_consumers))
+    # Use parallel interleave to read from consumers in parallel.
+    ds = dataset_ops.Dataset.from_tensor_slices(consumers)
+    ds = ds.interleave(
+        lambda x: x,
+        cycle_length=num_consumers,
+        num_parallel_calls=num_consumers)
+    return ds
+
+  def checkCoordinatedReadGroups(self, results, num_consumers):
+    """Validates results from a `make_coordinted_read_dataset` dataset.
+
+    Each group of `num_consumers` results should be consecutive, indicating that
+    they were produced by the same worker.
+
+    Args:
+      results: The elements produced by the dataset.
+      num_consumers: The number of consumers.
+    """
+    groups = [
+        results[start:start + num_consumers]
+        for start in range(0, len(results), num_consumers)
+    ]
+    incorrect_groups = []
+    for group in groups:
+      # Check that each group of `num_consumers` results are consecutive.
+      for offset in range(1, len(group)):
+        if group[0] + offset != group[offset]:
+          incorrect_groups.append(group)
+          break
+    self.assertEmpty(
+        incorrect_groups,
+        "Incorrect groups: {}.\nAll groups: {}".format(incorrect_groups,
+                                                       groups))
+
+  def read(self, get_next, results, count):
+    for _ in range(count):
+      results.append(self.evaluate(get_next()))
+
+
+class TempDir:
+  """Temporary directory for unit testing."""
+
+  def __init__(self):
+    temp_dir = tempfile.mkdtemp(dir=googletest.GetTempDir())
+    self._path = os.path.join(
+        tempfile.mkdtemp(dir=temp_dir), "tf_data_snapshot")
+
+  @property
+  def full_path(self) -> str:
+    return self._path
+
+  def __fspath__(self) -> str:
+    return self._path
+
+  def __del__(self):
+    try:
+      shutil.rmtree(self.full_path)
+    except FileNotFoundError:
+      pass

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/batching.py

@@ -0,0 +1,379 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Batching dataset transformations."""
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.data.ops import structured_function
+from tensorflow.python.data.util import convert
+from tensorflow.python.data.util import nest
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import sparse_tensor
+from tensorflow.python.framework import tensor_shape
+from tensorflow.python.framework import tensor_util
+from tensorflow.python.ops import gen_experimental_dataset_ops as ged_ops
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("data.experimental.dense_to_ragged_batch")
+@deprecation.deprecated(None, "Use `tf.data.Dataset.ragged_batch` instead.")
+def dense_to_ragged_batch(batch_size,
+                          drop_remainder=False,
+                          row_splits_dtype=dtypes.int64):
+  """A transformation that batches ragged elements into `tf.RaggedTensor`s.
+
+  This transformation combines multiple consecutive elements of the input
+  dataset into a single element.
+
+  Like `tf.data.Dataset.batch`, the components of the resulting element will
+  have an additional outer dimension, which will be `batch_size` (or
+  `N % batch_size` for the last element if `batch_size` does not divide the
+  number of input elements `N` evenly and `drop_remainder` is `False`). If
+  your program depends on the batches having the same outer dimension, you
+  should set the `drop_remainder` argument to `True` to prevent the smaller
+  batch from being produced.
+
+  Unlike `tf.data.Dataset.batch`, the input elements to be batched may have
+  different shapes:
+
+  *  If an input element is a `tf.Tensor` whose static `tf.TensorShape` is
+     fully defined, then it is batched as normal.
+  *  If an input element is a `tf.Tensor` whose static `tf.TensorShape` contains
+     one or more axes with unknown size (i.e., `shape[i]=None`), then the output
+     will contain a `tf.RaggedTensor` that is ragged up to any of such
+     dimensions.
+  *  If an input element is a `tf.RaggedTensor` or any other type, then it is
+     batched as normal.
+
+  Example:
+
+  >>> dataset = tf.data.Dataset.from_tensor_slices(np.arange(6))
+  >>> dataset = dataset.map(lambda x: tf.range(x))
+  >>> dataset.element_spec.shape
+  TensorShape([None])
+  >>> dataset = dataset.apply(
+  ...     tf.data.experimental.dense_to_ragged_batch(batch_size=2))
+  >>> for batch in dataset:
+  ...   print(batch)
+  <tf.RaggedTensor [[], [0]]>
+  <tf.RaggedTensor [[0, 1], [0, 1, 2]]>
+  <tf.RaggedTensor [[0, 1, 2, 3], [0, 1, 2, 3, 4]]>
+
+  Args:
+    batch_size: A `tf.int64` scalar `tf.Tensor`, representing the number of
+      consecutive elements of this dataset to combine in a single batch.
+    drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing
+      whether the last batch should be dropped in the case it has fewer than
+      `batch_size` elements; the default behavior is not to drop the smaller
+      batch.
+    row_splits_dtype: The dtype that should be used for the `row_splits` of any
+      new ragged tensors.  Existing `tf.RaggedTensor` elements do not have their
+      row_splits dtype changed.
+
+  Returns:
+    Dataset: A `Dataset`.
+  """
+  def _apply_fn(dataset):
+    return dataset.ragged_batch(batch_size, drop_remainder, row_splits_dtype)
+
+  return _apply_fn
+
+
+@tf_export("data.experimental.dense_to_sparse_batch")
+@deprecation.deprecated(None, "Use `tf.data.Dataset.sparse_batch` instead.")
+def dense_to_sparse_batch(batch_size, row_shape):
+  """A transformation that batches ragged elements into `tf.sparse.SparseTensor`s.
+
+  Like `Dataset.padded_batch()`, this transformation combines multiple
+  consecutive elements of the dataset, which might have different
+  shapes, into a single element. The resulting element has three
+  components (`indices`, `values`, and `dense_shape`), which
+  comprise a `tf.sparse.SparseTensor` that represents the same data. The
+  `row_shape` represents the dense shape of each row in the
+  resulting `tf.sparse.SparseTensor`, to which the effective batch size is
+  prepended. For example:
+
+  ```python
+  # NOTE: The following examples use `{ ... }` to represent the
+  # contents of a dataset.
+  a = { ['a', 'b', 'c'], ['a', 'b'], ['a', 'b', 'c', 'd'] }
+
+  a.apply(tf.data.experimental.dense_to_sparse_batch(
+      batch_size=2, row_shape=[6])) ==
+  {
+      ([[0, 0], [0, 1], [0, 2], [1, 0], [1, 1]],  # indices
+       ['a', 'b', 'c', 'a', 'b'],                 # values
+       [2, 6]),                                   # dense_shape
+      ([[0, 0], [0, 1], [0, 2], [0, 3]],
+       ['a', 'b', 'c', 'd'],
+       [1, 6])
+  }
+  ```
+
+  Args:
+    batch_size: A `tf.int64` scalar `tf.Tensor`, representing the number of
+      consecutive elements of this dataset to combine in a single batch.
+    row_shape: A `tf.TensorShape` or `tf.int64` vector tensor-like object
+      representing the equivalent dense shape of a row in the resulting
+      `tf.sparse.SparseTensor`. Each element of this dataset must have the same
+      rank as `row_shape`, and must have size less than or equal to `row_shape`
+      in each dimension.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+
+  def _apply_fn(dataset):
+    return dataset.sparse_batch(batch_size, row_shape)
+
+  return _apply_fn
+
+
+@deprecation.deprecated(None, "Use `tf.data.experimental.map_and_batch()")
+@tf_export(v1=["data.experimental.map_and_batch_with_legacy_function"])
+def map_and_batch_with_legacy_function(map_func,
+                                       batch_size,
+                                       num_parallel_batches=None,
+                                       drop_remainder=False,
+                                       num_parallel_calls=None):
+  """Fused implementation of `map` and `batch`.
+
+  NOTE: This is an escape hatch for existing uses of `map_and_batch` that do not
+  work with V2 functions. New uses are strongly discouraged and existing uses
+  should migrate to `map_and_batch` as this method will not be removed in V2.
+
+  Args:
+    map_func: A function mapping a nested structure of tensors to another
+      nested structure of tensors.
+    batch_size: A `tf.int64` scalar `tf.Tensor`, representing the number of
+      consecutive elements of this dataset to combine in a single batch.
+    num_parallel_batches: (Optional.) A `tf.int64` scalar `tf.Tensor`,
+      representing the number of batches to create in parallel. On one hand,
+      higher values can help mitigate the effect of stragglers. On the other
+      hand, higher values can increase contention if CPU is scarce.
+    drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing
+      whether the last batch should be dropped in case its size is smaller than
+      desired; the default behavior is not to drop the smaller batch.
+    num_parallel_calls: (Optional.) A `tf.int32` scalar `tf.Tensor`,
+      representing the number of elements to process in parallel. If not
+      specified, `batch_size * num_parallel_batches` elements will be processed
+      in parallel. If the value `tf.data.AUTOTUNE` is used, then
+      the number of parallel calls is set dynamically based on available CPU.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+
+  Raises:
+    ValueError: If both `num_parallel_batches` and `num_parallel_calls` are
+      specified.
+  """
+
+  if num_parallel_batches is None and num_parallel_calls is None:
+    num_parallel_calls = batch_size
+  elif num_parallel_batches is not None and num_parallel_calls is None:
+    num_parallel_calls = batch_size * num_parallel_batches
+  elif num_parallel_batches is not None and num_parallel_calls is not None:
+    raise ValueError(
+        "`map_and_batch_with_legacy_function` allows only one of "
+        "`num_parallel_batches` and "
+        "`num_parallel_calls` to be set, but "
+        f"`num_parallel_batches` was set to {num_parallel_batches} "
+        f"and `num_parallel_calls` as set to {num_parallel_calls}.")
+
+  def _apply_fn(dataset):
+    return _MapAndBatchDataset(dataset, map_func, batch_size,
+                               num_parallel_calls, drop_remainder,
+                               use_legacy_function=True)
+
+  return _apply_fn
+
+
+@deprecation.deprecated(
+    None,
+    "Use `tf.data.Dataset.map(map_func, num_parallel_calls)` followed by "
+    "`tf.data.Dataset.batch(batch_size, drop_remainder)`. Static tf.data "
+    "optimizations will take care of using the fused implementation.")
+@tf_export("data.experimental.map_and_batch")
+def map_and_batch(map_func,
+                  batch_size,
+                  num_parallel_batches=None,
+                  drop_remainder=False,
+                  num_parallel_calls=None):
+  """Fused implementation of `map` and `batch`.
+
+  Maps `map_func` across `batch_size` consecutive elements of this dataset
+  and then combines them into a batch. Functionally, it is equivalent to `map`
+  followed by `batch`. This API is temporary and deprecated since input pipeline
+  optimization now fuses consecutive `map` and `batch` operations automatically.
+
+  Args:
+    map_func: A function mapping a nested structure of tensors to another
+      nested structure of tensors.
+    batch_size: A `tf.int64` scalar `tf.Tensor`, representing the number of
+      consecutive elements of this dataset to combine in a single batch.
+    num_parallel_batches: (Optional.) A `tf.int64` scalar `tf.Tensor`,
+      representing the number of batches to create in parallel. On one hand,
+      higher values can help mitigate the effect of stragglers. On the other
+      hand, higher values can increase contention if CPU is scarce.
+    drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing
+      whether the last batch should be dropped in case its size is smaller than
+      desired; the default behavior is not to drop the smaller batch.
+    num_parallel_calls: (Optional.) A `tf.int32` scalar `tf.Tensor`,
+      representing the number of elements to process in parallel. If not
+      specified, `batch_size * num_parallel_batches` elements will be processed
+      in parallel. If the value `tf.data.AUTOTUNE` is used, then
+      the number of parallel calls is set dynamically based on available CPU.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+
+  Raises:
+    ValueError: If both `num_parallel_batches` and `num_parallel_calls` are
+      specified.
+  """
+
+  if num_parallel_batches is None and num_parallel_calls is None:
+    num_parallel_calls = batch_size
+  elif num_parallel_batches is not None and num_parallel_calls is None:
+    num_parallel_calls = batch_size * num_parallel_batches
+  elif num_parallel_batches is not None and num_parallel_calls is not None:
+    raise ValueError(
+        "`map_and_batch` allows only one of `num_parallel_batches` and "
+        "`num_parallel_calls` to be set, but "
+        f"`num_parallel_batches` was set to {num_parallel_batches} "
+        f"and `num_parallel_calls` as set to {num_parallel_calls}.")
+
+  def _apply_fn(dataset):
+    return _MapAndBatchDataset(dataset, map_func, batch_size,
+                               num_parallel_calls, drop_remainder)
+
+  return _apply_fn
+
+
+@deprecation.deprecated(None, "Use `tf.data.Dataset.unbatch()`.")
+@tf_export("data.experimental.unbatch")
+def unbatch():
+  """Splits elements of a dataset into multiple elements on the batch dimension.
+
+  For example, if elements of the dataset are shaped `[B, a0, a1, ...]`,
+  where `B` may vary for each input element, then for each element in the
+  dataset, the unbatched dataset will contain `B` consecutive elements
+  of shape `[a0, a1, ...]`.
+
+  ```python
+  # NOTE: The following example uses `{ ... }` to represent the contents
+  # of a dataset.
+  a = { ['a', 'b', 'c'], ['a', 'b'], ['a', 'b', 'c', 'd'] }
+
+  a.unbatch() == {
+      'a', 'b', 'c', 'a', 'b', 'a', 'b', 'c', 'd'}
+  ```
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+
+  def _apply_fn(dataset):
+    return dataset.unbatch()
+
+  return _apply_fn
+
+
+class _DenseToSparseBatchDataset(dataset_ops.UnaryDataset):
+  """A `Dataset` that batches ragged dense elements into `tf.sparse.SparseTensor`s."""
+
+  def __init__(self, input_dataset, batch_size, row_shape):
+    """See `Dataset.dense_to_sparse_batch()` for more details."""
+    if not isinstance(
+        dataset_ops.get_legacy_output_types(input_dataset), dtypes.DType):
+      raise TypeError("`dense_to_sparse_batch` requires an input dataset whose "
+                      "elements have a single component, but the given dataset "
+                      "has the following component types: "
+                      f"{dataset_ops.get_legacy_output_types(input_dataset)}.")
+    self._input_dataset = input_dataset
+    self._batch_size = batch_size
+    self._row_shape = row_shape
+    self._element_spec = sparse_tensor.SparseTensorSpec(
+        tensor_shape.TensorShape([None]).concatenate(self._row_shape),
+        dataset_ops.get_legacy_output_types(input_dataset))
+
+    variant_tensor = ged_ops.dense_to_sparse_batch_dataset(
+        self._input_dataset._variant_tensor,  # pylint: disable=protected-access
+        self._batch_size,
+        row_shape=convert.partial_shape_to_tensor(self._row_shape),
+        **self._flat_structure)
+    super(_DenseToSparseBatchDataset, self).__init__(input_dataset,
+                                                     variant_tensor)
+
+  @property
+  def element_spec(self):
+    return self._element_spec
+
+
+class _MapAndBatchDataset(dataset_ops.UnaryDataset):
+  """A `Dataset` that maps a function over a batch of elements."""
+
+  def __init__(self, input_dataset, map_func, batch_size, num_parallel_calls,
+               drop_remainder, use_legacy_function=False):
+    self._input_dataset = input_dataset
+
+    self._map_func = structured_function.StructuredFunctionWrapper(
+        map_func,
+        "tf.data.experimental.map_and_batch()",
+        dataset=input_dataset,
+        use_legacy_function=use_legacy_function)
+    self._batch_size_t = ops.convert_to_tensor(
+        batch_size, dtype=dtypes.int64, name="batch_size")
+    self._num_parallel_calls_t = ops.convert_to_tensor(
+        num_parallel_calls, dtype=dtypes.int64, name="num_parallel_calls")
+    self._drop_remainder_t = ops.convert_to_tensor(
+        drop_remainder, dtype=dtypes.bool, name="drop_remainder")
+
+    constant_drop_remainder = tensor_util.constant_value(self._drop_remainder_t)
+    # pylint: disable=protected-access
+    if constant_drop_remainder:
+      # NOTE(mrry): `constant_drop_remainder` may be `None` (unknown statically)
+      # or `False` (explicitly retaining the remainder).
+      # pylint: disable=g-long-lambda
+      self._element_spec = nest.map_structure(
+          lambda component_spec: component_spec._batch(
+              tensor_util.constant_value(self._batch_size_t)),
+          self._map_func.output_structure)
+    else:
+      self._element_spec = nest.map_structure(
+          lambda component_spec: component_spec._batch(None),
+          self._map_func.output_structure)
+    # pylint: enable=protected-access
+    variant_tensor = ged_ops.map_and_batch_dataset(
+        self._input_dataset._variant_tensor,  # pylint: disable=protected-access
+        self._map_func.function.captured_inputs,
+        f=self._map_func.function,
+        batch_size=self._batch_size_t,
+        num_parallel_calls=self._num_parallel_calls_t,
+        drop_remainder=self._drop_remainder_t,
+        preserve_cardinality=True,
+        **self._flat_structure)
+    super(_MapAndBatchDataset, self).__init__(input_dataset, variant_tensor)
+
+  def _functions(self):
+    return [self._map_func]
+
+  @property
+  def element_spec(self):
+    return self._element_spec

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/cardinality.py

@@ -0,0 +1,113 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Cardinality analysis of `Dataset` objects."""
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import gen_dataset_ops
+from tensorflow.python.ops import gen_experimental_dataset_ops as ged_ops
+from tensorflow.python.util.tf_export import tf_export
+
+
+INFINITE = -1
+UNKNOWN = -2
+tf_export("data.experimental.INFINITE_CARDINALITY").export_constant(
+    __name__, "INFINITE")
+tf_export("data.experimental.UNKNOWN_CARDINALITY").export_constant(
+    __name__, "UNKNOWN")
+
+
+# TODO(b/157691652): Deprecate this method after migrating users to the new API.
+@tf_export("data.experimental.cardinality")
+def cardinality(dataset):
+  """Returns the cardinality of `dataset`, if known.
+
+  The operation returns the cardinality of `dataset`. The operation may return
+  `tf.data.experimental.INFINITE_CARDINALITY` if `dataset` contains an infinite
+  number of elements or `tf.data.experimental.UNKNOWN_CARDINALITY` if the
+  analysis fails to determine the number of elements in `dataset` (e.g. when the
+  dataset source is a file).
+
+  >>> dataset = tf.data.Dataset.range(42)
+  >>> print(tf.data.experimental.cardinality(dataset).numpy())
+  42
+  >>> dataset = dataset.repeat()
+  >>> cardinality = tf.data.experimental.cardinality(dataset)
+  >>> print((cardinality == tf.data.experimental.INFINITE_CARDINALITY).numpy())
+  True
+  >>> dataset = dataset.filter(lambda x: True)
+  >>> cardinality = tf.data.experimental.cardinality(dataset)
+  >>> print((cardinality == tf.data.experimental.UNKNOWN_CARDINALITY).numpy())
+  True
+
+  Args:
+    dataset: A `tf.data.Dataset` for which to determine cardinality.
+
+  Returns:
+    A scalar `tf.int64` `Tensor` representing the cardinality of `dataset`. If
+    the cardinality is infinite or unknown, the operation returns the named
+    constant `INFINITE_CARDINALITY` and `UNKNOWN_CARDINALITY` respectively.
+  """
+
+  return gen_dataset_ops.dataset_cardinality(dataset._variant_tensor)  # pylint: disable=protected-access
+
+
+@tf_export("data.experimental.assert_cardinality")
+def assert_cardinality(expected_cardinality):
+  """Asserts the cardinality of the input dataset.
+
+  NOTE: The following assumes that "examples.tfrecord" contains 42 records.
+
+  >>> dataset = tf.data.TFRecordDataset("examples.tfrecord")
+  >>> cardinality = tf.data.experimental.cardinality(dataset)
+  >>> print((cardinality == tf.data.experimental.UNKNOWN_CARDINALITY).numpy())
+  True
+  >>> dataset = dataset.apply(tf.data.experimental.assert_cardinality(42))
+  >>> print(tf.data.experimental.cardinality(dataset).numpy())
+  42
+
+  Args:
+    expected_cardinality: The expected cardinality of the input dataset.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+
+  Raises:
+    FailedPreconditionError: The assertion is checked at runtime (when iterating
+      the dataset) and an error is raised if the actual and expected cardinality
+      differ.
+  """
+  def _apply_fn(dataset):
+    return _AssertCardinalityDataset(dataset, expected_cardinality)
+
+  return _apply_fn
+
+
+class _AssertCardinalityDataset(dataset_ops.UnaryUnchangedStructureDataset):
+  """A `Dataset` that assert the cardinality of its input."""
+
+  def __init__(self, input_dataset, expected_cardinality):
+    self._input_dataset = input_dataset
+    self._expected_cardinality = ops.convert_to_tensor(
+        expected_cardinality, dtype=dtypes.int64, name="expected_cardinality")
+
+    # pylint: enable=protected-access
+    variant_tensor = ged_ops.assert_cardinality_dataset(
+        self._input_dataset._variant_tensor,  # pylint: disable=protected-access
+        self._expected_cardinality,
+        **self._flat_structure)
+    super(_AssertCardinalityDataset, self).__init__(input_dataset,
+                                                    variant_tensor)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/compression_ops.py

@@ -0,0 +1,51 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Ops for compressing and uncompressing dataset elements."""
+from tensorflow.python.data.util import structure
+from tensorflow.python.ops import gen_experimental_dataset_ops as ged_ops
+
+
+def compress(element):
+  """Compress a dataset element.
+
+  Args:
+    element: A nested structure of types supported by Tensorflow.
+
+  Returns:
+    A variant tensor representing the compressed element. This variant can be
+    passed to `uncompress` to get back the original element.
+  """
+  element_spec = structure.type_spec_from_value(element)
+  tensor_list = structure.to_tensor_list(element_spec, element)
+  return ged_ops.compress_element(tensor_list)
+
+
+def uncompress(element, output_spec):
+  """Uncompress a compressed dataset element.
+
+  Args:
+    element: A scalar variant tensor to uncompress. The element should have been
+      created by calling `compress`.
+    output_spec: A nested structure of `tf.TypeSpec` representing the type(s) of
+      the uncompressed element.
+
+  Returns:
+    The uncompressed element.
+  """
+  flat_types = structure.get_flat_tensor_types(output_spec)
+  flat_shapes = structure.get_flat_tensor_shapes(output_spec)
+  tensor_list = ged_ops.uncompress_element(
+      element, output_types=flat_types, output_shapes=flat_shapes)
+  return structure.from_tensor_list(output_spec, tensor_list)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/counter.py

@@ -0,0 +1,84 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""The Counter Dataset."""
+from tensorflow.python import tf2
+from tensorflow.python.compat import v2_compat
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.framework import dtypes
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("data.experimental.Counter", v1=[])
+@deprecation.deprecated(None, "Use `tf.data.Dataset.counter(...)` instead.")
+def CounterV2(start=0, step=1, dtype=dtypes.int64):
+  """Creates a `Dataset` that counts from `start` in steps of size `step`.
+
+  Unlike `tf.data.Dataset.range` which will stop at some ending number,
+  `Counter` will produce elements indefinitely.
+
+  >>> dataset = tf.data.experimental.Counter().take(5)
+  >>> list(dataset.as_numpy_iterator())
+  [0, 1, 2, 3, 4]
+  >>> dataset.element_spec
+  TensorSpec(shape=(), dtype=tf.int64, name=None)
+  >>> dataset = tf.data.experimental.Counter(dtype=tf.int32)
+  >>> dataset.element_spec
+  TensorSpec(shape=(), dtype=tf.int32, name=None)
+  >>> dataset = tf.data.experimental.Counter(start=2).take(5)
+  >>> list(dataset.as_numpy_iterator())
+  [2, 3, 4, 5, 6]
+  >>> dataset = tf.data.experimental.Counter(start=2, step=5).take(5)
+  >>> list(dataset.as_numpy_iterator())
+  [2, 7, 12, 17, 22]
+  >>> dataset = tf.data.experimental.Counter(start=10, step=-1).take(5)
+  >>> list(dataset.as_numpy_iterator())
+  [10, 9, 8, 7, 6]
+
+  Args:
+    start: (Optional.) The starting value for the counter. Defaults to 0.
+    step: (Optional.) The step size for the counter. Defaults to 1.
+    dtype: (Optional.) The data type for counter elements. Defaults to
+      `tf.int64`.
+
+  Returns:
+    A `Dataset` of scalar `dtype` elements.
+  """
+  return dataset_ops.Dataset.counter(start, step, dtype)
+
+
+@tf_export(v1=["data.experimental.Counter"])
+@deprecation.deprecated(None, "Use `tf.data.Dataset.counter(...)` instead.")
+def CounterV1(start=0, step=1, dtype=dtypes.int64):
+  return dataset_ops.DatasetV1Adapter(CounterV2(start, step, dtype))
+
+
+CounterV1.__doc__ = CounterV2.__doc__
+
+if tf2.enabled():
+  Counter = CounterV2
+else:
+  Counter = CounterV1
+
+
+def _tf2_callback():  # pylint: disable=invalid-name
+  global Counter
+  if tf2.enabled():
+    Counter = CounterV2
+  else:
+    Counter = CounterV1
+
+
+v2_compat.register_data_v2_callback(_tf2_callback)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/distribute.py

@@ -0,0 +1,399 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Distribution Strategy-related dataset transformations."""
+
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.data.ops.options import ExternalStatePolicy
+from tensorflow.python.data.util import nest
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor_shape
+from tensorflow.python.framework import tensor_util
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import gen_experimental_dataset_ops as ged_ops
+from tensorflow.python.types import data as data_types
+from tensorflow.python.util.tf_export import tf_export
+
+SHARD_HINT = -1
+tf_export("data.experimental.SHARD_HINT").export_constant(
+    __name__, "SHARD_HINT")
+
+
+class _AutoShardDataset(dataset_ops.UnaryDataset):
+  """A `Dataset` that shards the `Dataset` automatically.
+
+  This dataset takes in an existing dataset and tries to automatically figure
+  out how to shard the dataset in a multi-worker scenario using graph rewrites.
+
+  If the AutoShardPolicy is set to FILE, it walks up the dataset graph until
+  it finds a reader dataset, then inserts a ShardDataset op before that node
+  so that each worker only sees some files.
+
+  If the AutoShardPolicy is set to DATA, it inserts a ShardDataset op at the
+  end of the input pipeline, before any terminal PrefetchDataset if there is
+  one. Additionally, if there is a RebatchDatasetV2 in the input pipeline, it
+  is written to legacy RebatchDataset for correctness reasons, since
+  RebatchDatasetV2 is incompatible with data sharding.
+
+  If the AutoShardPolicy is set to AUTO, it tries to do file-based sharding.
+  If it cannot find a reader dataset, it falls back to doing data-based
+  sharding.
+
+  If the AutoShardPolicy is set to OFF, it does nothing.
+
+  Attributes:
+    num_workers: Total number of workers to shard this dataset across.
+    index: The current worker index (out of the total number of workers) this
+      dataset is for.
+    num_replicas: The total number of replicas across all workers. This is used
+      only when sharding by data (either DATA or AUTO) in order to rewrite
+      RebatchDatasetV2 to RebatchDataset.
+
+  Raises:
+    NotFoundError: If we cannot find a suitable reader dataset to begin
+      automatically sharding the dataset.
+  """
+
+  def __init__(self, input_dataset, num_workers, index, num_replicas=None):
+    self._input_dataset = input_dataset
+
+    self._element_spec = input_dataset.element_spec
+    variant_tensor = ged_ops.auto_shard_dataset(
+        self._input_dataset._variant_tensor,  # pylint: disable=protected-access
+        num_workers=num_workers,
+        index=index,
+        auto_shard_policy=int(
+            input_dataset.options().experimental_distribute.auto_shard_policy),
+        num_replicas=num_replicas,
+        **self._flat_structure)
+    super(_AutoShardDataset, self).__init__(input_dataset, variant_tensor)
+
+  @property
+  def element_spec(self):
+    return self._element_spec
+
+
+def _AutoShardDatasetV1(input_dataset, num_workers, index, num_replicas=None):  # pylint: disable=invalid-name
+  return dataset_ops.DatasetV1Adapter(
+      _AutoShardDataset(input_dataset, num_workers, index, num_replicas))
+
+
+class _LegacyRebatchDataset(dataset_ops.UnaryDataset):
+  """A `Dataset` that divides its input batches into `num_replicas` sub-batches.
+
+  For each batch in the input dataset, _LegacyRebatchDataset will produce
+  `num_replicas` smaller batches whose sizes add up to the original batch size.
+
+  For example:
+
+  ```python
+  ds = tf.data.Dataset.range(8)
+  ds = ds.batch(4)
+  ds = _LegacyRebatchDataset(ds, num_replicas=3)
+  for elem in ds:
+    print(elem)
+  >> [0, 1], [2, 3], [], [4, 5], [6, 7], []
+  ```
+  """
+
+  def __init__(self, input_dataset, num_replicas):
+    """Creates a _LegacyRebatchDataset.
+
+    Args:
+      input_dataset: `Dataset` to rebatch.
+      num_replicas: A `tf.int64` scalar, representing the number of sub-batches
+        to split each batch from `input_dataset` into.
+    """
+
+    def recalculate_batch_size(type_spec):
+      """Recalculates the output_shape after dividing it by num_replicas."""
+      output_shape = type_spec._to_legacy_output_shapes()  # pylint: disable=protected-access
+      if not isinstance(output_shape, tensor_shape.TensorShape):
+        return None
+
+      # If the output shape is unknown, we set the batch dimension to unknown.
+      if output_shape.rank is None:
+        return None
+
+      if len(output_shape) < 1:
+        raise ValueError(
+            "Invalid `input_dataset`. Expected a dataset whose elements "
+            "have rank >= 1 but found a dataset whose elements are scalars. "
+            "Fix the issue by adding the `batch` transformation to the "
+            "dataset.")
+      output_dims = [d.value for d in output_shape.dims]
+
+      if output_dims[0] is not None and output_dims[0] % num_replicas == 0:
+        return output_dims[0] // num_replicas
+
+      # Set the batch dimension to unknown. If the global batch size does not
+      # divide num_replicas evenly, the minibatches may have different sizes.
+      return None
+
+    def rebatch(type_spec):
+      # pylint: disable=protected-access
+      batch_size = recalculate_batch_size(type_spec)
+      return type_spec._unbatch()._batch(batch_size)
+      # pylint: enable=protected-access
+
+    self._element_spec = nest.map_structure(
+        rebatch, dataset_ops.get_structure(input_dataset))
+
+    # auto_shard rewrite assumes that there's normalize_to_dense before
+    # rebatch_dataset.
+    # LINT.IfChange
+    input_dataset = dataset_ops.normalize_to_dense(input_dataset)
+    variant_tensor = ged_ops.rebatch_dataset(
+        input_dataset._variant_tensor,  # pylint: disable=protected-access
+        num_replicas=num_replicas,
+        **self._flat_structure)
+    # LINT.ThenChange(//tensorflow/core/grappler/optimizers/data/auto_shard.cc)
+    super(_LegacyRebatchDataset, self).__init__(input_dataset, variant_tensor)
+
+  @property
+  def element_spec(self):
+    return self._element_spec
+
+
+class _RemoteDataset(dataset_ops.DatasetSource):
+  """Creates a dataset on a given `device` given a graph def."""
+
+  def __init__(self, graph_def, device, element_spec):
+    self._elem_spec = element_spec
+    with ops.device(device):
+      variant_tensor = ged_ops.dataset_from_graph(graph_def)
+    super(_RemoteDataset, self).__init__(variant_tensor)
+
+  @property
+  def element_spec(self):
+    return self._elem_spec
+
+
+def replicate(dataset, devices):
+  """A transformation that replicates `dataset` onto a list of devices.
+
+  Args:
+    dataset: A `tf.data.Dataset` object.
+    devices: A list of devices to replicate the dataset on.
+
+  Returns:
+    A dictionary mapping device name to a dataset on that device.
+  """
+  if not isinstance(dataset, data_types.DatasetV2):
+    raise TypeError(
+        f"Invalid `dataset`. Expected a `tf.data.Dataset` object but "
+        f"got {type(dataset)}.")
+
+  # pylint: disable=protected-access
+  dataset_device = dataset._variant_tensor.device
+
+  datasets = {}
+  if len(devices) == 1 and devices[0] == dataset_device:
+    datasets[devices[0]] = dataset
+    return datasets
+
+  with ops.colocate_with(dataset._variant_tensor):
+    dataset = dataset._apply_debug_options()
+    graph_def = dataset._as_serialized_graph(
+        strip_device_assignment=True,
+        external_state_policy=ExternalStatePolicy.WARN)
+  for device in devices:
+    ds = _RemoteDataset(graph_def, device, dataset.element_spec)
+    datasets[device] = ds
+  return datasets
+
+
+def batch_sizes_for_worker(global_batch_size, num_workers,
+                           num_replicas_per_worker, worker_index):
+  """Determines how to rebatch a dataset for the given worker.
+
+  Given the global batch size, number of workers, number of replicas per worker,
+  and worker index, returns the correct batch sizes for rebatching a dataset
+  on worker `worker_index` of `num_workers`, such that each global step (across
+  all workers and replicas) will consume global_batch_size elements. The
+  returned value should be passed as the `batch_sizes` input parameter to
+  `tf.data.experimental.rebatch()`. The returned batch sizes meet the following
+  constraints:
+
+  Let G = global_batch_size, W = num_workers, R = num_replicas_per_worker
+  (A) for any worker, len(batch_sizes) = W * R
+  (B) for any worker, sum(batch_sizes) == G
+  (C) for any global step (i.e. R iterations on each worker), the sum of batches
+      consumed by replicas across all workers is G.
+  (D) any two batch sizes of any two replicas differs by at most one.
+
+  For example, suppose we have G = 7, W = 2, R = 2, and suppose we have two
+  files which each contain 7 elements:
+
+  ```python
+  # WORKER 0
+  batch_sizes_0 = batch_sizes_for_worker(global_batch_size=global_batch_size,
+                                         num_workers=2,
+                                         num_replicas_per_worker=2,
+                                         worker_index=0)
+  print(batch_sizes_0)
+  >> [2, 2, 2, 1]
+
+  dataset_0 = tf.data.Dataset.from_tensor_slices(["file_a", "file_b"])
+  dataset_0 = dataset_0.shard(num_shards, index=0)
+  dataset_0 = dataset_0.batch(7)
+  dataset_0 = dataset_0.apply(tf.data.experimental.rebatch(batch_sizes_0))
+  for elem in dataset_0:
+    print(elem)
+  >> [[A0, A1], [A2, A3], [A4, A5], [A6]]
+
+  # WORKER 1
+  batch_sizes_1 = batch_sizes_for_worker(global_batch_size=global_batch_size,
+                                         num_workers=2,
+                                         num_replicas_per_worker=2,
+                                         worker_index=1)
+  print(batch_sizes_1)
+  >> [2, 1, 2, 2]
+
+  dataset_1 = tf.data.Dataset.from_tensor_slices(["file_a", "file_b"])
+  dataset_1 = dataset_1.shard(num_shards, index=1)
+  dataset_1 = dataset_1.batch(7)
+  dataset_1 = dataset_1.apply(tf.data.experimental.rebatch(batch_sizes_1))
+  for elem in dataset_1:
+    print(elem)
+  >> [[B0, B1], [B2], [B3, B4], [B5, B6]]
+  ```
+
+  The above example will produce the following elements:
+
+  Step 1:
+    Worker 0 Replica 0: [A0, A1]
+    Worker 0 Replica 1: [A2, A3]
+    Worker 1 Replica 0: [B0, B1]
+    Worker 1 Replica 1: [B2]
+  Total batch size = 7
+
+  Step 2:
+    Worker 0 Replica 0: [A4, A5]
+    Worker 0 Replica 1: [A6]
+    Worker 1 Replica 0: [B3, B4]
+    Worker 1 Replica 1: [B5, B6]
+  Total batch size = 7
+
+  Args:
+    global_batch_size: A `tf.int64` scalar, representing the global batch size.
+    num_workers: An integer representing the number of workers the dataset will
+      be distributed across.
+    num_replicas_per_worker: An integer representing the number of replicas per
+      worker. All workers are assumed to have the same number of replicas.
+    worker_index: An integer index of the worker to be rebatched.
+
+  Returns:
+    A `tf.int64` vector, representing the batch sizes to rebatch the dataset
+    into.
+  """
+  # Constraint (A)
+  num_subbatches = num_workers * num_replicas_per_worker
+
+  offset = worker_index * num_replicas_per_worker
+
+  const_value = tensor_util.constant_value(global_batch_size)
+  if const_value is not None:
+    # Use the constant global batch size for further calculations
+    global_batch_size = const_value
+
+  # Let N = W * R. Constraint (B) and (D) jointly mean that the iterations
+  # should have batch size either floor(B/N) or ceil(B/N). Namely, of the N
+  # subbatches a batch is split into, B - N * floor(B/N) of them will have size
+  # ceil(B/N), and the rest will have size floor(B/N).
+  floor = global_batch_size // num_subbatches
+  num_ceil = global_batch_size - (num_subbatches * floor)
+
+  # For worker 0, we assign the first num_ceil subbatches to have size
+  # ceil(B/N), and the remainder to have size floor(B/N). The other workers will
+  # each be offset by R * worker_index in order to meet constraint (C).
+  if const_value is not None:
+    # If the global batch size is a known constant value, we return a constant
+    # tensor directly instead of manipulating it with TF ops. This allows for
+    # better downstream shape inference.
+    worker_0 = [floor + 1] * num_ceil + [floor] * (num_subbatches - num_ceil)
+    return ops.convert_to_tensor(
+        worker_0[offset:] + worker_0[:offset],
+        dtype=dtypes.int64,
+        name="batch_sizes")
+
+  worker_0 = array_ops.ones(num_subbatches, dtype=dtypes.int64)
+  worker_0 = floor * worker_0 + array_ops.concat([
+      array_ops.ones(num_ceil, dtype=dtypes.int64),
+      array_ops.zeros(num_subbatches - num_ceil, dtype=dtypes.int64)
+  ],
+                                                 axis=0)
+
+  return array_ops.concat([worker_0[offset:], worker_0[:offset]], axis=0)
+
+
+def compute_batch_size(dataset):
+  """An operation that returns the batch size of the dataset.
+
+  This op tries to infer the batch size statically by walking up the dataset
+  tree from the final dataset node and returning the batch size of the first
+  batching dataset (such as from .batch() and .padded_batch()) that it
+  encounters. This differs from using the `element_spec` of a dataset in that it
+  does not account for partial batches.
+
+  This operation may fail if it encounters contradictory batch sizes (for
+  example, if the dataset is created by zipping together two datasets with
+  different batch sizes), if there are no explicit batching transformations, or
+  if there are operations downstream from the batching transformation that may
+  modify its batch size. In these cases, it returns a -1.
+
+  Args:
+    dataset: A `tf.data.Dataset` object.
+
+  Returns:
+    A `tf.int64` Tensor representing the batch size of the dataset sans partial
+    batches. If this cannot be inferred statically, the value of this tensor
+    will be -1.
+  """
+
+  def get_static_batch_dim(type_spec):
+    try:
+      output_shape = type_spec._to_legacy_output_shapes()  # pylint: disable=protected-access
+    except NotImplementedError:
+      return None
+    if not isinstance(output_shape, tensor_shape.TensorShape):
+      return None
+    if output_shape.rank is None:
+      return None
+    return output_shape.dims[0].value
+
+  batch_dims = [
+      get_static_batch_dim(type_spec)
+      for type_spec in nest.flatten(dataset_ops.get_structure(dataset))
+  ]
+
+  if all(d is not None for d in batch_dims):
+
+    if all(d == batch_dims[0] for d in batch_dims):
+      # If all batch dimensions are known and equal, return that directly.
+      batch_dim = batch_dims[0]
+    else:
+      # If all batch dimensions are known but not all equal, return -1.
+      batch_dim = -1
+
+    return constant_op.constant(
+        batch_dim, dtype=dtypes.int64, name="static_batch_size")
+
+  # If any batch dimensions are unknown, use compute_batch_size op.
+  return ged_ops.compute_batch_size(dataset._variant_tensor)  # pylint: disable=protected-access
+
+
+_AutoShardDatasetV1.__doc__ = _AutoShardDataset.__doc__

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/distributed_save_op.py

@@ -0,0 +1,61 @@
+# Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Distributed saving of a dataset to disk."""
+
+from tensorflow.core.protobuf import snapshot_pb2
+from tensorflow.python.ops import gen_experimental_dataset_ops
+# TODO(b/238903802): Use TypeSpec serialization methods directly.
+from tensorflow.python.saved_model import nested_structure_coder
+
+
+# TODO(b/250921378): Add example to docstring and export to TF API.
+def distributed_save(dataset, path, dispatcher_address, compression="AUTO"):
+  """Initiates the process of distributedly saving a dataset to disk.
+
+  Args:
+    dataset: The `tf.data.Dataset` to save.
+    path: A string indicating the filepath of the directory to which to save
+      `dataset`.
+    dispatcher_address: A string indicating the address of the dispatcher for
+      the tf.data service instance used to save `dataset`.
+    compression: (Optional.) A string indicating whether and how to compress the
+      `dataset` materialization.  If `"AUTO"`, the tf.data runtime decides which
+      algorithm to use.  If `"GZIP"` or `"SNAPPY"`, that specific algorithm is
+      used.  If `None`, the `dataset` materialization is not compressed.
+
+  Returns:
+    An operation which when executed performs the distributed save.
+
+  Raises:
+    ValueError: If `dispatcher_address` is invalid.
+  """
+  if not isinstance(dispatcher_address, str):
+    raise ValueError("`dispatcher_address` must be a string, but is a "
+                     f"{type(dispatcher_address)} ({dispatcher_address}")
+  if not dispatcher_address:
+    raise ValueError("`dispatcher_address` must not be empty")
+
+  metadata = snapshot_pb2.DistributedSnapshotMetadata(
+      element_spec=nested_structure_coder.encode_structure(
+          dataset.element_spec).SerializeToString(),
+      compression=compression,
+  )
+
+  return gen_experimental_dataset_ops.distributed_save(
+      dataset._variant_tensor,  # pylint: disable=protected-access
+      directory=path,
+      address=dispatcher_address,
+      metadata=metadata.SerializeToString(),
+  )

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/enumerate_ops.py

@@ -0,0 +1,54 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Enumerate dataset transformations."""
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@deprecation.deprecated(None, "Use `tf.data.Dataset.enumerate()`.")
+@tf_export("data.experimental.enumerate_dataset")
+def enumerate_dataset(start=0):
+  """A transformation that enumerates the elements of a dataset.
+
+  It is similar to python's `enumerate`.
+  For example:
+
+  ```python
+  # NOTE: The following examples use `{ ... }` to represent the
+  # contents of a dataset.
+  a = { 1, 2, 3 }
+  b = { (7, 8), (9, 10) }
+
+  # The nested structure of the `datasets` argument determines the
+  # structure of elements in the resulting dataset.
+  a.apply(tf.data.experimental.enumerate_dataset(start=5))
+  => { (5, 1), (6, 2), (7, 3) }
+  b.apply(tf.data.experimental.enumerate_dataset())
+  => { (0, (7, 8)), (1, (9, 10)) }
+  ```
+
+  Args:
+    start: A `tf.int64` scalar `tf.Tensor`, representing the start value for
+      enumeration.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+
+  def _apply_fn(dataset):
+    return dataset.enumerate(start)
+
+  return _apply_fn

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/from_list.py

@@ -0,0 +1,119 @@
+# Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python API for creating a dataset from a list."""
+
+import itertools
+
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.data.util import nest
+from tensorflow.python.data.util import structure
+from tensorflow.python.ops import gen_experimental_dataset_ops
+from tensorflow.python.util.tf_export import tf_export
+
+
+class _ListDataset(dataset_ops.DatasetSource):
+  """A `Dataset` of elements from a list."""
+
+  def __init__(self, elements, name=None):
+    if not elements:
+      raise ValueError("Invalid `elements`. `elements` should not be empty.")
+    if not isinstance(elements, list):
+      raise ValueError("Invalid `elements`. `elements` must be a list.")
+
+    elements = [structure.normalize_element(element) for element in elements]
+    type_specs = [
+        structure.type_spec_from_value(element) for element in elements
+    ]
+
+    # Check that elements have same nested structure.
+    num_elements = len(elements)
+    for i in range(1, num_elements):
+      nest.assert_same_structure(type_specs[0], type_specs[i])
+
+    # Infer elements' supershape.
+    flattened_type_specs = [nest.flatten(type_spec) for type_spec in type_specs]
+    num_tensors_per_element = len(flattened_type_specs[0])
+    flattened_structure = [None] * num_tensors_per_element
+    for i in range(num_tensors_per_element):
+      flattened_structure[i] = flattened_type_specs[0][i]
+      for j in range(1, num_elements):
+        flattened_structure[i] = flattened_structure[
+            i].most_specific_common_supertype([flattened_type_specs[j][i]])
+
+    if not isinstance(type_specs[0], dataset_ops.DatasetSpec):
+      self._tensors = list(
+          itertools.chain.from_iterable(
+              [nest.flatten(element) for element in elements]))
+    else:
+      self._tensors = [x._variant_tensor for x in elements]
+    self._structure = nest.pack_sequence_as(type_specs[0], flattened_structure)
+    self._name = name
+    variant_tensor = gen_experimental_dataset_ops.list_dataset(
+        self._tensors,
+        output_types=self._flat_types,
+        output_shapes=self._flat_shapes,
+        metadata=self._metadata.SerializeToString())
+    super(_ListDataset, self).__init__(variant_tensor)
+
+  @property
+  def element_spec(self):
+    return self._structure
+
+
+@tf_export("data.experimental.from_list")
+def from_list(elements, name=None):
+  """Creates a `Dataset` comprising the given list of elements.
+
+  The returned dataset will produce the items in the list one by one. The
+  functionality is identical to `Dataset.from_tensor_slices` when elements are
+  scalars, but different when elements have structure. Consider the following
+  example.
+
+  >>> dataset = tf.data.experimental.from_list([(1, 'a'), (2, 'b'), (3, 'c')])
+  >>> list(dataset.as_numpy_iterator())
+  [(1, b'a'), (2, b'b'), (3, b'c')]
+
+  To get the same output with `from_tensor_slices`, the data needs to be
+  reorganized:
+
+  >>> dataset = tf.data.Dataset.from_tensor_slices(([1, 2, 3], ['a', 'b', 'c']))
+  >>> list(dataset.as_numpy_iterator())
+  [(1, b'a'), (2, b'b'), (3, b'c')]
+
+  Unlike `from_tensor_slices`, `from_list` supports non-rectangular input:
+
+  >>> dataset = tf.data.experimental.from_list([[1], [2, 3]])
+  >>> list(dataset.as_numpy_iterator())
+  [array([1], dtype=int32), array([2, 3], dtype=int32)]
+
+  Achieving the same with `from_tensor_slices` requires the use of ragged
+  tensors.
+
+  `from_list` can be more performant than `from_tensor_slices` in some cases,
+  since it avoids the need for data slicing each epoch. However, it can also be
+  less performant, because data is stored as many small tensors rather than a
+  few large tensors as in `from_tensor_slices`. The general guidance is to
+  prefer `from_list` from a performance perspective when the number of elements
+  is small (less than 1000).
+
+  Args:
+    elements: A list of elements whose components have the same nested
+      structure.
+    name: (Optional.) A name for the tf.data operation.
+
+  Returns:
+    Dataset: A `Dataset` of the `elements`.
+  """
+  return _ListDataset(elements, name)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/interleave_ops.py

@@ -0,0 +1,261 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Non-deterministic dataset transformations."""
+from tensorflow.python import tf2
+from tensorflow.python.compat import v2_compat
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.data.ops import readers
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@deprecation.deprecated(
+    None,
+    "Use `tf.data.Dataset.interleave(map_func, cycle_length, block_length, "
+    "num_parallel_calls=tf.data.AUTOTUNE)` instead. If sloppy "
+    "execution is desired, use `tf.data.Options.deterministic`.")
+@tf_export("data.experimental.parallel_interleave")
+def parallel_interleave(map_func,
+                        cycle_length,
+                        block_length=1,
+                        sloppy=False,
+                        buffer_output_elements=None,
+                        prefetch_input_elements=None):
+  """A parallel version of the `Dataset.interleave()` transformation.
+
+  `parallel_interleave()` maps `map_func` across its input to produce nested
+  datasets, and outputs their elements interleaved. Unlike
+  `tf.data.Dataset.interleave`, it gets elements from `cycle_length` nested
+  datasets in parallel, which increases the throughput, especially in the
+  presence of stragglers. Furthermore, the `sloppy` argument can be used to
+  improve performance, by relaxing the requirement that the outputs are produced
+  in a deterministic order, and allowing the implementation to skip over nested
+  datasets whose elements are not readily available when requested.
+
+  Example usage:
+
+  ```python
+  # Preprocess 4 files concurrently.
+  filenames = tf.data.Dataset.list_files("/path/to/data/train*.tfrecords")
+  dataset = filenames.apply(
+      tf.data.experimental.parallel_interleave(
+          lambda filename: tf.data.TFRecordDataset(filename),
+          cycle_length=4))
+  ```
+
+  WARNING: If `sloppy` is `True`, the order of produced elements is not
+  deterministic.
+
+  Args:
+    map_func: A function mapping a nested structure of tensors to a `Dataset`.
+    cycle_length: The number of input `Dataset`s to interleave from in parallel.
+    block_length: The number of consecutive elements to pull from an input
+      `Dataset` before advancing to the next input `Dataset`.
+    sloppy: A boolean controlling whether determinism should be traded for
+      performance by allowing elements to be produced out of order.  If `sloppy`
+      is `None`, the `tf.data.Options.deterministic` dataset option (`True` by
+      default) is used to decide whether to enforce a deterministic order.
+    buffer_output_elements: The number of elements each iterator being
+      interleaved should buffer (similar to the `.prefetch()` transformation for
+      each interleaved iterator).
+    prefetch_input_elements: The number of input elements to transform to
+      iterators before they are needed for interleaving.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+
+  def _apply_fn(dataset):
+    return readers.ParallelInterleaveDataset(dataset, map_func, cycle_length,
+                                             block_length, sloppy,
+                                             buffer_output_elements,
+                                             prefetch_input_elements)
+
+  return _apply_fn
+
+
+@deprecation.deprecated(None,
+                        "Use `tf.data.Dataset.sample_from_datasets(...)`.")
+@tf_export("data.experimental.sample_from_datasets", v1=[])
+def sample_from_datasets_v2(datasets,
+                            weights=None,
+                            seed=None,
+                            stop_on_empty_dataset=False):
+  """Samples elements at random from the datasets in `datasets`.
+
+  Creates a dataset by interleaving elements of `datasets` with `weight[i]`
+  probability of picking an element from dataset `i`. Sampling is done without
+  replacement. For example, suppose we have 2 datasets:
+
+  ```python
+  dataset1 = tf.data.Dataset.range(0, 3)
+  dataset2 = tf.data.Dataset.range(100, 103)
+  ```
+
+  Suppose also that we sample from these 2 datasets with the following weights:
+
+  ```python
+  sample_dataset = tf.data.Dataset.sample_from_datasets(
+      [dataset1, dataset2], weights=[0.5, 0.5])
+  ```
+
+  One possible outcome of elements in sample_dataset is:
+
+  ```
+  print(list(sample_dataset.as_numpy_iterator()))
+  # [100, 0, 1, 101, 2, 102]
+  ```
+
+  Args:
+    datasets: A non-empty list of `tf.data.Dataset` objects with compatible
+      structure.
+    weights: (Optional.) A list or Tensor of `len(datasets)` floating-point
+      values where `weights[i]` represents the probability to sample from
+      `datasets[i]`, or a `tf.data.Dataset` object where each element is such a
+      list. Defaults to a uniform distribution across `datasets`.
+    seed: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the random
+      seed that will be used to create the distribution. See
+      `tf.random.set_seed` for behavior.
+    stop_on_empty_dataset: If `True`, sampling stops if it encounters an empty
+      dataset. If `False`, it skips empty datasets. It is recommended to set it
+      to `True`. Otherwise, the distribution of samples starts off as the user
+      intends, but may change as input datasets become empty. This can be
+      difficult to detect since the dataset starts off looking correct. Default
+      to `False` for backward compatibility.
+
+  Returns:
+    A dataset that interleaves elements from `datasets` at random, according to
+    `weights` if provided, otherwise with uniform probability.
+
+  Raises:
+    TypeError: If the `datasets` or `weights` arguments have the wrong type.
+    ValueError:
+      - If `datasets` is empty, or
+      - If `weights` is specified and does not match the length of `datasets`.
+  """
+  return dataset_ops.Dataset.sample_from_datasets(
+      datasets=datasets,
+      weights=weights,
+      seed=seed,
+      stop_on_empty_dataset=stop_on_empty_dataset)
+
+
+@deprecation.deprecated(None,
+                        "Use `tf.data.Dataset.sample_from_datasets(...)`.")
+@tf_export(v1=["data.experimental.sample_from_datasets"])
+def sample_from_datasets_v1(datasets,
+                            weights=None,
+                            seed=None,
+                            stop_on_empty_dataset=False):
+  return dataset_ops.DatasetV1Adapter(
+      sample_from_datasets_v2(datasets, weights, seed, stop_on_empty_dataset))
+
+
+sample_from_datasets_v1.__doc__ = sample_from_datasets_v2.__doc__
+
+
+@deprecation.deprecated(
+    None, "Use `tf.data.Dataset.choose_from_datasets(...)` instead. Note that, "
+    "unlike the experimental endpoint, the non-experimental endpoint "
+    "sets `stop_on_empty_dataset=True` by default. You should set this "
+    "argument explicitly in case you would like to match the behavior of the "
+    "experimental endpoint.")
+@tf_export("data.experimental.choose_from_datasets", v1=[])
+def choose_from_datasets_v2(datasets,
+                            choice_dataset,
+                            stop_on_empty_dataset=False):
+  """Creates a dataset that deterministically chooses elements from `datasets`.
+
+  For example, given the following datasets:
+
+  ```python
+  datasets = [tf.data.Dataset.from_tensors("foo").repeat(),
+              tf.data.Dataset.from_tensors("bar").repeat(),
+              tf.data.Dataset.from_tensors("baz").repeat()]
+
+  # Define a dataset containing `[0, 1, 2, 0, 1, 2, 0, 1, 2]`.
+  choice_dataset = tf.data.Dataset.range(3).repeat(3)
+
+  result = tf.data.experimental.choose_from_datasets(datasets, choice_dataset)
+  ```
+
+  The elements of `result` will be:
+
+  ```
+  "foo", "bar", "baz", "foo", "bar", "baz", "foo", "bar", "baz"
+  ```
+
+  Args:
+    datasets: A non-empty list of `tf.data.Dataset` objects with compatible
+      structure.
+    choice_dataset: A `tf.data.Dataset` of scalar `tf.int64` tensors between `0`
+      and `len(datasets) - 1`.
+    stop_on_empty_dataset: If `True`, selection stops if it encounters an empty
+      dataset. If `False`, it skips empty datasets. It is recommended to set it
+      to `True`. Otherwise, the selected elements start off as the user intends,
+      but may change as input datasets become empty. This can be difficult to
+      detect since the dataset starts off looking correct. Default to `False`
+      for backward compatibility.
+
+  Returns:
+    A dataset that interleaves elements from `datasets` according to the values
+    of `choice_dataset`.
+
+  Raises:
+    TypeError: If `datasets` or `choice_dataset` has the wrong type.
+    ValueError: If `datasets` is empty.
+  """
+  return dataset_ops.Dataset.choose_from_datasets(
+      datasets=datasets,
+      choice_dataset=choice_dataset,
+      stop_on_empty_dataset=stop_on_empty_dataset)
+
+
+@deprecation.deprecated(
+    None, "Use `tf.data.Dataset.choose_from_datasets(...)` instead. Note that, "
+    "unlike the experimental endpoint, the non-experimental endpoint "
+    "sets `stop_on_empty_dataset=True` by default. You should set this "
+    "argument explicitly in case you would like to match the behavior of the "
+    "experimental endpoint.")
+@tf_export(v1=["data.experimental.choose_from_datasets"])
+def choose_from_datasets_v1(datasets,
+                            choice_dataset,
+                            stop_on_empty_dataset=False):
+  return dataset_ops.DatasetV1Adapter(
+      choose_from_datasets_v2(datasets, choice_dataset, stop_on_empty_dataset))
+
+
+choose_from_datasets_v1.__doc__ = choose_from_datasets_v2.__doc__
+
+if tf2.enabled():
+  choose_from_datasets = choose_from_datasets_v2
+  sample_from_datasets = sample_from_datasets_v2
+else:
+  choose_from_datasets = choose_from_datasets_v1
+  sample_from_datasets = sample_from_datasets_v1
+
+
+def _tf2_callback():
+  global choose_from_datasets, sample_from_datasets
+  if tf2.enabled():
+    choose_from_datasets = choose_from_datasets_v2
+    sample_from_datasets = sample_from_datasets_v2
+  else:
+    choose_from_datasets = choose_from_datasets_v1
+    sample_from_datasets = sample_from_datasets_v1
+
+
+v2_compat.register_data_v2_callback(_tf2_callback)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/io.py

@@ -0,0 +1,166 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python API for save and loading a dataset."""
+
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+COMPRESSION_GZIP = "GZIP"
+COMPRESSION_SNAPPY = "NONE"
+DATASET_SPEC_FILENAME = "dataset_spec.pb"
+
+
+@tf_export("data.experimental.save", v1=[])
+@deprecation.deprecated(None, "Use `tf.data.Dataset.save(...)` instead.")
+def save(dataset,
+         path,
+         compression=None,
+         shard_func=None,
+         checkpoint_args=None):
+  """Saves the content of the given dataset.
+
+  Example usage:
+
+  >>> import tempfile
+  >>> path = os.path.join(tempfile.gettempdir(), "saved_data")
+  >>> # Save a dataset
+  >>> dataset = tf.data.Dataset.range(2)
+  >>> tf.data.experimental.save(dataset, path)
+  >>> new_dataset = tf.data.experimental.load(path)
+  >>> for elem in new_dataset:
+  ...   print(elem)
+  tf.Tensor(0, shape=(), dtype=int64)
+  tf.Tensor(1, shape=(), dtype=int64)
+
+  The saved dataset is saved in multiple file "shards". By default, the dataset
+  output is divided to shards in a round-robin fashion but custom sharding can
+  be specified via the `shard_func` function. For example, you can save the
+  dataset to using a single shard as follows:
+
+  ```python
+  dataset = make_dataset()
+  def custom_shard_func(element):
+    return np.int64(0)
+  dataset = tf.data.experimental.save(
+      path="/path/to/data", ..., shard_func=custom_shard_func)
+  ```
+
+  To enable checkpointing, pass in `checkpoint_args` to the `save` method
+  as follows:
+
+  ```python
+  dataset = tf.data.Dataset.range(100)
+  save_dir = "..."
+  checkpoint_prefix = "..."
+  step_counter = tf.Variable(0, trainable=False)
+  checkpoint_args = {
+    "checkpoint_interval": 50,
+    "step_counter": step_counter,
+    "directory": checkpoint_prefix,
+    "max_to_keep": 20,
+  }
+  dataset.save(dataset, save_dir, checkpoint_args=checkpoint_args)
+  ```
+
+  NOTE: The directory layout and file format used for saving the dataset is
+  considered an implementation detail and may change. For this reason, datasets
+  saved through `tf.data.experimental.save` should only be consumed through
+  `tf.data.experimental.load`, which is guaranteed to be backwards compatible.
+
+  Args:
+    dataset: The dataset to save.
+    path: Required. A directory to use for saving the dataset.
+    compression: Optional. The algorithm to use to compress data when writing
+      it. Supported options are `GZIP` and `NONE`. Defaults to `NONE`.
+    shard_func: Optional. A function to control the mapping of dataset elements
+      to file shards. The function is expected to map elements of the input
+      dataset to int64 shard IDs. If present, the function will be traced and
+      executed as graph computation.
+    checkpoint_args: Optional args for checkpointing which will be passed into
+      the `tf.train.CheckpointManager`. If `checkpoint_args` are not specified,
+      then checkpointing will not be performed. The `save()` implementation
+      creates a `tf.train.Checkpoint` object internally, so users should not
+      set the `checkpoint` argument in `checkpoint_args`.
+
+  Returns:
+    An operation which when executed performs the save. When writing
+    checkpoints, returns None. The return value is useful in unit tests.
+
+  Raises:
+    ValueError if `checkpoint` is passed into `checkpoint_args`.
+  """
+  return dataset.save(path, compression, shard_func, checkpoint_args)
+
+
+@tf_export("data.experimental.load", v1=[])
+@deprecation.deprecated(None, "Use `tf.data.Dataset.load(...)` instead.")
+def load(path, element_spec=None, compression=None, reader_func=None):
+  """Loads a previously saved dataset.
+
+  Example usage:
+
+  >>> import tempfile
+  >>> path = os.path.join(tempfile.gettempdir(), "saved_data")
+  >>> # Save a dataset
+  >>> dataset = tf.data.Dataset.range(2)
+  >>> tf.data.experimental.save(dataset, path)
+  >>> new_dataset = tf.data.experimental.load(path)
+  >>> for elem in new_dataset:
+  ...   print(elem)
+  tf.Tensor(0, shape=(), dtype=int64)
+  tf.Tensor(1, shape=(), dtype=int64)
+
+
+  If the default option of sharding the saved dataset was used, the element
+  order of the saved dataset will be preserved when loading it.
+
+  The `reader_func` argument can be used to specify a custom order in which
+  elements should be loaded from the individual shards. The `reader_func` is
+  expected to take a single argument -- a dataset of datasets, each containing
+  elements of one of the shards -- and return a dataset of elements. For
+  example, the order of shards can be shuffled when loading them as follows:
+
+  ```python
+  def custom_reader_func(datasets):
+    datasets = datasets.shuffle(NUM_SHARDS)
+    return datasets.interleave(lambda x: x, num_parallel_calls=AUTOTUNE)
+
+  dataset = tf.data.experimental.load(
+      path="/path/to/data", ..., reader_func=custom_reader_func)
+  ```
+
+  Args:
+    path: Required. A path pointing to a previously saved dataset.
+    element_spec: Optional. A nested structure of `tf.TypeSpec` objects matching
+      the structure of an element of the saved dataset and specifying the type
+      of individual element components. If not provided, the nested structure of
+      `tf.TypeSpec` saved with the saved dataset is used. Note that this
+      argument is required in graph mode.
+    compression: Optional. The algorithm to use to decompress the data when
+      reading it. Supported options are `GZIP` and `NONE`. Defaults to `NONE`.
+    reader_func: Optional. A function to control how to read data from shards.
+      If present, the function will be traced and executed as graph computation.
+
+  Returns:
+    A `tf.data.Dataset` instance.
+
+  Raises:
+    FileNotFoundError: If `element_spec` is not specified and the saved nested
+      structure of `tf.TypeSpec` can not be located with the saved dataset.
+    ValueError: If `element_spec` is not specified and the method is executed
+      in graph mode.
+  """
+  return dataset_ops.Dataset.load(path, element_spec, compression, reader_func)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/iterator_ops.py

@@ -0,0 +1,97 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Iterator ops."""
+
+from tensorflow.python.data.ops import iterator_ops
+from tensorflow.python.data.ops import options as options_lib
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+def _convert_external_state_policy_to_enum(external_state_policy):
+  if isinstance(external_state_policy, options_lib.ExternalStatePolicy):
+    return external_state_policy
+  if external_state_policy == "warn":
+    return options_lib.ExternalStatePolicy.WARN
+  if external_state_policy == "ignore":
+    return options_lib.ExternalStatePolicy.IGNORE
+  if external_state_policy == "fail":
+    return options_lib.ExternalStatePolicy.FAIL
+  raise ValueError(
+      f"Invalid `ExternalStatePolicy.` Supported values include 'warn', "
+      f"'ignore', and 'fail.' Received {external_state_policy}."
+  )
+
+
+@tf_export("data.experimental.make_saveable_from_iterator")
+@deprecation.deprecated(
+    None, "`make_saveable_from_iterator` is intended for use in TF1 with "
+    "`tf.compat.v1.Saver`. In TF2, use `tf.train.Checkpoint` instead.")
+def make_saveable_from_iterator(iterator, external_state_policy=None):
+  """Returns a SaveableObject for saving/restoring iterator state using Saver.
+
+  Args:
+    iterator: Iterator.
+    external_state_policy: A string that identifies how to handle input
+      pipelines that depend on external state. Possible values are
+      'ignore': The external state is silently ignored.
+      'warn': The external state is ignored, logging a warning.
+      'fail': The operation fails upon encountering external state.
+      By default we set it to 'fail'.
+
+  Returns:
+    A SaveableObject for saving/restoring iterator state using Saver.
+
+  Raises:
+    ValueError: If iterator does not support checkpointing.
+    ValueError: If `external_state_policy` is not one of 'warn', 'ignore' or
+      'fail'.
+
+  For example:
+
+  ```python
+  with tf.Graph().as_default():
+    ds = tf.data.Dataset.range(10)
+    iterator = ds.make_initializable_iterator()
+    # Build the iterator SaveableObject.
+    saveable_obj = tf.data.experimental.make_saveable_from_iterator(iterator)
+    # Add the SaveableObject to the SAVEABLE_OBJECTS collection so
+    # it can be automatically saved using Saver.
+    tf.compat.v1.add_to_collection(tf.GraphKeys.SAVEABLE_OBJECTS, saveable_obj)
+    saver = tf.compat.v1.train.Saver()
+
+    while continue_training:
+      ... Perform training ...
+      if should_save_checkpoint:
+        saver.save()
+  ```
+
+  Note: When restoring the iterator, the existing iterator state is completely
+  discarded. This means that any changes you may have made to the Dataset
+  graph will be discarded as well! This includes the new Dataset graph
+  that you may have built during validation. So, while running validation,
+  make sure to run the initializer for the validation input pipeline after
+  restoring the checkpoint.
+
+  Note: Not all iterators support checkpointing yet. Attempting to save the
+  state of an unsupported iterator will throw an error.
+  """
+  if external_state_policy is None:
+    external_state_policy = "fail"
+  policy_enum = _convert_external_state_policy_to_enum(external_state_policy)
+  return iterator_ops._IteratorSaveable(  # pylint: disable=protected-access
+      iterator._iterator_resource,  # pylint: disable=protected-access
+      iterator._iterator_resource.name,  # pylint: disable=protected-access
+      external_state_policy=policy_enum)

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/pad_to_cardinality.py

@@ -0,0 +1,105 @@
+# Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""The implementation of `tf.data.experimental.pad_to_cardinality`."""
+
+from collections.abc import Mapping
+
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.eager import context
+from tensorflow.python.ops import array_ops
+from tensorflow.python.util import nest
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("data.experimental.pad_to_cardinality")
+def pad_to_cardinality(cardinality, mask_key="valid"):
+  """Pads a dataset with fake elements to reach the desired cardinality.
+
+  The dataset to pad must have a known and finite cardinality and contain
+  dictionary elements. The `mask_key` will be added to differentiate between
+  real and padding elements -- real elements will have a `<mask_key>=True` entry
+  while padding elements will have a `<mask_key>=False` entry.
+
+  Example usage:
+
+  >>> ds = tf.data.Dataset.from_tensor_slices({'a': [1, 2]})
+  >>> ds = ds.apply(tf.data.experimental.pad_to_cardinality(3))
+  >>> list(ds.as_numpy_iterator())
+  [{'a': 1, 'valid': True}, {'a': 2, 'valid': True}, {'a': 0, 'valid': False}]
+
+  This can be useful, e.g. during eval, when partial batches are undesirable but
+  it is also important not to drop any data.
+
+  ```
+  ds = ...
+  # Round up to the next full batch.
+  target_cardinality = -(-ds.cardinality() // batch_size) * batch_size
+  ds = ds.apply(tf.data.experimental.pad_to_cardinality(target_cardinality))
+  # Set `drop_remainder` so that batch shape will be known statically. No data
+  # will actually be dropped since the batch size divides the cardinality.
+  ds = ds.batch(batch_size, drop_remainder=True)
+  ```
+
+  Args:
+    cardinality: The cardinality to pad the dataset to.
+    mask_key: The key to use for identifying real vs padding elements.
+
+  Returns:
+    A dataset transformation that can be applied via `Dataset.apply()`.
+  """
+
+  def make_filler_dataset(ds):
+    padding = cardinality - ds.cardinality()
+
+    filler_element = nest.map_structure(
+        lambda spec: array_ops.zeros(spec.shape, spec.dtype), ds.element_spec
+    )
+    filler_element[mask_key] = False
+    filler_dataset = dataset_ops.Dataset.from_tensors(filler_element)
+    filler_dataset = filler_dataset.repeat(padding)
+    return filler_dataset
+
+  def apply_valid_mask(x):
+    x[mask_key] = True
+    return x
+
+  def _apply_fn(dataset):
+    # The cardinality tensor is unknown during tracing, so we only check it
+    # in eager mode.
+    if context.executing_eagerly():
+      if dataset.cardinality() < 0:
+        raise ValueError(
+            "The dataset passed into `pad_to_cardinality` must "
+            "have a known cardinalty, but has cardinality "
+            f"{dataset.cardinality()}"
+        )
+      if dataset.cardinality() > cardinality:
+        raise ValueError(
+            "The dataset passed into `pad_to_cardinality` must "
+            "have a cardinalty less than the target cardinality "
+            f"({cardinality}), but has cardinality "
+            f"{dataset.cardinality()}"
+        )
+    if not isinstance(dataset.element_spec, Mapping):
+      raise ValueError(
+          "`pad_to_cardinality` requires its input dataset to "
+          "be a dictionary."
+      )
+    filler = make_filler_dataset(dataset)
+    dataset = dataset.map(apply_valid_mask)
+    dataset = dataset.concatenate(filler)
+    return dataset
+
+  return _apply_fn

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/parsing_ops.py

@@ -0,0 +1,161 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Experimental `dataset` API for parsing example."""
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.data.util import structure
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import sparse_tensor
+from tensorflow.python.framework import tensor_spec
+from tensorflow.python.ops import gen_experimental_dataset_ops
+from tensorflow.python.ops import parsing_ops
+from tensorflow.python.ops.ragged import ragged_tensor
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+class _ParseExampleDataset(dataset_ops.UnaryDataset):
+  """A `Dataset` that parses `example` dataset into a `dict` dataset."""
+
+  def __init__(self, input_dataset, features, num_parallel_calls,
+               deterministic):
+    self._input_dataset = input_dataset
+    if not structure.are_compatible(
+        input_dataset.element_spec,
+        tensor_spec.TensorSpec([None], dtypes.string)):
+      raise TypeError("Input dataset should be a dataset of vectors of "
+                      f"strings. Instead it is `{input_dataset.element_spec}`.")
+    self._num_parallel_calls = num_parallel_calls
+    if deterministic is None:
+      self._deterministic = "default"
+    elif deterministic:
+      self._deterministic = "true"
+    else:
+      self._deterministic = "false"
+    # pylint: disable=protected-access
+    self._features = parsing_ops._prepend_none_dimension(features)
+    params = parsing_ops._ParseOpParams.from_features(self._features, [
+        parsing_ops.VarLenFeature, parsing_ops.SparseFeature,
+        parsing_ops.FixedLenFeature, parsing_ops.FixedLenSequenceFeature,
+        parsing_ops.RaggedFeature
+    ])
+    # pylint: enable=protected-access
+    self._sparse_keys = params.sparse_keys
+    self._sparse_types = params.sparse_types
+    self._ragged_keys = params.ragged_keys
+    self._ragged_value_types = params.ragged_value_types
+    self._ragged_split_types = params.ragged_split_types
+    self._dense_keys = params.dense_keys
+    self._dense_defaults = params.dense_defaults_vec
+    self._dense_shapes = params.dense_shapes_as_proto
+    self._dense_types = params.dense_types
+    input_dataset_shape = dataset_ops.get_legacy_output_shapes(
+        self._input_dataset)
+
+    self._element_spec = {}
+
+    for (key, value_type) in zip(params.sparse_keys, params.sparse_types):
+      self._element_spec[key] = sparse_tensor.SparseTensorSpec(
+          input_dataset_shape.concatenate([None]), value_type)
+
+    for (key, value_type, dense_shape) in zip(params.dense_keys,
+                                              params.dense_types,
+                                              params.dense_shapes):
+      self._element_spec[key] = tensor_spec.TensorSpec(
+          input_dataset_shape.concatenate(dense_shape), value_type)
+
+    for (key, value_type, splits_type) in zip(params.ragged_keys,
+                                              params.ragged_value_types,
+                                              params.ragged_split_types):
+      self._element_spec[key] = ragged_tensor.RaggedTensorSpec(
+          input_dataset_shape.concatenate([None]), value_type, 1, splits_type)
+
+    variant_tensor = (
+        gen_experimental_dataset_ops.parse_example_dataset_v2(
+            self._input_dataset._variant_tensor,  # pylint: disable=protected-access
+            self._num_parallel_calls,
+            self._dense_defaults,
+            self._sparse_keys,
+            self._dense_keys,
+            self._sparse_types,
+            self._dense_shapes,
+            deterministic=self._deterministic,
+            ragged_keys=self._ragged_keys,
+            ragged_value_types=self._ragged_value_types,
+            ragged_split_types=self._ragged_split_types,
+            **self._flat_structure))
+    super(_ParseExampleDataset, self).__init__(input_dataset, variant_tensor)
+
+  @property
+  def element_spec(self):
+    return self._element_spec
+
+
+@tf_export("data.experimental.parse_example_dataset")
+@deprecation.deprecated(
+    None, "Use `tf.data.Dataset.map(tf.io.parse_example(...))` instead.")
+def parse_example_dataset(features, num_parallel_calls=1, deterministic=None):
+  """A transformation that parses `Example` protos into a `dict` of tensors.
+
+  Parses a number of serialized `Example` protos given in `serialized`. We refer
+  to `serialized` as a batch with `batch_size` many entries of individual
+  `Example` protos.
+
+  This op parses serialized examples into a dictionary mapping keys to `Tensor`,
+  `SparseTensor`, and `RaggedTensor` objects. `features` is a dict from keys to
+  `VarLenFeature`, `RaggedFeature`, `SparseFeature`, and `FixedLenFeature`
+  objects. Each `VarLenFeature` and `SparseFeature` is mapped to a
+  `SparseTensor`; each `RaggedFeature` is mapped to a `RaggedTensor`; and each
+  `FixedLenFeature` is mapped to a `Tensor`. See `tf.io.parse_example` for more
+  details about feature dictionaries.
+
+  Args:
+   features: A `dict` mapping feature keys to `FixedLenFeature`,
+     `VarLenFeature`, `RaggedFeature`, and `SparseFeature` values.
+   num_parallel_calls: (Optional.) A `tf.int32` scalar `tf.Tensor`,
+      representing the number of parsing processes to call in parallel.
+   deterministic: (Optional.) A boolean controlling whether determinism
+      should be traded for performance by allowing elements to be produced out
+      of order if some parsing calls complete faster than others. If
+      `deterministic` is `None`, the
+      `tf.data.Options.deterministic` dataset option (`True` by default) is used
+      to decide whether to produce elements deterministically.
+
+  Returns:
+    A dataset transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+
+  Raises:
+    ValueError: if features argument is None.
+  """
+  if features is None:
+    raise ValueError("Argument `features` is required, but not specified.")
+
+  def _apply_fn(dataset):
+    """Function from `Dataset` to `Dataset` that applies the transformation."""
+    out_dataset = _ParseExampleDataset(dataset, features, num_parallel_calls,
+                                       deterministic)
+    if any(
+        isinstance(feature, parsing_ops.SparseFeature) or
+        isinstance(feature, parsing_ops.RaggedFeature)
+        for feature in features.values()):
+      # pylint: disable=protected-access
+      # pylint: disable=g-long-lambda
+      out_dataset = out_dataset.map(
+          lambda x: parsing_ops._construct_tensors_for_composite_features(
+              features, x),
+          num_parallel_calls=num_parallel_calls)
+    return out_dataset
+
+  return _apply_fn

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/prefetching_ops.py

@@ -0,0 +1,287 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python wrapper for prefetching_ops."""
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.data.ops import iterator_ops
+from tensorflow.python.data.ops import structured_function
+from tensorflow.python.data.util import structure
+from tensorflow.python.eager import def_function
+from tensorflow.python.framework import device as framework_device
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor_spec
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import functional_ops
+from tensorflow.python.ops import gen_dataset_ops
+from tensorflow.python.ops import gen_experimental_dataset_ops as ged_ops
+from tensorflow.python.ops import resource_variable_ops
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("data.experimental.prefetch_to_device")
+def prefetch_to_device(device, buffer_size=None):
+  """A transformation that prefetches dataset values to the given `device`.
+
+  NOTE: Although the transformation creates a `tf.data.Dataset`, the
+  transformation must be the final `Dataset` in the input pipeline.
+
+  For example,
+  >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])
+  >>> dataset = dataset.apply(tf.data.experimental.prefetch_to_device("/cpu:0"))
+  >>> for element in dataset:
+  ...   print(f'Tensor {element} is on device {element.device}')
+  Tensor 1 is on device /job:localhost/replica:0/task:0/device:CPU:0
+  Tensor 2 is on device /job:localhost/replica:0/task:0/device:CPU:0
+  Tensor 3 is on device /job:localhost/replica:0/task:0/device:CPU:0
+
+  Args:
+    device: A string. The name of a device to which elements will be prefetched.
+    buffer_size: (Optional.) The number of elements to buffer on `device`.
+      Defaults to an automatically chosen value.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+  def _apply_fn(dataset):
+    return dataset.apply(
+        copy_to_device(target_device=device)).prefetch(buffer_size)
+
+  return _apply_fn
+
+
+@tf_export("data.experimental.copy_to_device")
+def copy_to_device(target_device, source_device="/cpu:0"):
+  """A transformation that copies dataset elements to the given `target_device`.
+
+  Args:
+    target_device: The name of a device to which elements will be copied.
+    source_device: The original device on which `input_dataset` will be placed.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+
+  def _apply_fn(dataset):
+    return _CopyToDeviceDataset(
+        dataset, target_device=target_device, source_device=source_device)
+
+  return _apply_fn
+
+
+# TODO(rohanj): Use the _input_hostmem attr on the RemoteCall ops to indicate
+# all inputs to the Op are in host memory, thereby avoiding some unnecessary
+# Sends and Recvs.
+class _CopyToDeviceDataset(dataset_ops.UnaryUnchangedStructureDataset):
+  """A `Dataset` that copies elements to another device."""
+
+  def __init__(self, input_dataset, target_device, source_device="/cpu:0"):
+    """Constructs a _CopyToDeviceDataset.
+
+    Args:
+      input_dataset: `Dataset` to be copied
+      target_device: The name of the device to which elements would be copied.
+      source_device: Device where input_dataset would be placed.
+    """
+    self._input_dataset = input_dataset._apply_debug_options()  # pylint: disable=protected-access
+    self._target_device = target_device
+    spec = framework_device.DeviceSpec().from_string(self._target_device)
+    self._is_gpu_target = (spec.device_type == "GPU")
+    self._source_device_string = source_device
+    self._source_device = ops.convert_to_tensor(source_device)
+
+    wrap_ds_variant = gen_dataset_ops.wrap_dataset_variant(
+        self._input_dataset._variant_tensor)  # pylint: disable=protected-access
+
+    @def_function.function()
+    def _init_func():
+      """Creates an iterator for the input dataset.
+
+      Returns:
+        A `string` tensor that encapsulates the iterator created.
+      """
+      ds_variant = gen_dataset_ops.unwrap_dataset_variant(wrap_ds_variant)
+      resource = gen_dataset_ops.anonymous_iterator(
+          **self._input_dataset._flat_structure)  # pylint: disable=protected-access
+      with ops.control_dependencies(
+          [gen_dataset_ops.make_iterator(ds_variant, resource)]):
+        return gen_dataset_ops.iterator_to_string_handle(resource)
+
+    init_func_concrete = _init_func.get_concrete_function()  # pylint: disable=protected-access
+
+    @def_function.function()
+    def _remote_init_func():
+      return functional_ops.remote_call(
+          target=self._source_device,
+          args=init_func_concrete.captured_inputs,
+          Tout=[dtypes.string],
+          f=init_func_concrete)
+
+    self._init_func = _remote_init_func.get_concrete_function()  # pylint: disable=protected-access
+    self._init_captured_args = self._init_func.captured_inputs
+
+    @def_function.function(
+        input_signature=[tensor_spec.TensorSpec([], dtypes.string)])
+    def _next_func(string_handle):
+      """Calls get_next for created iterator.
+
+      Args:
+        string_handle: An iterator string handle created by _init_func
+      Returns:
+        The elements generated from `input_dataset`
+      """
+      with ops.device(self._source_device_string):
+        iterator = iterator_ops.Iterator.from_string_handle(
+            string_handle,
+            dataset_ops.get_legacy_output_types(self),
+            dataset_ops.get_legacy_output_shapes(self),
+            dataset_ops.get_legacy_output_classes(self))
+      return structure.to_tensor_list(self.element_spec, iterator.get_next())
+
+    next_func_concrete = _next_func.get_concrete_function()  # pylint: disable=protected-access
+
+    @def_function.function(
+        input_signature=[tensor_spec.TensorSpec([], dtypes.string)],
+        experimental_attributes={"experimental_ints_on_device": True})
+    def _remote_next_func(string_handle):
+      return functional_ops.remote_call(
+          target=self._source_device,
+          args=[string_handle] + next_func_concrete.captured_inputs,
+          Tout=self._input_dataset._flat_types,  # pylint: disable=protected-access
+          f=next_func_concrete)
+
+    self._next_func = _remote_next_func.get_concrete_function()
+    self._next_captured_args = self._next_func.captured_inputs
+
+    @def_function.function(
+        input_signature=[tensor_spec.TensorSpec([], dtypes.string)])
+    def _finalize_func(string_handle):
+      """Destroys the iterator resource created.
+
+      Args:
+        string_handle: An iterator string handle created by _init_func
+      Returns:
+        Tensor constant 0
+      """
+      iterator_resource = gen_dataset_ops.iterator_from_string_handle_v2(
+          string_handle,
+          **self._input_dataset._flat_structure)  # pylint: disable=protected-access
+      with ops.control_dependencies([
+          resource_variable_ops.destroy_resource_op(
+              iterator_resource, ignore_lookup_error=True)]):
+        return array_ops.constant(0, dtypes.int64)
+
+    finalize_func_concrete = _finalize_func.get_concrete_function()  # pylint: disable=protected-access
+
+    @def_function.function(
+        input_signature=[tensor_spec.TensorSpec([], dtypes.string)])
+    def _remote_finalize_func(string_handle):
+      return functional_ops.remote_call(
+          target=self._source_device,
+          args=[string_handle] + finalize_func_concrete.captured_inputs,
+          Tout=[dtypes.int64],
+          f=finalize_func_concrete)
+
+    self._finalize_func = _remote_finalize_func.get_concrete_function(  # pylint: disable=protected-access
+    )
+    self._finalize_captured_args = self._finalize_func.captured_inputs
+
+    g = ops.get_default_graph()
+    self._init_func.add_to_graph(g)
+    self._next_func.add_to_graph(g)
+    self._finalize_func.add_to_graph(g)
+    # pylint: enable=protected-scope
+
+    with ops.device(self._target_device):
+      variant_tensor = gen_dataset_ops.generator_dataset(
+          self._init_captured_args,
+          self._next_captured_args,
+          self._finalize_captured_args,
+          init_func=self._init_func,
+          next_func=self._next_func,
+          finalize_func=self._finalize_func,
+          **self._input_dataset._flat_structure)  # pylint: disable=protected-access
+    super(_CopyToDeviceDataset, self).__init__(input_dataset, variant_tensor)
+
+  # The one_shot_iterator implementation needs a 0 arg _make_dataset function
+  # that thereby captures all the inputs required to create the dataset. Since
+  # there are strings that are inputs to the GeneratorDataset which can't be
+  # placed on a GPU, this fails for the GPU case. Therefore, disabling it for
+  # GPU
+  def make_one_shot_iterator(self):
+    if self._is_gpu_target:
+      raise ValueError(
+          "`make_one_shot_iterator` is not compatible with GPU execution. "
+          "Please use `Dataset.make_initializable_iterator()` instead."
+      )
+    else:
+      return super(_CopyToDeviceDataset, self).make_one_shot_iterator()
+
+
+class _MapOnGpuDataset(dataset_ops.UnaryDataset):
+  """A `Dataset` that maps a function over elements in its using a GPU."""
+
+  def __init__(self, input_dataset, map_func, use_inter_op_parallelism=True):
+    """See `Dataset.map()` for details."""
+    self._input_dataset = input_dataset
+    self._use_inter_op_parallelism = use_inter_op_parallelism
+
+    self._map_func = structured_function.StructuredFunctionWrapper(
+        map_func,
+        self._transformation_name(),
+        dataset=input_dataset,
+        defun_kwargs={"experimental_ints_on_device": True})
+    variant_tensor = ged_ops.experimental_map_dataset(
+        self._input_dataset._variant_tensor,  # pylint: disable=protected-access
+        self._map_func.function.captured_inputs,
+        f=self._map_func.function,
+        use_inter_op_parallelism=self._use_inter_op_parallelism,
+        **self._flat_structure)
+    super(_MapOnGpuDataset, self).__init__(input_dataset, variant_tensor)
+
+  def _functions(self):
+    return [self._map_func]
+
+  @property
+  def element_spec(self):
+    return self._map_func.output_structure
+
+  def _transformation_name(self):
+    return "map_on_gpu()"
+
+
+def map_on_gpu(map_func):
+  """Maps `map_func` across the elements of this dataset.
+
+  NOTE: This is a highly experimental version of `tf.data.Dataset.map` that runs
+  `map_func` on GPU. It must be used after applying the
+  `tf.data.experimental.copy_to_device` transformation with a GPU device
+  argument.
+
+  Args:
+    map_func: A function mapping a nested structure of tensors (having shapes
+      and types defined by `self.output_shapes` and `self.output_types`) to
+      another nested structure of tensors.
+
+  Returns:
+    A `Dataset` transformation function, which can be passed to
+    `tf.data.Dataset.apply`.
+  """
+
+  def _apply_fn(dataset):
+    return _MapOnGpuDataset(dataset, map_func)
+
+  return _apply_fn

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/random_access.py

@@ -0,0 +1,73 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Python API for random indexing into a dataset."""
+
+from tensorflow.python.data.util import structure
+from tensorflow.python.ops import gen_experimental_dataset_ops
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("data.experimental.at", v1=[])
+def at(dataset, index):
+  """Returns the element at a specific index in a datasest.
+
+  Currently, random access is supported for the following tf.data operations:
+
+     - `tf.data.Dataset.from_tensor_slices`,
+     - `tf.data.Dataset.from_tensors`,
+     - `tf.data.Dataset.shuffle`,
+     - `tf.data.Dataset.batch`,
+     - `tf.data.Dataset.shard`,
+     - `tf.data.Dataset.map`,
+     - `tf.data.Dataset.range`,
+     - `tf.data.Dataset.zip`,
+     - `tf.data.Dataset.skip`,
+     - `tf.data.Dataset.repeat`,
+     - `tf.data.Dataset.list_files`,
+     - `tf.data.Dataset.SSTableDataset`,
+     - `tf.data.Dataset.concatenate`,
+     - `tf.data.Dataset.enumerate`,
+     - `tf.data.Dataset.parallel_map`,
+     - `tf.data.Dataset.prefetch`,
+     - `tf.data.Dataset.take`,
+     - `tf.data.Dataset.cache` (in-memory only)
+
+     Users can use the cache operation to enable random access for any dataset,
+     even one comprised of transformations which are not on this list.
+     E.g., to get the third element of a TFDS dataset:
+
+       ```python
+       ds = tfds.load("mnist", split="train").cache()
+       elem = tf.data.Dataset.experimental.at(ds, 3)
+       ```
+
+  Args:
+    dataset: A `tf.data.Dataset` to determine whether it supports random access.
+    index: The index at which to fetch the element.
+
+  Returns:
+      A (nested) structure of values matching `tf.data.Dataset.element_spec`.
+
+   Raises:
+     UnimplementedError: If random access is not yet supported for a dataset.
+  """
+  # pylint: disable=protected-access
+  return structure.from_tensor_list(
+      dataset.element_spec,
+      gen_experimental_dataset_ops.get_element_at_index(
+          dataset._variant_tensor,
+          index,
+          output_types=structure.get_flat_tensor_types(dataset.element_spec),
+          output_shapes=structure.get_flat_tensor_shapes(dataset.element_spec)))

videochat2/lib/python3.10/site-packages/tensorflow/python/data/experimental/ops/random_ops.py

@@ -0,0 +1,58 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Datasets for random number generators."""
+import functools
+
+from tensorflow.python import tf2
+from tensorflow.python.compat import v2_compat
+from tensorflow.python.data.ops import dataset_ops
+from tensorflow.python.data.ops import random_op
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+# TODO(b/260143413): Migrate users to `tf.data.Dataset.random`.
+@deprecation.deprecated(None, "Use `tf.data.Dataset.random(...)`.")
+@tf_export("data.experimental.RandomDataset", v1=[])
+class RandomDatasetV2(random_op._RandomDataset):  # pylint: disable=protected-access
+  """A `Dataset` of pseudorandom values."""
+
+
+@deprecation.deprecated(None, "Use `tf.data.Dataset.random(...)`.")
+@tf_export(v1=["data.experimental.RandomDataset"])
+class RandomDatasetV1(dataset_ops.DatasetV1Adapter):
+  """A `Dataset` of pseudorandom values."""
+
+  @functools.wraps(RandomDatasetV2.__init__)
+  def __init__(self, seed=None):
+    wrapped = RandomDatasetV2(seed)
+    super(RandomDatasetV1, self).__init__(wrapped)
+
+
+if tf2.enabled():
+  RandomDataset = RandomDatasetV2
+else:
+  RandomDataset = RandomDatasetV1
+
+
+def _tf2_callback():
+  global RandomDataset
+  if tf2.enabled():
+    RandomDataset = RandomDatasetV2
+  else:
+    RandomDataset = RandomDatasetV1
+
+
+v2_compat.register_data_v2_callback(_tf2_callback)