Add files using upload-large-folder tool

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/distributed_runtime/coordination/coordination_service_agent.h

@@ -0,0 +1,283 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_SERVICE_AGENT_H_
+#define TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_SERVICE_AGENT_H_
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "absl/time/time.h"
+#include "tsl/distributed_runtime/call_options.h"
+#include "tsl/distributed_runtime/coordination/coordination_client.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+#include "tsl/protobuf/coordination_service.pb.h"
+
+namespace tensorflow {
+class CoordinationServiceConfig;
+};  // namespace tensorflow
+
+namespace tsl {
+class Env;
+
+// CoordinationServiceAgent defines the interface for tasks to communicate with
+// the coordination service instance (which implements
+// CoordinationServiceInterface). One instance of the agent should be deployed
+// on each task for it to send various requests and stores / retrieves config
+// key-value data to the service.
+//
+// See CoordinationServiceInterface for more details on coordination service.
+//
+// All coordination service errors will have an additional
+// CoordinationServiceError payload to distinguish themselves from RPC failures.
+// The payload can optionally specify the error origin, and if the error is
+// reported by the user via `agent->ReportError()`.
+//
+// Possible service errors:
+//    - Internal: Coordination service is not enabled.
+//                        If it was previously accessible, coordination service
+//                        has been shut down.
+//    - Aborted: Incarnation mismatch during heartbeat (either remote
+//                       task or coordination service has restarted).
+//    - Unavailable: Heartbeat timeout from remote task (failed,
+//                           crashed or got preempted).
+//    - InvalidArgument: Unexpected heartbeat from remote task (not
+//                               registered or wrong config).
+class CoordinationServiceAgent {
+ public:
+  using StatusOrValueCallback =
+      std::function<void(const StatusOr<std::string>&)>;
+  // Collection of key-value pairs in the same directory.
+  using StatusOrValueDirCallback = std::function<void(
+      const StatusOr<std::vector<tensorflow::KeyValueEntry>>&)>;
+  using ChangedKeyValuesCallback =
+      std::function<void(const std::map<std::string, std::string>&)>;
+
+  virtual ~CoordinationServiceAgent() = default;
+
+  // Initialize coordination service agent.
+  virtual Status Initialize(
+      tsl::Env* env, std::string_view job_name, int task_id,
+      const tensorflow::CoordinationServiceConfig& configs,
+      std::unique_ptr<CoordinationClient> leader_client,
+      StatusCallback error_fn) = 0;
+  virtual Status Initialize(
+      tsl::Env* env, const tensorflow::CoordinatedTask& task,
+      const tensorflow::CoordinationServiceConfig& configs,
+      std::unique_ptr<CoordinationClient> leader_client,
+      StatusCallback error_fn) = 0;
+
+  // Return true if the coordination service agent has been initialized.
+  virtual bool IsInitialized() = 0;
+
+  // Return true if the coordination service agent has successfully connected
+  // with the Coordination Service
+  virtual bool IsConnected() = 0;
+
+  // Return true if the coordination service agent has an error state.
+  virtual bool IsError() = 0;
+
+  // Connect to coordination service with the following steps:
+  //   - connect to service address specified in the config of `server_def`
+  //   - register itself as a task to the service
+  //   - start a thread to periodically send heartbeat message with the service
+  // Possible service errors:
+  //   - FailedPrecondition: Agent is not in DISCONNECTED state.
+  //   - InvalidArgument: Unexpected task registration
+  //   - Aborted: Duplicate task registration (agent will retry connecting until
+  //              the configured timeout)
+  virtual Status Connect() = 0;
+
+  // Wait for all tasks to be up and registered. The call blocks until all tasks
+  // in the cluster are up, or some error occurs.
+  // Possible service errors:
+  //   - FailedPrecondition: Agent is not in CONNECTED state.
+  //   - InvalidArgument: Unexpected task request
+  virtual Status WaitForAllTasks(
+      const tensorflow::DeviceInfo& local_devices) = 0;
+
+  // Get the device attributes of tasks from remote tasks in the cluster.
+  virtual const tensorflow::DeviceInfo& GetClusterDeviceInfo() = 0;
+
+  // State transition in coordination service agent:
+  //
+  //                 Init              Connect           SetError
+  //   UNINITIALIZED ---> DISCONNECTED ------> CONNECTED -------> ERROR
+  //                           ^                                  |
+  //                           |__________________________________|
+  //                                         Reset
+
+  // Get task associated with this agent.
+  virtual StatusOr<tensorflow::CoordinatedTask> GetOwnTask() = 0;
+
+  // Get status of a remote task.
+  virtual StatusOr<std::vector<tensorflow::CoordinatedTaskStateInfo>>
+  GetTaskState(const std::vector<tensorflow::CoordinatedTask>& task) = 0;
+
+  // Report error to coordination service. This will invoke the error callback.
+  // Note that the error payload will set `is_reported_error` to true, to
+  // distinguish user-specified errors from internal service or RPC failures.
+  // Possible service errors:
+  //   - FailedPrecondition: Uninitialized/disconnected/already in error state.
+  //   - InvalidArgument: Unexpected task request
+  virtual Status ReportError(const Status& error) = 0;
+
+  // Shuts down by disconnecting from the service. Should only be called if
+  // agent is connected and no further agent calls (except the destructor) are
+  // expected. If `shutdown_barrier_timeout_in_ms` is specified in the config,
+  // blocks until all tasks reach the barrier before shutting down together. If
+  // the barrier times out, this agent will still disconnect, while an error is
+  // reported to other agents that did not reach the barrier on time.
+  // Possible service errors:
+  //   - InvalidArgument: Unexpected task request.
+  //   - FailedPrecondition: Task was in error state (note: agent is still
+  //                         shut down forcefully).
+  virtual Status Shutdown() = 0;
+
+  // Disconnect from the service, and clean up the internal error status.
+  // Possible service errors:
+  //   - InvalidArgument: Unexpected task request.
+  //   - FailedPrecondition: task is not in error state/has already
+  //       disconnected.
+  virtual Status Reset() = 0;
+
+  // Key-value store API.
+  // The agent does not need to be connected to utilize the key-value store.
+  // There are no concurrency guarantees. To avoid a race / impose an ordering
+  // on potentially concurrent ops (e.g. set, delete), use WaitAtBarrier().
+
+  // Get config key-value from the service.
+  // If the key-value is not inserted yet, this is a blocking call that waits
+  // until the corresponding key is inserted.
+  //   - DeadlineExceeded: timed out waiting for key.
+  virtual StatusOr<std::string> GetKeyValue(std::string_view key) = 0;
+  virtual StatusOr<std::string> GetKeyValue(std::string_view key,
+                                            absl::Duration timeout) = 0;
+  // Note: Cancel the underlying RPC call with `call_opts->StartCancel()` and
+  // `call_opts->ClearCancelCallback()`.
+  virtual std::shared_ptr<CallOptions> GetKeyValueAsync(
+      std::string_view, StatusOrValueCallback done) = 0;
+
+  // Get config key-value from the service.
+  //   - NotFound: the requested key does not exist.
+  virtual StatusOr<std::string> TryGetKeyValue(std::string_view key) = 0;
+
+  // Get all values under a directory (key).
+  // A value is considered to be in the directory if its key is prefixed with
+  // the directory.
+  // This is not a blocking call. If no keys are found, an empty vector is
+  // returned immediately.
+  virtual StatusOr<std::vector<tensorflow::KeyValueEntry>> GetKeyValueDir(
+      std::string_view key) = 0;
+  virtual void GetKeyValueDirAsync(std::string_view key,
+                                   StatusOrValueDirCallback done) = 0;
+
+  // Insert config key-value to the service.
+  //   - AlreadyExists: key is already set.
+  virtual Status InsertKeyValue(std::string_view key,
+                                std::string_view value) = 0;
+
+  // Delete config keys in the coordination service.
+  virtual Status DeleteKeyValue(std::string_view key) = 0;
+
+  // Update the value of a config key.
+  virtual Status UpdateKeyValue(std::string_view key,
+                                std::string_view value) = 0;
+
+  // Register a callback that will be invoked when the key or keys under the key
+  // directory are changed (inserted, deleted, or updated).
+  virtual Status StartWatchKey(std::string_view key,
+                               ChangedKeyValuesCallback on_change) = 0;
+  virtual Status StopWatchKey(std::string_view key) = 0;
+
+  // Blocks until all (or a subset of) tasks are at the barrier or the barrier
+  // fails.
+  //
+  // `barrier_id` should be unique across barriers.
+  //
+  // The first WaitAtBarrier() call received by the service for a particular
+  // barrier_id is special in that it determines the barrier deadline based on
+  // timeout duration.
+  // However, if subsequent calls by different agents specify a different set of
+  // `tasks` for the same `barrier_id`, the barrier will fail instantly.
+  // For example,
+  //   agent_1->WaitAtBarrier(“barrier”, 10min, <<”worker”, 1>, <”worker”, 2>>);
+  //   agent_2->WaitAtBarrier(“barrier”, 10min, <<”worker”, 2>, <”worker”, 3>>);
+  // Barrier fails after agent_2’s call because it specifies a different set of
+  // participating tasks.
+  //
+  // If no tasks are specified (default), the barrier will block for all the
+  // connected tasks.
+  //
+  // Possible service errors:
+  //   - DeadlineExceeded: Timed out waiting for specified tasks at the barrier.
+  //      Deadline is determined by the server timestamp when it receives the
+  //      first WaitAtBarrier() + timeout duration.
+  //   - Cancelled: One of the tasks called CancelBarrier().
+  //   - Aborted: Service is shutting down.
+  //   - Internal: Any participating task is in ERROR state.
+  //   - InvalidArgument: (1) Conflicting tasks specified by different agents
+  //       for the same barrier, (2) one of the participating tasks is not in
+  //       the cluster, or (3) task making the request is not included in the
+  //       list of participating tasks.
+  //   - FailedPrecondition: Agent is in UNINITIALIZED or ERROR state. Or the
+  //       same barrier_id was already used previously.
+  virtual Status WaitAtBarrier(
+      std::string_view barrier_id, absl::Duration timeout,
+      const std::vector<tensorflow::CoordinatedTask>& tasks) = 0;
+
+  virtual void WaitAtBarrierAsync(
+      std::string_view barrier_id, absl::Duration timeout,
+      const std::vector<tensorflow::CoordinatedTask>& tasks,
+      StatusCallback done) = 0;
+
+  // Aborts the barrier if it is ongoing.
+  // Current and future WaitAtBarrier() calls with the same id will return a
+  // CANCELLED error status.
+  // Possible service errors:
+  //   - FailedPrecondition: Barrier has already been passed.
+  virtual Status CancelBarrier(std::string_view barrier_id) = 0;
+  virtual void CancelBarrierAsync(std::string_view barrier_id,
+                                  StatusCallback done) = 0;
+
+  // Get unowned Env* that the agent was initialized with.
+  virtual StatusOr<tsl::Env*> GetEnv() = 0;
+
+ protected:
+  // Set the service agent to error status and invoke the error callback.
+  // Note: different from ReportError, this does not report the error status to
+  // remote coordination service.
+  virtual void SetError(const Status& error) = 0;
+
+  // Activate the key-value callback watch.
+  virtual Status ActivateWatch(std::string_view,
+                               const std::map<std::string, std::string>&) = 0;
+
+ private:
+  friend class CoordinationServiceRpcHandler;
+};
+
+std::unique_ptr<CoordinationServiceAgent> CreateCoordinationServiceAgent();
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_SERVICE_AGENT_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/distributed_runtime/coordination/coordination_service_error_util.h

@@ -0,0 +1,60 @@
+/* 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.
+==============================================================================*/
+#ifndef TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_SERVICE_ERROR_UTIL_H_
+#define TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_SERVICE_ERROR_UTIL_H_
+
+#include "absl/strings/string_view.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/status.h"
+#include "tsl/protobuf/coordination_service.pb.h"
+
+namespace tsl {
+
+constexpr absl::string_view CoordinationErrorPayloadKey() {
+  return "type.googleapis.com/tensorflow.CoordinationServiceError";
+}
+
+// Mark error as a coordination service error (as opposed to RPC
+// errors).
+inline Status MakeCoordinationError(Status s) {
+  s.SetPayload(CoordinationErrorPayloadKey(), absl::Cord(""));
+  return s;
+}
+
+// Mark error as a coordination service error (as opposed to RPC
+// errors), and indicate error origin.
+// Errors reported via the agent API by the user should set `is_reported_error`
+// to true.
+inline Status MakeCoordinationError(Status s,
+                                    const tensorflow::CoordinatedTask& origin,
+                                    bool is_reported_error = false) {
+  tensorflow::CoordinationServiceError error;
+  *error.mutable_source_task() = origin;
+  error.set_is_reported_error(is_reported_error);
+  s.SetPayload(CoordinationErrorPayloadKey(),
+               absl::Cord(error.SerializeAsString()));
+  return s;
+}
+
+// Mark error as a coordination service error with payload.
+inline Status MakeCoordinationError(
+    Status s, const tensorflow::CoordinationServiceError& payload) {
+  s.SetPayload(CoordinationErrorPayloadKey(),
+               absl::Cord(payload.SerializeAsString()));
+  return s;
+}
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_SERVICE_ERROR_UTIL_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/distributed_runtime/rpc/async_service_interface.h

@@ -0,0 +1,41 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_ASYNC_SERVICE_INTERFACE_H_
+#define TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_ASYNC_SERVICE_INTERFACE_H_
+
+namespace tsl {
+
+// Represents an abstract asynchronous service that handles incoming
+// RPCs with a polling loop.
+class AsyncServiceInterface {
+ public:
+  virtual ~AsyncServiceInterface() {}
+
+  // A blocking method that should be called to handle incoming RPCs.
+  // This method will block until the service shuts down.
+  virtual void HandleRPCsLoop() = 0;
+
+  // Starts shutting down this service.
+  //
+  // NOTE(mrry): To shut down this service completely, the caller must
+  // also shut down any servers that might share ownership of this
+  // service's resources (e.g. completion queues).
+  virtual void Shutdown() = 0;
+};
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_ASYNC_SERVICE_INTERFACE_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/distributed_runtime/rpc/coordination/grpc_coordination_client.h

@@ -0,0 +1,34 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_CLIENT_H_
+#define TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_CLIENT_H_
+
+#include <memory>
+
+#include "tsl/distributed_runtime/coordination/coordination_client.h"
+#include "tsl/distributed_runtime/rpc/grpc_channel.h"
+
+namespace tsl {
+
+CoordinationClientCache* NewGrpcCoordinationClientCache(
+    std::shared_ptr<GrpcChannelCache> channel);
+
+CoordinationClient* NewGrpcCoordinationClient(
+    std::shared_ptr<::grpc::Channel> channel);
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_CLIENT_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/distributed_runtime/rpc/coordination/grpc_coordination_service_impl.h

@@ -0,0 +1,117 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_SERVICE_IMPL_H_
+#define TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_SERVICE_IMPL_H_
+
+#include <memory>
+
+#include "grpcpp/alarm.h"
+#include "grpcpp/completion_queue.h"
+#include "grpcpp/server_builder.h"
+#include "tsl/distributed_runtime/coordination/coordination_service_agent.h"
+#include "tsl/distributed_runtime/coordination/coordination_service_rpc_handler.h"
+#include "tsl/distributed_runtime/rpc/async_service_interface.h"
+#include "tsl/distributed_runtime/rpc/grpc_call.h"
+#include "tsl/distributed_runtime/rpc/grpc_util.h"
+#include "tsl/platform/mutex.h"
+#include "tsl/platform/thread_annotations.h"
+#include "tsl/platform/threadpool.h"
+#include "tsl/protobuf/coordination_service.grpc.pb.h"
+#include "tsl/protobuf/coordination_service.pb.h"
+
+namespace tsl {
+
+class GrpcCoordinationServiceImpl : public AsyncServiceInterface {
+ public:
+  template <class RequestMessage, class ResponseMessage>
+  using CoordCall = Call<GrpcCoordinationServiceImpl,
+                         tensorflow::grpc::CoordinationService::AsyncService,
+                         RequestMessage, ResponseMessage>;
+
+  GrpcCoordinationServiceImpl(thread::ThreadPool* compute_pool,
+                              ::grpc::ServerBuilder* server_builder);
+  ~GrpcCoordinationServiceImpl() override {}
+
+  void HandleRPCsLoop() override;
+  void Shutdown() override;
+  void SetCoordinationServiceAgentInstance(CoordinationServiceAgent* agent) {
+    rpc_handler_.SetAgentInstance(agent);
+  }
+  void SetCoordinationServiceInstance(CoordinationServiceInterface* service) {
+    rpc_handler_.SetServiceInstance(service);
+  }
+  CoordinationServiceRpcHandler* GetRpcHandler() { return &rpc_handler_; }
+
+ private:
+#define HANDLER(method)                                                       \
+  void method##Handler(CoordCall<tensorflow::method##Request,                 \
+                                 tensorflow::method##Response>* call) {       \
+    tf_shared_lock l(shutdown_mu_);                                           \
+    if (shutdown_) {                                                          \
+      call->SendResponse(ToGrpcStatus(                                        \
+          errors::Internal("Coordination service has been shut down.")));     \
+      return;                                                                 \
+    }                                                                         \
+    compute_pool_.Schedule([this, call]() {                                   \
+      rpc_handler_.method##Async(&call->request, &call->response,             \
+                                 [call](const Status& s) {                    \
+                                   call->ClearCancelCallback();               \
+                                   call->SendResponse(ToGrpcStatus(s));       \
+                                 });                                          \
+    });                                                                       \
+    Call<GrpcCoordinationServiceImpl,                                         \
+         tensorflow::grpc::CoordinationService::AsyncService,                 \
+         tensorflow::method##Request, tensorflow::method##Response>::         \
+        EnqueueRequest(&service_, cq_.get(),                                  \
+                       &tensorflow::grpc::CoordinationService::AsyncService:: \
+                           Request##method,                                   \
+                       &GrpcCoordinationServiceImpl::method##Handler,         \
+                       /*supports_cancel=*/false);                            \
+  }
+  HANDLER(RegisterTask);
+  HANDLER(WaitForAllTasks);
+  HANDLER(ShutdownTask);
+  HANDLER(ResetTask);
+  HANDLER(Heartbeat);
+  HANDLER(ReportErrorToTask);
+  HANDLER(ReportErrorToService);
+  HANDLER(GetTaskState);
+  HANDLER(InsertKeyValue);
+  HANDLER(GetKeyValue);
+  HANDLER(TryGetKeyValue);
+  HANDLER(GetKeyValueDir);
+  HANDLER(DeleteKeyValue);
+  HANDLER(Barrier);
+  HANDLER(CancelBarrier);
+#undef HANDLER
+
+  thread::ThreadPool& compute_pool_;
+  CoordinationServiceRpcHandler rpc_handler_;
+
+  mutex shutdown_mu_;
+  bool shutdown_ TF_GUARDED_BY(shutdown_mu_);
+  std::unique_ptr<::grpc::Alarm> shutdown_alarm_;
+
+  std::unique_ptr<::grpc::ServerCompletionQueue> cq_;
+  tensorflow::grpc::CoordinationService::AsyncService service_;
+
+  GrpcCoordinationServiceImpl(const GrpcCoordinationServiceImpl&) = delete;
+  void operator=(const GrpcCoordinationServiceImpl&) = delete;
+};
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_SERVICE_IMPL_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/distributed_runtime/rpc/grpc_state.h

@@ -0,0 +1,254 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_GRPC_STATE_H_
+#define TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_GRPC_STATE_H_
+
+#include <queue>
+#include <string>
+#include <utility>
+
+#include "grpcpp/generic/generic_stub.h"
+#include "grpcpp/grpcpp.h"
+#include "absl/status/status.h"
+#include "tsl/distributed_runtime/call_options.h"
+#include "tsl/distributed_runtime/rpc/grpc_client_cq_tag.h"
+#include "tsl/distributed_runtime/rpc/grpc_util.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/strcat.h"
+#include "tsl/platform/threadpool.h"
+#include "tsl/util/env_var.h"
+
+namespace tsl {
+
+// Object allocated per active RPC.
+// Manage the state of a single asynchronous RPC request.  If `max_retries`
+// is greater than 0, the request will be retried for any transient failures.
+// Note: `parse_proto_fn` is used solely to allow TensorFlow's worker service
+// to pass in an optimized function that avoids an unnecessary copy of tensors.
+// That is not implemented as an overload of tsl::GrpcMaybeParseProto because it
+// has dependencies on many TensorFlow-specific absractions.
+template <class Response>
+class RPCState : public GrpcClientCQTag {
+ public:
+  RPCState(
+      ::grpc::GenericStub* stub, ::grpc::CompletionQueue* cq,
+      const ::grpc::string& method, const protobuf::Message& request,
+      Response* response, StatusCallback done, CallOptions* call_opts,
+      thread::ThreadPool* threadpool, int32_t max_retries = 0,
+      bool fail_fast = true, const string* target = nullptr,
+      std::function<bool(::grpc::ByteBuffer*, Response*)> parse_proto_fn =
+          [](::grpc::ByteBuffer* src, Response* dst) {
+            return tsl::GrpcMaybeParseProto(src, dst);
+          })
+      : RPCState(
+            stub, cq, method, request, response, std::move(done), call_opts,
+            threadpool,
+            // 1) If GRPC_FAIL_FAST is set to 'true' or 'false',
+            // fail_fast=$GRPC_FAIL_FAST. See b/141948186.
+            // 2) Otherwise if GRPC_FAIL_FAST is set to 'use_caller', use the
+            // fail_fast from the caller. See b/140260119.
+            //
+            // Current default: use caller's fail_fast argument.
+            //
+            // NOTE: Callers mostly set fail_fast=true to prevent job hanging
+            // on worker task failures, except a few cases such as GetStatus
+            // in cluster initialization and collective param resolution.
+            [fail_fast, &done]() -> bool {
+              string fail_fast_env;
+              TF_CHECK_OK(ReadStringFromEnvVar("GRPC_FAIL_FAST", "use_caller",
+                                               &fail_fast_env));
+              string fail_fast_env_lower = absl::AsciiStrToLower(fail_fast_env);
+              if (fail_fast_env_lower == "true") {
+                return true;
+              } else if (fail_fast_env_lower == "use_caller") {
+                return fail_fast;
+              } else if (fail_fast_env_lower == "false") {
+                return false;
+              } else {
+                string error_message = strings::StrCat(
+                    "Invalid GRPC_FAIL_FAST config: ", fail_fast_env);
+                LOG(WARNING) << error_message;
+                done(errors::InvalidArgument(error_message));
+                return false;
+              }
+            }(),
+            (call_opts != nullptr ? call_opts->GetTimeout() : 0), max_retries,
+            target, parse_proto_fn) {}
+
+  template <typename Request>
+  RPCState(
+      ::grpc::GenericStub* stub, ::grpc::CompletionQueue* cq,
+      const ::grpc::string& method, const Request& request, Response* response,
+      StatusCallback done, CallOptions* call_opts,
+      thread::ThreadPool* threadpool, bool fail_fast, int64_t timeout_in_ms,
+      int32_t max_retries, const string* target,
+      std::function<bool(::grpc::ByteBuffer*, Response*)> parse_proto_fn =
+          [](::grpc::ByteBuffer* src, Response* dst) {
+            return tsl::GrpcMaybeParseProto(src, dst);
+          })
+      : call_opts_(call_opts),
+        threadpool_(threadpool),
+        done_(std::move(done)),
+        timeout_in_ms_(timeout_in_ms),
+        max_retries_(max_retries),
+        cq_(cq),
+        stub_(stub),
+        method_(method),
+        fail_fast_(fail_fast),
+        target_(target),
+        parse_proto_fn_(std::move(parse_proto_fn)) {
+    response_ = response;
+    ::grpc::Status s = GrpcMaybeUnparseProto(request, &request_buf_);
+    if (!s.ok()) {
+      LOG(ERROR) << "GrpcMaybeUnparseProto returned with non-ok status: "
+                 << s.error_message();
+      // Skip retry logic if we fail to parse our request.
+      done_(FromGrpcStatus(s));
+      delete this;
+      return;
+    }
+    StartCall();
+  }
+
+  void StartCall() {
+    context_.reset(new ::grpc::ClientContext());
+    context_->set_wait_for_ready(!fail_fast_);
+    if (timeout_in_ms_ > 0) {
+      context_->set_deadline(
+          gpr_time_from_millis(timeout_in_ms_, GPR_TIMESPAN));
+    }
+    if (call_opts_) {
+      call_opts_->SetCancelCallback([this]() { context_->TryCancel(); });
+    }
+
+    VLOG(2) << "Starting call: " << method_;
+
+    call_ = stub_->PrepareUnaryCall(context_.get(), method_, request_buf_, cq_);
+    call_->StartCall();
+    call_->Finish(&response_buf_, &status_, this);
+  }
+
+  void OnCompleted(bool ok) override {
+    if (call_opts_) {
+      call_opts_->ClearCancelCallback();
+    }
+
+    VLOG(2) << "Completed call: " << method_;
+
+    Status s = FromGrpcStatus(status_);
+    if (s.ok() && !ok) {
+      // Since this function is only being used for processing the response
+      // to Finish for client-side unary calls, ok should never be false
+      s.Update(
+          errors::Internal("GRPC status is okay but CompletionQueueStatus is "
+                           "not.  This should never happen."));
+    }
+
+    if (s.ok()) {
+      if (threadpool_) {
+        // Run parse and callback in another thread, returning this
+        // one to service more RPCs.
+        threadpool_->Schedule([this]() { ParseAndCallDone(); });
+      } else {
+        ParseAndCallDone();
+      }
+      return;
+    }
+
+    VLOG(1) << method_ << " returned with non-ok status: " << s
+            << " Retries: " << num_retries_ << " Max: " << max_retries_ << "\n"
+            << context_->debug_error_string();
+    // Retry if we have any attempts left
+    if (++num_retries_ <= max_retries_ &&
+        (absl::IsUnavailable(s) || absl::IsUnknown(s))) {
+      response_buf_.Clear();
+      VLOG(1) << "Retrying call for " << method_ << "Retry: " << num_retries_
+              << " of " << max_retries_;
+
+      ComputeRetryBackoffMs(/*min_backoff_ms=*/1, /*max_backoff_ms=*/10000);
+      int64_t backoff_us = retry_backoff_ms_ * 1000;
+      Env::Default()->SchedClosureAfter(/*micros=*/backoff_us,
+                                        [this]() { StartCall(); });
+    } else {
+      // Attach additional GRPC error information if any to the final status
+      string error_msg = std::string(s.message());
+      strings::StrAppend(&error_msg, "\nAdditional GRPC error information");
+      if (target_) {
+        strings::StrAppend(&error_msg, " from remote target ", *target_);
+      }
+      strings::StrAppend(&error_msg, " while calling ", method_);
+      strings::StrAppend(&error_msg, ":\n:", context_->debug_error_string());
+      s = errors::CreateWithUpdatedMessage(s, error_msg);
+      // Always treat gRPC cancellation as a derived error. This ensures that
+      // other error types are preferred during status aggregation. (gRPC
+      // cancellation messages do not contain the original status message).
+      if (s.code() == absl::StatusCode::kCancelled) {
+        s = StatusGroup::MakeDerived(s);
+      }
+
+      done_(s);
+      delete this;
+    }
+  }
+
+  void ParseAndCallDone() {
+    Status s;
+    if (!parse_proto_fn_(&response_buf_, response_)) {
+      s.Update(errors::Internal("could not parse rpc response"));
+    }
+    done_(s);
+    delete this;
+  }
+
+ private:
+  void ComputeRetryBackoffMs(int min_backoff_ms, int max_backoff_ms) {
+    constexpr float kBackoffBase = 1.3;
+    if (retry_backoff_ms_ < 0) {
+      retry_backoff_ms_ = min_backoff_ms;
+    } else {
+      retry_backoff_ms_ *= kBackoffBase;
+      if (retry_backoff_ms_ > max_backoff_ms) {
+        retry_backoff_ms_ = max_backoff_ms;
+      }
+    }
+  }
+
+  CallOptions* call_opts_;
+  std::unique_ptr<::grpc::ClientContext> context_;
+  thread::ThreadPool* threadpool_;
+  std::unique_ptr<::grpc::GenericClientAsyncResponseReader> call_;
+  Response* response_;
+  ::grpc::ByteBuffer request_buf_;
+  ::grpc::ByteBuffer response_buf_;
+  ::grpc::Status status_;
+  StatusCallback done_;
+  int64_t timeout_in_ms_;
+
+  size_t num_retries_ = 0;
+  size_t max_retries_;
+  double retry_backoff_ms_ = -1;
+
+  ::grpc::CompletionQueue* cq_;
+  ::grpc::GenericStub* stub_;
+  ::grpc::string method_;
+  bool fail_fast_;
+  const string* target_;
+  std::function<bool(::grpc::ByteBuffer*, Response*)> parse_proto_fn_ = nullptr;
+};
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_DISTRIBUTED_RUNTIME_RPC_GRPC_STATE_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/abi.h

@@ -0,0 +1,31 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_ABI_H_
+#define TENSORFLOW_TSL_PLATFORM_ABI_H_
+
+#include <string>
+
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace port {
+
+std::string MaybeAbiDemangle(const char* name);
+
+}  // namespace port
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_ABI_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/base64.h

@@ -0,0 +1,60 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_BASE64_H_
+#define TENSORFLOW_TSL_PLATFORM_BASE64_H_
+
+#include <string>
+
+#include "tsl/platform/status.h"
+#include "tsl/platform/stringpiece.h"
+
+namespace tsl {
+
+/// \brief Converts data into web-safe base64 encoding.
+///
+/// See https://en.wikipedia.org/wiki/Base64
+template <typename T>
+Status Base64Encode(StringPiece source, bool with_padding, T* encoded);
+template <typename T>
+Status Base64Encode(StringPiece source,
+                    T* encoded);  // with_padding=false.
+
+/// \brief Converts data from web-safe base64 encoding.
+///
+/// See https://en.wikipedia.org/wiki/Base64
+template <typename T>
+Status Base64Decode(StringPiece data, T* decoded);
+
+// Explicit instantiations defined in base64.cc.
+extern template Status Base64Decode<std::string>(StringPiece data,
+                                                 std::string* decoded);
+extern template Status Base64Encode<std::string>(StringPiece source,
+                                                 std::string* encoded);
+extern template Status Base64Encode<std::string>(StringPiece source,
+                                                 bool with_padding,
+                                                 std::string* encoded);
+
+extern template Status Base64Decode<tstring>(StringPiece data,
+                                             tstring* decoded);
+extern template Status Base64Encode<tstring>(StringPiece source,
+                                             tstring* encoded);
+extern template Status Base64Encode<tstring>(StringPiece source,
+                                             bool with_padding,
+                                             tstring* encoded);
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_BASE64_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/bfloat16.h

@@ -0,0 +1,27 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_BFLOAT16_H_
+#define TENSORFLOW_TSL_PLATFORM_BFLOAT16_H_
+
+// clang-format off
+#include "Eigen/Core"  // from @eigen_archive
+// clang-format on
+
+namespace tsl {
+typedef Eigen::bfloat16 bfloat16;
+}  // end namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_BFLOAT16_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/blocking_counter.h

@@ -0,0 +1,80 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_BLOCKING_COUNTER_H_
+#define TENSORFLOW_TSL_PLATFORM_BLOCKING_COUNTER_H_
+
+#include <atomic>
+
+#include "tsl/platform/logging.h"
+#include "tsl/platform/mutex.h"
+
+namespace tsl {
+
+class BlockingCounter {
+ public:
+  BlockingCounter(int initial_count)
+      : state_(initial_count << 1), notified_(false) {
+    CHECK_GE(initial_count, 0);
+    DCHECK_EQ((initial_count << 1) >> 1, initial_count);
+  }
+
+  ~BlockingCounter() {}
+
+  inline void DecrementCount() {
+    unsigned int v = state_.fetch_sub(2, std::memory_order_acq_rel) - 2;
+    if (v != 1) {
+      DCHECK_NE(((v + 2) & ~1), 0);
+      return;  // either count has not dropped to 0, or waiter is not waiting
+    }
+    mutex_lock l(mu_);
+    DCHECK(!notified_);
+    notified_ = true;
+    cond_var_.notify_all();
+  }
+
+  inline void Wait() {
+    unsigned int v = state_.fetch_or(1, std::memory_order_acq_rel);
+    if ((v >> 1) == 0) return;
+    mutex_lock l(mu_);
+    while (!notified_) {
+      cond_var_.wait(l);
+    }
+  }
+  // Wait for the specified time, return false iff the count has not dropped to
+  // zero before the timeout expired.
+  inline bool WaitFor(std::chrono::milliseconds ms) {
+    unsigned int v = state_.fetch_or(1, std::memory_order_acq_rel);
+    if ((v >> 1) == 0) return true;
+    mutex_lock l(mu_);
+    while (!notified_) {
+      const std::cv_status status = cond_var_.wait_for(l, ms);
+      if (status == std::cv_status::timeout) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+ private:
+  mutex mu_;
+  condition_variable cond_var_;
+  std::atomic<int> state_;  // low bit is waiter flag
+  bool notified_;
+};
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_BLOCKING_COUNTER_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/casts.h

@@ -0,0 +1,31 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_CASTS_H_
+#define TENSORFLOW_TSL_PLATFORM_CASTS_H_
+
+#include "tsl/platform/platform.h"
+
+#if defined(PLATFORM_GOOGLE)
+#include "tsl/platform/google/casts.h"  // IWYU pragma: export
+#elif defined(PLATFORM_POSIX) || defined(PLATFORM_POSIX_ANDROID) ||    \
+    defined(PLATFORM_GOOGLE_ANDROID) || defined(PLATFORM_POSIX_IOS) || \
+    defined(PLATFORM_GOOGLE_IOS) || defined(PLATFORM_WINDOWS)
+#include "tsl/platform/default/casts.h"  // IWYU pragma: export
+#else
+#error Define the appropriate PLATFORM_<foo> macro for this platform
+#endif
+
+#endif  // TENSORFLOW_TSL_PLATFORM_CASTS_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/coding.h

@@ -0,0 +1,71 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Endian-neutral encoding:
+// * Fixed-length numbers are encoded with least-significant byte first
+// * In addition we support variable length "varint" encoding
+// * Strings are encoded prefixed by their length in varint format
+
+#ifndef TENSORFLOW_TSL_PLATFORM_CODING_H_
+#define TENSORFLOW_TSL_PLATFORM_CODING_H_
+
+#include "tsl/platform/stringpiece.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace core {
+
+// Maximum number of bytes occupied by a varint32.
+static const int kMaxVarint32Bytes = 5;
+
+// Maximum number of bytes occupied by a varint64.
+static const int kMaxVarint64Bytes = 10;
+
+// Lower-level versions of Put... that write directly into a character buffer
+// REQUIRES: dst has enough space for the value being written
+extern void EncodeFixed16(char* dst, uint16 value);
+extern void EncodeFixed32(char* dst, uint32 value);
+extern void EncodeFixed64(char* dst, uint64 value);
+extern void PutFixed16(string* dst, uint16 value);
+extern void PutFixed32(string* dst, uint32 value);
+extern void PutFixed64(string* dst, uint64 value);
+
+extern void PutVarint32(string* dst, uint32 value);
+extern void PutVarint64(string* dst, uint64 value);
+
+extern void PutVarint32(tstring* dst, uint32 value);
+extern void PutVarint64(tstring* dst, uint64 value);
+
+extern bool GetVarint32(StringPiece* input, uint32* value);
+extern bool GetVarint64(StringPiece* input, uint64* value);
+
+extern const char* GetVarint32Ptr(const char* p, const char* limit, uint32* v);
+extern const char* GetVarint64Ptr(const char* p, const char* limit, uint64* v);
+
+// Internal routine for use by fallback path of GetVarint32Ptr
+extern const char* GetVarint32PtrFallback(const char* p, const char* limit,
+                                          uint32* value);
+extern const char* GetVarint32Ptr(const char* p, const char* limit,
+                                  uint32* value);
+extern char* EncodeVarint32(char* dst, uint32 v);
+extern char* EncodeVarint64(char* dst, uint64 v);
+
+// Returns the length of the varint32 or varint64 encoding of "v"
+extern int VarintLength(uint64_t v);
+
+}  // namespace core
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_CODING_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/context.h

@@ -0,0 +1,47 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_CONTEXT_H_
+#define TENSORFLOW_TSL_PLATFORM_CONTEXT_H_
+
+#include "tsl/platform/platform.h"
+
+namespace tsl {
+
+enum class ContextKind {
+  // Initial state with default (empty) values.
+  kDefault,
+  // Initial state inherited from the creating or scheduling thread.
+  kThread,
+};
+
+// Context is a container for request-specific information that should be passed
+// to threads that perform related work. The default constructor should capture
+// all relevant context.
+class Context;
+
+// Scoped object that sets the current thread's context until the object is
+// destroyed.
+class WithContext;
+
+}  // namespace tsl
+
+#if defined(PLATFORM_GOOGLE)
+#include "tsl/platform/google/context.h"  // IWYU pragma: export
+#else
+#include "tsl/platform/default/context.h"  // IWYU pragma: export
+#endif
+
+#endif  // TENSORFLOW_TSL_PLATFORM_CONTEXT_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/cord.h

@@ -0,0 +1,26 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_CORD_H_
+#define TENSORFLOW_TSL_PLATFORM_CORD_H_
+
+// It seems CORD doesn't work well with CUDA <= 10.2
+#if !defined(__CUDACC__) || ((defined(__CUDACC__) && CUDA_VERSION > 10020))
+#include "absl/strings/cord.h"  // IWYU pragma: export
+#define TF_CORD_SUPPORT 1
+
+#endif  // __CUDACC__
+
+#endif  // TENSORFLOW_TSL_PLATFORM_CORD_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/cpu_info.h

@@ -0,0 +1,171 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_CPU_INFO_H_
+#define TENSORFLOW_TSL_PLATFORM_CPU_INFO_H_
+
+#include <string>
+
+// TODO(ahentz): This is not strictly required here but, for historical
+// reasons, many people depend on cpu_info.h in order to use kLittleEndian.
+#include "tsl/platform/byte_order.h"
+
+#if defined(_MSC_VER)
+// included so __cpuidex function is available for GETCPUID on Windows
+#include <intrin.h>
+#endif
+
+namespace tsl {
+namespace port {
+
+// Returns an estimate of the number of schedulable CPUs for this
+// process.  Usually, it's constant throughout the lifetime of a
+// process, but it might change if the underlying cluster management
+// software can change it dynamically.  If the underlying call fails, a default
+// value (e.g. `4`) may be returned.
+int NumSchedulableCPUs();
+
+// Returns an estimate for the maximum parallelism for this process.
+// Applications should avoid running more than this number of threads with
+// intensive workloads concurrently to avoid performance degradation and
+// contention.
+// This value is either the number of schedulable CPUs, or a value specific to
+// the underlying cluster management. Applications should assume this value can
+// change throughout the lifetime of the process. This function must not be
+// called during initialization, i.e., before main() has started.
+int MaxParallelism();
+
+// Returns an estimate for the maximum parallelism for this process on the
+// provided numa node, or any numa node if `numa_node` is kNUMANoAffinity.
+// See MaxParallelism() for more information.
+int MaxParallelism(int numa_node);
+
+// Returns the total number of CPUs on the system.  This number should
+// not change even if the underlying cluster management software may
+// change the number of schedulable CPUs.  Unlike `NumSchedulableCPUs`, if the
+// underlying call fails, an invalid value of -1 will be returned;
+// the user must check for validity.
+static constexpr int kUnknownCPU = -1;
+int NumTotalCPUs();
+
+// Returns the id of the current CPU.  Returns -1 if the current CPU cannot be
+// identified.  If successful, the return value will be in [0, NumTotalCPUs()).
+int GetCurrentCPU();
+
+// Returns an estimate of the number of hyperthreads per physical core
+// on the CPU
+int NumHyperthreadsPerCore();
+
+// Mostly ISA related features that we care about
+enum CPUFeature {
+  // Do not change numeric assignments.
+  MMX = 0,
+  SSE = 1,
+  SSE2 = 2,
+  SSE3 = 3,
+  SSSE3 = 4,
+  SSE4_1 = 5,
+  SSE4_2 = 6,
+  CMOV = 7,
+  CMPXCHG8B = 8,
+  CMPXCHG16B = 9,
+  POPCNT = 10,
+  AES = 11,
+  AVX = 12,
+  RDRAND = 13,
+  AVX2 = 14,
+  FMA = 15,
+  F16C = 16,
+  PCLMULQDQ = 17,
+  RDSEED = 18,
+  ADX = 19,
+  SMAP = 20,
+
+  // Prefetch Vector Data Into Caches with Intent to Write and T1 Hint
+  // http://www.felixcloutier.com/x86/PREFETCHWT1.html.
+  // You probably want PREFETCHW instead.
+  PREFETCHWT1 = 21,
+
+  BMI1 = 22,
+  BMI2 = 23,
+  HYPERVISOR = 25,  // 0 when on a real CPU, 1 on (well-behaved) hypervisor.
+
+  // Prefetch Data into Caches in Anticipation of a Write (3D Now!).
+  // http://www.felixcloutier.com/x86/PREFETCHW.html
+  PREFETCHW = 26,
+
+  // AVX-512: 512-bit vectors (plus masking, etc.) in Knights Landing,
+  // Skylake, Xeon, etc. Each of these entries is a different subset of
+  // instructions, various combinations of which occur on various CPU types.
+  AVX512F = 27,        // Foundation
+  AVX512CD = 28,       // Conflict detection
+  AVX512ER = 29,       // Exponential and reciprocal
+  AVX512PF = 30,       // Prefetching
+  AVX512VL = 31,       // Shorter vector lengths
+  AVX512BW = 32,       // Byte and word
+  AVX512DQ = 33,       // Dword and qword
+  AVX512VBMI = 34,     // Bit manipulation
+  AVX512IFMA = 35,     // Integer multiply-add
+  AVX512_4VNNIW = 36,  // Integer neural network (Intel Xeon Phi only)
+  AVX512_4FMAPS = 37,  // Floating point neural network (Intel Xeon Phi only)
+  AVX512_VNNI = 38,    // Integer neural network
+  AVX512_BF16 = 39,    // Bfloat16 neural network
+
+  // AVX version of AVX512_VNNI in CPUs such as Alder Lake and Sapphire Rapids.
+  AVX_VNNI = 40,  // Integer neural network
+
+  // AMX: Advanced Matrix Extension in Sapphire Rapids.
+  // Perform matrix multiplication on the Tile Matrix Multiply (TMUL) unit,
+  // supporting two popular data types in neural networks, int8 and bfloat16.
+  AMX_TILE = 41,  // Tile configuration and load/store
+  AMX_INT8 = 42,  // Int8 tile matrix multiplication
+  AMX_BF16 = 43,  // Bfloat16 tile matrix multiplication
+
+  AVX512_FP16 = 44,     // Float16 neural network
+  AMX_FP16 = 45,        // Float16 tile matrix multiplication
+  AVX_NE_CONVERT = 46,  // Instructions for faster bfloat16, float16 convert.
+  AVX_VNNI_INT8 = 47,   // VNNI instructions for combinations of u8, s8 dtypes.
+};
+
+enum Aarch64CPU {
+  ARM_NEOVERSE_N1 = 0,  // ARM NEOVERSE N1
+  ARM_NEOVERSE_V1 = 1,  // ARM NEOVERSE V1
+};
+// Checks whether the current AArch64 processor is supported.
+bool TestAarch64CPU(Aarch64CPU cpu);
+
+// Checks whether the current processor supports one of the features above.
+// Checks CPU registers to return hardware capabilities.
+bool TestCPUFeature(CPUFeature feature);
+
+// Returns CPU Vendor string (i.e. 'GenuineIntel', 'AuthenticAMD', etc.)
+std::string CPUVendorIDString();
+
+// Returns CPU family.
+int CPUFamily();
+
+// Returns CPU model number.
+int CPUModelNum();
+
+// Returns nominal core processor cycles per second of each processor.
+double NominalCPUFrequency();
+
+// Returns num of hyperthreads per physical core
+int CPUIDNumSMT();
+
+}  // namespace port
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_CPU_INFO_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/ctstring.h

@@ -0,0 +1,123 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_CTSTRING_H_
+#define TENSORFLOW_TSL_PLATFORM_CTSTRING_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "tsl/platform/ctstring_internal.h"
+
+// Initialize a new tstring.  This must be called before using any function
+// below.
+inline void TF_TString_Init(TF_TString *str);
+// Deallocate a tstring.
+inline void TF_TString_Dealloc(TF_TString *str);
+
+// Resizes `str' to `new_size'.  This function will appropriately grow or shrink
+// the string buffer to fit a `new_size' string.  Grown regions of the string
+// will be initialized with `c'.
+inline char *TF_TString_Resize(TF_TString *str, size_t new_size, char c);
+// Similar to TF_TString_Resize, except the newly allocated regions will remain
+// uninitialized.  This is useful if you plan on overwriting the newly grown
+// regions immediately after allocation; doing so will elide a superfluous
+// initialization of the new buffer.
+inline char *TF_TString_ResizeUninitialized(TF_TString *str, size_t new_size);
+// Reserves a string buffer with a capacity of at least `new_cap'.
+// Reserve will not change the size, or the contents of the existing
+// string.  This is useful if you have a rough idea of `str's upperbound in
+// size, and want to avoid allocations as you append to `str'. It should not be
+// considered safe to write in the region between size and capacity; explicitly
+// resize before doing so.
+inline void TF_TString_Reserve(TF_TString *str, size_t new_cap);
+// Similar to TF_TString_Reserve, except that we ensure amortized growth, i.e.
+// that we grow the capacity by at least a constant factor >1.
+inline void TF_TString_ReserveAmortized(TF_TString *str, size_t new_cap);
+
+// Returns the size of the string.
+inline size_t TF_TString_GetSize(const TF_TString *str);
+// Returns the capacity of the string buffer.  It should not be considered safe
+// to write in the region between size and capacity---call Resize or
+// ResizeUninitialized before doing so.
+inline size_t TF_TString_GetCapacity(const TF_TString *str);
+// Returns the underlying type of the tstring:
+// TF_TSTR_SMALL:
+//    Small string optimization; the contents of strings
+//    less than 22-bytes are stored in the TF_TString struct. This avoids any
+//    heap allocations.
+// TF_TSTR_LARGE:
+//    Heap allocated string.
+// TF_TSTR_OFFSET: (currently unused)
+//    An offset defined string.  The string buffer begins at an internally
+//    defined little-endian offset from `str'; i.e. GetDataPointer() = str +
+//    offset.  This type is useful for memory mapping or reading string tensors
+//    directly from file, without the need to deserialize the data.  For
+//    security reasons, it is imperative that OFFSET based string tensors are
+//    validated before use, or are from a trusted source.
+// TF_TSTR_VIEW:
+//    A view into an unowned character string.
+//
+// NOTE:
+//    VIEW and OFFSET types are immutable, so any modifcation via Append,
+//    AppendN, or GetMutableDataPointer of a VIEW/OFFSET based tstring will
+//    result in a conversion to an owned type (SMALL/LARGE).
+inline TF_TString_Type TF_TString_GetType(const TF_TString *str);
+
+// Returns a const char pointer to the start of the underlying string. The
+// underlying character buffer may not be null-terminated.
+inline const char *TF_TString_GetDataPointer(const TF_TString *str);
+// Returns a char pointer to a mutable representation of the underlying string.
+// In the case of VIEW and OFFSET types, `src' is converted to an owned type
+// (SMALL/LARGE).  The underlying character buffer may not be null-terminated.
+inline char *TF_TString_GetMutableDataPointer(TF_TString *str);
+
+// Sets `dst' as a VIEW type to `src'.  `dst' will not take ownership of `src'.
+// It is the user's responsibility to ensure that the lifetime of `src' exceeds
+// `dst'.  Any mutations to `dst' via Append, AppendN, or GetMutableDataPointer,
+// will result in a copy into an owned SMALL or LARGE type, and will not modify
+// `src'.
+inline void TF_TString_AssignView(TF_TString *dst, const char *src,
+                                  size_t size);
+
+// Appends `src' onto `dst'.  If `dst' is a VIEW or OFFSET type, it will first
+// be converted to an owned LARGE or SMALL type.  `dst' should not point to
+// memory owned by `src'.
+inline void TF_TString_Append(TF_TString *dst, const TF_TString *src);
+inline void TF_TString_AppendN(TF_TString *dst, const char *src, size_t size);
+
+// Copy/Move/Assign semantics
+//
+//        | src     | dst          | complexity
+// Copy   | *       |  SMALL/LARGE | fixed/O(size)
+// Assign | SMALL   |  SMALL       | fixed
+// Assign | OFFSET  |  VIEW        | fixed
+// Assign | VIEW    |  VIEW        | fixed
+// Assign | LARGE   |  LARGE       | O(size)
+// Move   | *       |  same as src | fixed
+
+// Copies `src' to `dst'. `dst' will be an owned type (SMALL/LARGE). `src'
+// should not point to memory owned by `dst'.
+inline void TF_TString_Copy(TF_TString *dst, const char *src, size_t size);
+// Assigns a `src' tstring to `dst'.  An OFFSET `src' type will yield a `VIEW'
+// `dst'.  LARGE `src' types will be copied to a new buffer; all other `src'
+// types will incur a fixed cost.
+inline void TF_TString_Assign(TF_TString *dst, const TF_TString *src);
+// Moves a `src' tstring to `dst'.  Moving a LARGE `src' to `dst' will result in
+// a valid but unspecified `src'.  This function incurs a fixed cost for all
+// inputs.
+inline void TF_TString_Move(TF_TString *dst, TF_TString *src);
+
+#endif  // TENSORFLOW_TSL_PLATFORM_CTSTRING_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/cuda_libdevice_path.h

@@ -0,0 +1,49 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_CUDA_LIBDEVICE_PATH_H_
+#define TENSORFLOW_TSL_PLATFORM_CUDA_LIBDEVICE_PATH_H_
+
+#include <string>
+#include <vector>
+
+namespace tsl {
+
+// Returns, in order of preference, potential locations of the root directory of
+// the CUDA SDK, which contains sub-folders such as bin, lib64, and nvvm.
+std::vector<std::string> CandidateCudaRoots();
+
+// A convenient wrapper for CandidateCudaRoots, which allows supplying a
+// preferred location (inserted first in the output vector), and a flag whether
+// the current working directory should be searched (inserted last).
+inline std::vector<std::string> CandidateCudaRoots(
+    std::string preferred_location, bool use_working_directory = true) {
+  std::vector<std::string> candidates = CandidateCudaRoots();
+  if (!preferred_location.empty()) {
+    candidates.insert(candidates.begin(), preferred_location);
+  }
+
+  // "." is our last resort, even though it probably won't work.
+  candidates.push_back(".");
+
+  return candidates;
+}
+
+// Returns true if we should prefer ptxas from PATH.
+bool PreferPtxasFromPath();
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_CUDA_LIBDEVICE_PATH_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/demangle.h

@@ -0,0 +1,34 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_DEMANGLE_H_
+#define TENSORFLOW_TSL_PLATFORM_DEMANGLE_H_
+
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace port {
+
+// If the compiler supports, demangle a mangled symbol name and return
+// the demangled name. Otherwise, returns 'mangled' as is.
+string Demangle(const char* mangled);
+inline string Demangle(const string mangled) {
+  return Demangle(mangled.c_str());
+}
+
+}  // namespace port
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_DEMANGLE_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/denormal.h

@@ -0,0 +1,94 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_DENORMAL_H_
+#define TENSORFLOW_TSL_PLATFORM_DENORMAL_H_
+
+#include "tsl/platform/macros.h"
+
+namespace tsl {
+namespace port {
+
+// State for handling of denormals.
+class DenormalState {
+ public:
+  DenormalState(bool flush_to_zero, bool denormals_are_zero)
+      : flush_to_zero_(flush_to_zero),
+        denormals_are_zero_(denormals_are_zero) {}
+
+  // Output denormals of floating-point operations are flushed to zero.
+  inline bool flush_to_zero() const { return flush_to_zero_; }
+
+  // Input denormals to floating-point operations are treated as zero.
+  inline bool denormals_are_zero() const { return denormals_are_zero_; }
+
+  bool operator==(const DenormalState& other) const;
+  bool operator!=(const DenormalState& other) const;
+
+ private:
+  bool flush_to_zero_;
+  bool denormals_are_zero_;
+};
+
+// Gets the platform's current state for handling denormals.
+DenormalState GetDenormalState();
+
+// Sets handling of denormals if the platform allows it. Returns `true` if the
+// platform supports setting denormals to the specified state. Otherwise the
+// denormal state remains unmodified and false is returned.
+bool SetDenormalState(const DenormalState& state);
+
+// Remembers the flush denormal state on construction and restores that same
+// state on destruction.
+class ScopedRestoreFlushDenormalState {
+ public:
+  ScopedRestoreFlushDenormalState();
+  ~ScopedRestoreFlushDenormalState();
+
+ private:
+  DenormalState denormal_state_;
+  ScopedRestoreFlushDenormalState(const ScopedRestoreFlushDenormalState&) =
+      delete;
+  void operator=(const ScopedRestoreFlushDenormalState&) = delete;
+};
+
+// While this class is active, denormal floating point numbers are flushed
+// to zero.  The destructor restores the original flags.
+class ScopedFlushDenormal {
+ public:
+  ScopedFlushDenormal();
+
+ private:
+  ScopedRestoreFlushDenormalState restore_;
+  ScopedFlushDenormal(const ScopedFlushDenormal&) = delete;
+  void operator=(const ScopedFlushDenormal&) = delete;
+};
+
+// While this class is active, denormal floating point numbers are not flushed
+// to zero.  The destructor restores the original flags.
+class ScopedDontFlushDenormal {
+ public:
+  ScopedDontFlushDenormal();
+
+ private:
+  ScopedRestoreFlushDenormalState restore_;
+  ScopedDontFlushDenormal(const ScopedDontFlushDenormal&) = delete;
+  void operator=(const ScopedDontFlushDenormal&) = delete;
+};
+
+}  // namespace port
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_DENORMAL_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/dso_loader.h

@@ -0,0 +1,31 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_DSO_LOADER_H_
+#define TENSORFLOW_TSL_PLATFORM_DSO_LOADER_H_
+
+#include "tsl/platform/platform.h"
+
+// Include appropriate platform-dependent implementations
+#if defined(PLATFORM_GOOGLE) || defined(PLATFORM_CHROMIUMOS)
+#include "tsl/platform/google/dso_loader.h"
+#elif defined(PLATFORM_POSIX) || defined(PLATFORM_POSIX_ANDROID) || \
+    defined(PLATFORM_GOOGLE_ANDROID) || defined(PLATFORM_WINDOWS)
+#include "tsl/platform/default/dso_loader.h"
+#else
+#error Define the appropriate PLATFORM_<foo> macro for this platform
+#endif
+
+#endif  // TENSORFLOW_TSL_PLATFORM_DSO_LOADER_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/dynamic_annotations.h

@@ -0,0 +1,36 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_DYNAMIC_ANNOTATIONS_H_
+#define TENSORFLOW_TSL_PLATFORM_DYNAMIC_ANNOTATIONS_H_
+
+#include "absl/base/dynamic_annotations.h"
+
+#define TF_ANNOTATE_MEMORY_IS_INITIALIZED(ptr, bytes) \
+  ANNOTATE_MEMORY_IS_INITIALIZED(ptr, bytes)
+
+#define TF_ANNOTATE_BENIGN_RACE(ptr, description) \
+  ANNOTATE_BENIGN_RACE(ptr, description)
+
+// Tell MemorySanitizer to relax the handling of a given function. All "Use of
+// uninitialized value" warnings from such functions will be suppressed, and
+// all values loaded from memory will be considered fully initialized.
+#ifdef MEMORY_SANITIZER
+#define TF_ATTRIBUTE_NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
+#else
+#define TF_ATTRIBUTE_NO_SANITIZE_MEMORY
+#endif
+
+#endif  // TENSORFLOW_TSL_PLATFORM_DYNAMIC_ANNOTATIONS_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/env.h

@@ -0,0 +1,706 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_ENV_H_
+#define TENSORFLOW_TSL_PLATFORM_ENV_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "absl/functional/any_invocable.h"
+#include "tsl/platform/env_time.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/file_system.h"
+#include "tsl/platform/macros.h"
+#include "tsl/platform/mutex.h"
+#include "tsl/platform/numa.h"
+#include "tsl/platform/platform.h"
+#include "tsl/platform/protobuf.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/stringpiece.h"
+#include "tsl/platform/types.h"
+
+// Delete leaked Windows definitions.
+#ifdef PLATFORM_WINDOWS
+#undef CopyFile
+#undef DeleteFile
+#endif
+
+namespace tsl {
+
+class Thread;
+struct ThreadOptions;
+
+/// \brief An interface used by the tensorflow implementation to
+/// access operating system functionality like the filesystem etc.
+///
+/// Callers may wish to provide a custom Env object to get fine grain
+/// control.
+///
+/// All Env implementations are safe for concurrent access from
+/// multiple threads without any external synchronization.
+class Env {
+ public:
+  Env();
+  virtual ~Env() = default;
+
+  /// \brief Returns a default environment suitable for the current operating
+  /// system.
+  ///
+  /// Sophisticated users may wish to provide their own Env
+  /// implementation instead of relying on this default environment.
+  ///
+  /// The result of Default() belongs to this library and must never be deleted.
+  static Env* Default();
+
+  /// \brief Returns the FileSystem object to handle operations on the file
+  /// specified by 'fname'. The FileSystem object is used as the implementation
+  /// for the file system related (non-virtual) functions that follow.
+  /// Returned FileSystem object is still owned by the Env object and will
+  // (might) be destroyed when the environment is destroyed.
+  virtual Status GetFileSystemForFile(const std::string& fname,
+                                      FileSystem** result);
+
+  /// \brief Returns the file system schemes registered for this Env.
+  virtual Status GetRegisteredFileSystemSchemes(
+      std::vector<std::string>* schemes);
+
+  /// \brief Register a file system for a scheme.
+  virtual Status RegisterFileSystem(const std::string& scheme,
+                                    FileSystemRegistry::Factory factory);
+
+  /// \brief Register a modular file system for a scheme.
+  ///
+  /// Same as `RegisterFileSystem` but for filesystems provided by plugins.
+  ///
+  /// TODO(b/139060984): After all filesystems are converted, make this be the
+  /// canonical registration function.
+  virtual Status RegisterFileSystem(const std::string& scheme,
+                                    std::unique_ptr<FileSystem> filesystem);
+
+  Status SetOption(const std::string& scheme, const std::string& key,
+                   const std::string& value);
+
+  Status SetOption(const std::string& scheme, const std::string& key,
+                   const std::vector<string>& values);
+
+  Status SetOption(const std::string& scheme, const std::string& key,
+                   const std::vector<int64_t>& values);
+
+  Status SetOption(const std::string& scheme, const std::string& key,
+                   const std::vector<double>& values);
+
+  /// \brief Flush filesystem caches for all registered filesystems.
+  Status FlushFileSystemCaches();
+
+  /// \brief Creates a brand new random access read-only file with the
+  /// specified name.
+
+  /// On success, stores a pointer to the new file in
+  /// *result and returns OK.  On failure stores NULL in *result and
+  /// returns non-OK.  If the file does not exist, returns a non-OK
+  /// status.
+  ///
+  /// The returned file may be concurrently accessed by multiple threads.
+  ///
+  /// The ownership of the returned RandomAccessFile is passed to the caller
+  /// and the object should be deleted when is not used. The file object
+  /// shouldn't live longer than the Env object.
+  Status NewRandomAccessFile(const std::string& fname,
+                             std::unique_ptr<RandomAccessFile>* result);
+
+  Status NewRandomAccessFile(const std::string& fname, TransactionToken* token,
+                             std::unique_ptr<RandomAccessFile>* result) {
+    // We duplicate these methods due to Google internal coding style prevents
+    // virtual functions with default arguments. See PR #41615.
+    return OkStatus();
+  }
+
+  /// \brief Creates an object that writes to a new file with the specified
+  /// name.
+  ///
+  /// Deletes any existing file with the same name and creates a
+  /// new file.  On success, stores a pointer to the new file in
+  /// *result and returns OK.  On failure stores NULL in *result and
+  /// returns non-OK.
+  ///
+  /// The returned file will only be accessed by one thread at a time.
+  ///
+  /// The ownership of the returned WritableFile is passed to the caller
+  /// and the object should be deleted when is not used. The file object
+  /// shouldn't live longer than the Env object.
+  Status NewWritableFile(const std::string& fname,
+                         std::unique_ptr<WritableFile>* result);
+
+  Status NewWritableFile(const std::string& fname, TransactionToken* token,
+                         std::unique_ptr<WritableFile>* result) {
+    return OkStatus();
+  }
+
+  /// \brief Creates an object that either appends to an existing file, or
+  /// writes to a new file (if the file does not exist to begin with).
+  ///
+  /// On success, stores a pointer to the new file in *result and
+  /// returns OK.  On failure stores NULL in *result and returns
+  /// non-OK.
+  ///
+  /// The returned file will only be accessed by one thread at a time.
+  ///
+  /// The ownership of the returned WritableFile is passed to the caller
+  /// and the object should be deleted when is not used. The file object
+  /// shouldn't live longer than the Env object.
+  Status NewAppendableFile(const std::string& fname,
+                           std::unique_ptr<WritableFile>* result);
+
+  Status NewAppendableFile(const std::string& fname, TransactionToken* token,
+                           std::unique_ptr<WritableFile>* result) {
+    return OkStatus();
+  }
+  /// \brief Creates a readonly region of memory with the file context.
+  ///
+  /// On success, it returns a pointer to read-only memory region
+  /// from the content of file fname. The ownership of the region is passed to
+  /// the caller. On failure stores nullptr in *result and returns non-OK.
+  ///
+  /// The returned memory region can be accessed from many threads in parallel.
+  ///
+  /// The ownership of the returned ReadOnlyMemoryRegion is passed to the caller
+  /// and the object should be deleted when is not used. The memory region
+  /// object shouldn't live longer than the Env object.
+  Status NewReadOnlyMemoryRegionFromFile(
+      const std::string& fname, std::unique_ptr<ReadOnlyMemoryRegion>* result);
+
+  Status NewReadOnlyMemoryRegionFromFile(
+      const std::string& fname, TransactionToken* token,
+      std::unique_ptr<ReadOnlyMemoryRegion>* result) {
+    return OkStatus();
+  }
+
+  /// Returns OK if the named path exists and NOT_FOUND otherwise.
+  Status FileExists(const std::string& fname);
+
+  Status FileExists(const std::string& fname, TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// Returns true if all the listed files exist, false otherwise.
+  /// if status is not null, populate the vector with a detailed status
+  /// for each file.
+  bool FilesExist(const std::vector<string>& files,
+                  std::vector<Status>* status);
+
+  bool FilesExist(const std::vector<string>& files, TransactionToken* token,
+                  std::vector<Status>* status) {
+    return true;
+  }
+
+  /// \brief Stores in *result the names of the children of the specified
+  /// directory. The names are relative to "dir".
+  ///
+  /// Original contents of *results are dropped.
+  Status GetChildren(const std::string& dir, std::vector<string>* result);
+
+  Status GetChildren(const std::string& dir, TransactionToken* token,
+                     std::vector<string>* result) {
+    return OkStatus();
+  }
+
+  /// \brief Returns true if the path matches the given pattern. The wildcards
+  /// allowed in pattern are described in FileSystem::GetMatchingPaths.
+  virtual bool MatchPath(const std::string& path,
+                         const std::string& pattern) = 0;
+
+  /// \brief Given a pattern, stores in *results the set of paths that matches
+  /// that pattern. *results is cleared.
+  ///
+  /// More details about `pattern` in FileSystem::GetMatchingPaths.
+  virtual Status GetMatchingPaths(const std::string& pattern,
+                                  std::vector<string>* results);
+
+  Status GetMatchingPaths(const std::string& pattern, TransactionToken* token,
+                          std::vector<string>* results) {
+    return OkStatus();
+  }
+
+  /// Deletes the named file.
+  Status DeleteFile(const std::string& fname);
+
+  Status DeleteFile(const std::string& fname, TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// \brief Deletes the specified directory and all subdirectories and files
+  /// underneath it. This is accomplished by traversing the directory tree
+  /// rooted at dirname and deleting entries as they are encountered.
+  ///
+  /// If dirname itself is not readable or does not exist, *undeleted_dir_count
+  /// is set to 1, *undeleted_file_count is set to 0 and an appropriate status
+  /// (e.g. NOT_FOUND) is returned.
+  ///
+  /// If dirname and all its descendants were successfully deleted, TF_OK is
+  /// returned and both error counters are set to zero.
+  ///
+  /// Otherwise, while traversing the tree, undeleted_file_count and
+  /// undeleted_dir_count are updated if an entry of the corresponding type
+  /// could not be deleted. The returned error status represents the reason that
+  /// any one of these entries could not be deleted.
+  ///
+  /// REQUIRES: undeleted_files, undeleted_dirs to be not null.
+  ///
+  /// Typical return codes:
+  ///  * OK - dirname exists and we were able to delete everything underneath.
+  ///  * NOT_FOUND - dirname doesn't exist
+  ///  * PERMISSION_DENIED - dirname or some descendant is not writable
+  ///  * UNIMPLEMENTED - Some underlying functions (like Delete) are not
+  ///                    implemented
+  Status DeleteRecursively(const std::string& dirname, int64_t* undeleted_files,
+                           int64_t* undeleted_dirs);
+
+  Status DeleteRecursively(const std::string& dirname, TransactionToken* token,
+                           int64_t* undeleted_files, int64_t* undeleted_dirs) {
+    return OkStatus();
+  }
+
+  /// \brief Creates the specified directory and all the necessary
+  /// subdirectories. Typical return codes.
+  ///  * OK - successfully created the directory and sub directories, even if
+  ///         they were already created.
+  ///  * PERMISSION_DENIED - dirname or some subdirectory is not writable.
+  Status RecursivelyCreateDir(const std::string& dirname);
+
+  Status RecursivelyCreateDir(const std::string& dirname,
+                              TransactionToken* token) {
+    return OkStatus();
+  }
+  /// \brief Creates the specified directory. Typical return codes
+  ///  * OK - successfully created the directory.
+  ///  * ALREADY_EXISTS - directory already exists.
+  ///  * PERMISSION_DENIED - dirname is not writable.
+  Status CreateDir(const std::string& dirname);
+
+  Status CreateDir(const std::string& dirname, TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// Deletes the specified directory.
+  Status DeleteDir(const std::string& dirname);
+
+  Status DeleteDir(const std::string& dirname, TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// Obtains statistics for the given path.
+  Status Stat(const std::string& fname, FileStatistics* stat);
+
+  Status Stat(const std::string& fname, TransactionToken* token,
+              FileStatistics* stat) {
+    return OkStatus();
+  }
+
+  /// \brief Returns whether the given path is a directory or not.
+  /// Typical return codes (not guaranteed exhaustive):
+  ///  * OK - The path exists and is a directory.
+  ///  * FAILED_PRECONDITION - The path exists and is not a directory.
+  ///  * NOT_FOUND - The path entry does not exist.
+  ///  * PERMISSION_DENIED - Insufficient permissions.
+  ///  * UNIMPLEMENTED - The file factory doesn't support directories.
+  Status IsDirectory(const std::string& fname);
+
+  /// \brief Returns whether the given path is on a file system
+  /// that has atomic move capabilities. This can be used
+  /// to determine if there needs to be a temp location to safely write objects.
+  /// The second boolean argument has_atomic_move contains this information.
+  ///
+  /// Returns one of the following status codes (not guaranteed exhaustive):
+  ///  * OK - The path is on a recognized file system,
+  ///         so has_atomic_move holds the above information.
+  ///  * UNIMPLEMENTED - The file system of the path hasn't been implemented in
+  ///  TF
+  Status HasAtomicMove(const std::string& path, bool* has_atomic_move);
+
+  /// Stores the size of `fname` in `*file_size`.
+  Status GetFileSize(const std::string& fname, uint64* file_size);
+
+  Status GetFileSize(const std::string& fname, TransactionToken* token,
+                     uint64* file_size) {
+    return OkStatus();
+  }
+
+  /// \brief Renames file src to target. If target already exists, it will be
+  /// replaced.
+  Status RenameFile(const std::string& src, const std::string& target);
+
+  Status RenameFile(const std::string& src, const std::string& target,
+                    TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// \brief Copy the src to target.
+  Status CopyFile(const std::string& src, const std::string& target);
+
+  Status CopyFile(const std::string& src, const std::string& target,
+                  TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// \brief starts a new transaction on the filesystem that handles filename
+  Status StartTransaction(const std::string& filename,
+                          TransactionToken** token) {
+    *token = nullptr;
+    return OkStatus();
+  }
+
+  /// \brief Adds `path` to transaction in `token` if token belongs to
+  /// filesystem that handles the path.
+  Status AddToTransaction(const std::string& path, TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// \brief Get token for `path` or start a new transaction and add `path` to
+  /// it.
+  Status GetTokenOrStartTransaction(const std::string& path,
+                                    TransactionToken** token) {
+    *token = nullptr;
+    return OkStatus();
+  }
+
+  /// \brief Returns the transaction for `path` or nullptr in `token`
+  Status GetTransactionForPath(const std::string& path,
+                               TransactionToken** token) {
+    *token = nullptr;
+    return OkStatus();
+  }
+
+  /// \brief Finalizes the transaction
+  Status EndTransaction(TransactionToken* token) { return OkStatus(); }
+
+  /// \brief Returns the absolute path of the current executable. It resolves
+  /// symlinks if there is any.
+  std::string GetExecutablePath();
+
+  /// Creates a local unique temporary file name. Returns true if success.
+  bool LocalTempFilename(std::string* filename);
+
+  /// Creates a local unique file name that starts with |prefix| and ends with
+  /// |suffix|. Returns true if success.
+  bool CreateUniqueFileName(std::string* prefix, const std::string& suffix);
+
+  /// \brief Return the runfiles directory if running under bazel. Returns
+  /// the directory the executable is located in if not running under bazel.
+  virtual std::string GetRunfilesDir() = 0;
+
+  // TODO(jeff,sanjay): Add back thread/thread-pool support if needed.
+  // TODO(jeff,sanjay): if needed, tighten spec so relative to epoch, or
+  // provide a routine to get the absolute time.
+
+  /// \brief Returns the number of nano-seconds since the Unix epoch.
+  virtual uint64 NowNanos() const { return EnvTime::NowNanos(); }
+
+  /// \brief Returns the number of micro-seconds since the Unix epoch.
+  virtual uint64 NowMicros() const { return EnvTime::NowMicros(); }
+
+  /// \brief Returns the number of seconds since the Unix epoch.
+  virtual uint64 NowSeconds() const { return EnvTime::NowSeconds(); }
+
+  /// Sleeps/delays the thread for the prescribed number of micro-seconds.
+  virtual void SleepForMicroseconds(int64_t micros) = 0;
+
+  /// Returns the process ID of the calling process.
+  int32 GetProcessId();
+
+  /// \brief Returns a new thread that is running fn() and is identified
+  /// (for debugging/performance-analysis) by "name".
+  ///
+  /// Caller takes ownership of the result and must delete it eventually
+  /// (the deletion will block until fn() stops running).
+  virtual Thread* StartThread(
+      const ThreadOptions& thread_options, const std::string& name,
+      absl::AnyInvocable<void()> fn) TF_MUST_USE_RESULT = 0;
+
+  // Returns the thread id of calling thread.
+  // Posix: Returns pthread id which is only guaranteed to be unique within a
+  //        process.
+  // Windows: Returns thread id which is unique.
+  virtual int32 GetCurrentThreadId() = 0;
+
+  // Copies current thread name to "name". Returns true if success.
+  virtual bool GetCurrentThreadName(std::string* name) = 0;
+
+  // \brief Schedules the given closure on a thread-pool.
+  //
+  // NOTE(mrry): This closure may block.
+  virtual void SchedClosure(absl::AnyInvocable<void()> closure) = 0;
+
+  // \brief Schedules the given closure on a thread-pool after the given number
+  // of microseconds.
+  //
+  // NOTE(mrry): This closure must not block.
+  virtual void SchedClosureAfter(int64_t micros,
+                                 absl::AnyInvocable<void()> closure) = 0;
+
+  // \brief Load a dynamic library.
+  //
+  // Pass "library_filename" to a platform-specific mechanism for dynamically
+  // loading a library.  The rules for determining the exact location of the
+  // library are platform-specific and are not documented here.
+  //
+  // On success, returns a handle to the library in "*handle" and returns
+  // OK from the function.
+  // Otherwise returns nullptr in "*handle" and an error status from the
+  // function.
+  virtual Status LoadDynamicLibrary(const char* library_filename,
+                                    void** handle) = 0;
+
+  // \brief Get a pointer to a symbol from a dynamic library.
+  //
+  // "handle" should be a pointer returned from a previous call to LoadLibrary.
+  // On success, store a pointer to the located symbol in "*symbol" and return
+  // OK from the function. Otherwise, returns nullptr in "*symbol" and an error
+  // status from the function.
+  virtual Status GetSymbolFromLibrary(void* handle, const char* symbol_name,
+                                      void** symbol) = 0;
+
+  // \brief build the name of dynamic library.
+  //
+  // "name" should be name of the library.
+  // "version" should be the version of the library or NULL
+  // returns the name that LoadLibrary() can use
+  virtual std::string FormatLibraryFileName(const std::string& name,
+                                            const std::string& version) = 0;
+
+  // Returns a possible list of local temporary directories.
+  virtual void GetLocalTempDirectories(std::vector<string>* list) = 0;
+
+ private:
+  std::unique_ptr<FileSystemRegistry> file_system_registry_;
+  Env(const Env&) = delete;
+  void operator=(const Env&) = delete;
+};
+
+/// \brief An implementation of Env that forwards all calls to another Env.
+///
+/// May be useful to clients who wish to override just part of the
+/// functionality of another Env.
+class EnvWrapper : public Env {
+ public:
+  /// Initializes an EnvWrapper that delegates all calls to *t
+  explicit EnvWrapper(Env* t) : target_(t) {}
+  ~EnvWrapper() override;
+
+  /// Returns the target to which this Env forwards all calls
+  Env* target() const { return target_; }
+
+  Status GetFileSystemForFile(const std::string& fname,
+                              FileSystem** result) override {
+    return target_->GetFileSystemForFile(fname, result);
+  }
+
+  Status GetRegisteredFileSystemSchemes(std::vector<string>* schemes) override {
+    return target_->GetRegisteredFileSystemSchemes(schemes);
+  }
+
+  Status RegisterFileSystem(const std::string& scheme,
+                            FileSystemRegistry::Factory factory) override {
+    return target_->RegisterFileSystem(scheme, factory);
+  }
+
+  bool MatchPath(const std::string& path, const std::string& pattern) override {
+    return target_->MatchPath(path, pattern);
+  }
+
+  uint64 NowMicros() const override { return target_->NowMicros(); }
+  void SleepForMicroseconds(int64_t micros) override {
+    target_->SleepForMicroseconds(micros);
+  }
+  Thread* StartThread(const ThreadOptions& thread_options,
+                      const std::string& name,
+                      absl::AnyInvocable<void()> fn) override {
+    return target_->StartThread(thread_options, name, std::move(fn));
+  }
+  int32 GetCurrentThreadId() override { return target_->GetCurrentThreadId(); }
+  bool GetCurrentThreadName(std::string* name) override {
+    return target_->GetCurrentThreadName(name);
+  }
+  void SchedClosure(absl::AnyInvocable<void()> closure) override {
+    target_->SchedClosure(std::move(closure));
+  }
+  void SchedClosureAfter(int64_t micros,
+                         absl::AnyInvocable<void()> closure) override {
+    target_->SchedClosureAfter(micros, std::move(closure));
+  }
+  Status LoadDynamicLibrary(const char* library_filename,
+                            void** handle) override {
+    return target_->LoadDynamicLibrary(library_filename, handle);
+  }
+  Status GetSymbolFromLibrary(void* handle, const char* symbol_name,
+                              void** symbol) override {
+    return target_->GetSymbolFromLibrary(handle, symbol_name, symbol);
+  }
+  std::string FormatLibraryFileName(const std::string& name,
+                                    const std::string& version) override {
+    return target_->FormatLibraryFileName(name, version);
+  }
+
+  std::string GetRunfilesDir() override { return target_->GetRunfilesDir(); }
+
+ private:
+  void GetLocalTempDirectories(std::vector<string>* list) override {
+    target_->GetLocalTempDirectories(list);
+  }
+
+  Env* target_;
+};
+
+/// Represents a thread used to run a TSL function.
+class Thread {
+ public:
+  Thread() {}
+
+  /// Blocks until the thread of control stops running.
+  virtual ~Thread();
+
+ private:
+  Thread(const Thread&) = delete;
+  void operator=(const Thread&) = delete;
+};
+
+/// \brief Cross-platform setenv.
+///
+/// Since setenv() is not available on windows, we provide an
+/// alternative with platform specific implementations here.
+int setenv(const char* name, const char* value, int overwrite);
+
+/// Cross-platform unsetenv.
+int unsetenv(const char* name);
+
+/// \brief Options to configure a Thread.
+///
+/// Note that the options are all hints, and the
+/// underlying implementation may choose to ignore it.
+struct ThreadOptions {
+  /// Thread stack size to use (in bytes).
+  size_t stack_size = 0;  // 0: use system default value
+  /// Guard area size to use near thread stacks to use (in bytes)
+  size_t guard_size = 0;  // 0: use system default value
+  int numa_node = port::kNUMANoAffinity;
+};
+
+/// A utility routine: copy contents of `src` in file system `src_fs`
+/// to `target` in file system `target_fs`.
+Status FileSystemCopyFile(FileSystem* src_fs, const std::string& src,
+                          FileSystem* target_fs, const std::string& target);
+
+/// A utility routine: reads contents of named file into `*data`
+Status ReadFileToString(Env* env, const std::string& fname, std::string* data);
+
+/// A utility routine: write contents of `data` to file named `fname`
+/// (overwriting existing contents, if any).
+Status WriteStringToFile(Env* env, const std::string& fname,
+                         const StringPiece& data);
+
+/// Write binary representation of "proto" to the named file.
+Status WriteBinaryProto(Env* env, const std::string& fname,
+                        const protobuf::MessageLite& proto);
+
+/// Reads contents of named file and parse as binary encoded proto data
+/// and store into `*proto`.
+Status ReadBinaryProto(Env* env, const std::string& fname,
+                       protobuf::MessageLite* proto);
+
+/// Write the text representation of "proto" to the named file.
+inline Status WriteTextProto(Env* /* env */, const std::string& /* fname */,
+                             const protobuf::MessageLite& /* proto */) {
+  return errors::Unimplemented("Can't write text protos with protolite.");
+}
+Status WriteTextProto(Env* env, const std::string& fname,
+                      const protobuf::Message& proto);
+
+/// Read contents of named file and parse as text encoded proto data
+/// and store into `*proto`.
+inline Status ReadTextProto(Env* /* env */, const std::string& /* fname */,
+                            protobuf::MessageLite* /* proto */) {
+  return errors::Unimplemented("Can't parse text protos with protolite.");
+}
+Status ReadTextProto(Env* env, const std::string& fname,
+                     protobuf::Message* proto);
+
+/// Read contents of named file and parse as either text or binary encoded proto
+/// data and store into `*proto`.
+Status ReadTextOrBinaryProto(Env* env, const std::string& fname,
+                             protobuf::Message* proto);
+Status ReadTextOrBinaryProto(Env* env, const std::string& fname,
+                             protobuf::MessageLite* proto);
+
+// START_SKIP_DOXYGEN
+
+// The following approach to register filesystems is deprecated and will be
+// replaced with modular filesystem plugins registration.
+// TODO(b/139060984): After all filesystems are converted, remove this.
+namespace register_file_system {
+
+template <typename Factory>
+struct Register {
+  Register(Env* env, const std::string& scheme, bool try_modular_filesystems) {
+    // TODO(yongtang): Remove legacy file system registration for hdfs/s3/gcs
+    // after TF 2.6+.
+    if (try_modular_filesystems) {
+      const char* env_value = getenv("TF_USE_MODULAR_FILESYSTEM");
+      string load_plugin = env_value ? absl::AsciiStrToLower(env_value) : "";
+      if (load_plugin == "true" || load_plugin == "1") {
+        // We don't register the static filesystem and wait for SIG IO one
+        LOG(WARNING) << "Using modular file system for '" << scheme << "'."
+                     << " Please switch to tensorflow-io"
+                     << " (https://github.com/tensorflow/io) for file system"
+                     << " support of '" << scheme << "'.";
+        return;
+      }
+      // If the envvar is missing or not "true"/"1", then fall back to legacy
+      // implementation to be backwards compatible.
+    }
+    // TODO(b/32704451): Don't just ignore the ::tensorflow::Status object!
+    env->RegisterFileSystem(scheme, []() -> FileSystem* { return new Factory; })
+        .IgnoreError();
+  }
+};
+
+}  // namespace register_file_system
+
+// END_SKIP_DOXYGEN
+
+}  // namespace tsl
+
+// Register a FileSystem implementation for a scheme. Files with names that have
+// "scheme://" prefixes are routed to use this implementation.
+#define REGISTER_FILE_SYSTEM_ENV(env, scheme, factory, modular) \
+  REGISTER_FILE_SYSTEM_UNIQ_HELPER(__COUNTER__, env, scheme, factory, modular)
+#define REGISTER_FILE_SYSTEM_UNIQ_HELPER(ctr, env, scheme, factory, modular) \
+  REGISTER_FILE_SYSTEM_UNIQ(ctr, env, scheme, factory, modular)
+#define REGISTER_FILE_SYSTEM_UNIQ(ctr, env, scheme, factory, modular)    \
+  static ::tsl::register_file_system::Register<factory> register_ff##ctr \
+      TF_ATTRIBUTE_UNUSED =                                              \
+          ::tsl::register_file_system::Register<factory>(env, scheme, modular)
+
+#define REGISTER_FILE_SYSTEM(scheme, factory) \
+  REGISTER_FILE_SYSTEM_ENV(::tsl::Env::Default(), scheme, factory, false);
+
+#define REGISTER_LEGACY_FILE_SYSTEM(scheme, factory) \
+  REGISTER_FILE_SYSTEM_ENV(::tsl::Env::Default(), scheme, factory, true);
+
+#endif  // TENSORFLOW_TSL_PLATFORM_ENV_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/error_logging.h

@@ -0,0 +1,29 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_ERROR_LOGGING_H_
+#define TENSORFLOW_TSL_PLATFORM_ERROR_LOGGING_H_
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+namespace tsl::error_logging {
+
+absl::Status Log(absl::string_view component, absl::string_view subcomponent,
+                 absl::string_view error_msg);
+
+}
+
+#endif  // TENSORFLOW_TSL_PLATFORM_ERROR_LOGGING_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/errors.h

@@ -0,0 +1,646 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_ERRORS_H_
+#define TENSORFLOW_TSL_PLATFORM_ERRORS_H_
+
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "absl/base/attributes.h"
+#include "absl/status/status.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/str_join.h"
+#include "tsl/platform/logging.h"
+#include "tsl/platform/macros.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/str_util.h"
+#include "tsl/platform/strcat.h"
+
+namespace tsl {
+namespace error {
+// NOLINTBEGIN(misc-unused-using-decls)
+// TODO(aminim): figure out the protobuf migration story.
+using tensorflow::error::ABORTED;
+using tensorflow::error::ALREADY_EXISTS;
+using tensorflow::error::CANCELLED;
+using tensorflow::error::Code;
+using tensorflow::error::DATA_LOSS;
+using tensorflow::error::DEADLINE_EXCEEDED;
+using tensorflow::error::FAILED_PRECONDITION;
+using tensorflow::error::INTERNAL;
+using tensorflow::error::INVALID_ARGUMENT;
+using tensorflow::error::NOT_FOUND;
+using tensorflow::error::OK;
+using tensorflow::error::OUT_OF_RANGE;
+using tensorflow::error::PERMISSION_DENIED;
+using tensorflow::error::RESOURCE_EXHAUSTED;
+using tensorflow::error::UNAUTHENTICATED;
+using tensorflow::error::UNAVAILABLE;
+using tensorflow::error::UNIMPLEMENTED;
+using tensorflow::error::UNKNOWN;
+// NOLINTEND(misc-unused-using-decls)
+}  // namespace error
+
+namespace errors {
+
+namespace internal {
+
+// The DECLARE_ERROR macro below only supports types that can be converted
+// into StrCat's AlphaNum. For the other types we rely on a slower path
+// through std::stringstream. To add support of a new type, it is enough to
+// make sure there is an operator<<() for it:
+//
+//   std::ostream& operator<<(std::ostream& os, const MyType& foo) {
+//     os << foo.ToString();
+//     return os;
+//   }
+// Eventually absl::strings will have native support for this and we will be
+// able to completely remove PrepareForStrCat().
+template <typename T>
+typename std::enable_if<!std::is_convertible<T, strings::AlphaNum>::value,
+                        std::string>::type
+PrepareForStrCat(const T& t) {
+  std::stringstream ss;
+  ss << t;
+  return ss.str();
+}
+inline const strings::AlphaNum& PrepareForStrCat(const strings::AlphaNum& a) {
+  return a;
+}
+
+}  // namespace internal
+
+// Maps UNIX errors into a Status.
+Status IOError(const string& context, int err_number);
+
+// Returns all payloads from a Status as a key-value map.
+inline std::unordered_map<std::string, std::string> GetPayloads(
+    const ::tsl::Status& status) {
+  std::unordered_map<std::string, std::string> payloads;
+  status.ForEachPayload(
+      [&payloads](::tsl::StringPiece key, const absl::Cord& value) {
+        payloads[std::string(key)] = std::string(value);
+      });
+  return payloads;
+}
+
+// Inserts all given payloads into the given status. Will overwrite existing
+// payloads if they exist with the same key.
+inline void InsertPayloads(
+    ::tsl::Status& status,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  for (const auto& payload : payloads) {
+    status.SetPayload(payload.first, absl::Cord(payload.second));
+  }
+}
+
+// Copies all payloads from one Status to another. Will overwrite existing
+// payloads in the destination if they exist with the same key.
+inline void CopyPayloads(const ::tsl::Status& from, ::tsl::Status& to) {
+  from.ForEachPayload([&to](::tsl::StringPiece key, const absl::Cord& value) {
+    to.SetPayload(key, value);
+  });
+}
+
+#if defined(PLATFORM_GOOGLE)
+// Creates a new status with the given code, message and payloads.
+inline ::tsl::Status Create(
+    absl::StatusCode code, ::tsl::StringPiece message,
+    const std::unordered_map<std::string, std::string>& payloads,
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  Status status(code, message, loc);
+  InsertPayloads(status, payloads);
+  return status;
+}
+// Returns a new Status, replacing its message with the given.
+inline ::tsl::Status CreateWithUpdatedMessage(const ::tsl::Status& status,
+                                              ::tsl::StringPiece message) {
+  auto locations = status.GetSourceLocations();
+  auto initial_loc =
+      locations.empty() ? absl::SourceLocation::current() : locations[0];
+  Status new_status = Create(static_cast<absl::StatusCode>(status.code()),
+                             message, GetPayloads(status), initial_loc);
+  if (locations.size() > 1) {
+    for (auto loc : locations.subspan(1)) {
+      new_status.AddSourceLocation(loc);
+    }
+  }
+  return new_status;
+}
+
+#else
+inline ::absl::Status Create(
+    absl::StatusCode code, ::tsl::StringPiece message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  Status status(code, message);
+  InsertPayloads(status, payloads);
+  return status;
+}
+// Returns a new Status, replacing its message with the given.
+inline ::tsl::Status CreateWithUpdatedMessage(const ::tsl::Status& status,
+                                              ::tsl::StringPiece message) {
+  return Create(static_cast<absl::StatusCode>(status.code()), message,
+                GetPayloads(status));
+}
+#endif
+
+// Append some context to an error message.  Each time we append
+// context put it on a new line, since it is possible for there
+// to be several layers of additional context.
+template <typename... Args>
+void AppendToMessage(::tsl::Status* status, Args... args) {
+  auto new_status = CreateWithUpdatedMessage(
+      *status, ::tsl::strings::StrCat(status->message(), "\n\t", args...));
+  CopyPayloads(*status, new_status);
+  *status = std::move(new_status);
+}
+
+// For propagating errors when calling a function.
+#define TF_RETURN_IF_ERROR(...)             \
+  do {                                      \
+    ::absl::Status _status = (__VA_ARGS__); \
+    if (TF_PREDICT_FALSE(!_status.ok())) {  \
+      MAYBE_ADD_SOURCE_LOCATION(_status)    \
+      return _status;                       \
+    }                                       \
+  } while (0)
+
+#define TF_RETURN_WITH_CONTEXT_IF_ERROR(expr, ...)           \
+  do {                                                       \
+    ::tsl::Status _status = (expr);                          \
+    if (TF_PREDICT_FALSE(!_status.ok())) {                   \
+      ::tsl::errors::AppendToMessage(&_status, __VA_ARGS__); \
+      return _status;                                        \
+    }                                                        \
+  } while (0)
+
+// Convenience functions for generating and using error status.
+// Example usage:
+//   status.Update(errors::InvalidArgument("The ", foo, " isn't right."));
+//   if (errors::IsInvalidArgument(status)) { ... }
+//   switch (status.code()) { case error::INVALID_ARGUMENT: ... }
+
+// CANCELLED
+template <typename... Args>
+::tsl::Status Cancelled(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kCancelled,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status CancelledWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kCancelled, message, payloads);
+}
+
+// InvalidArgument
+template <typename... Args>
+::tsl::Status InvalidArgument(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kInvalidArgument,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+
+#if defined(PLATFORM_GOOGLE)
+// Specialized overloads to capture source location for up to three arguments.
+template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+::absl::Status InvalidArgument(
+    Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4,
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return ::tsl::Status(
+      absl::StatusCode::kInvalidArgument,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1),
+                             ::tsl::errors::internal::PrepareForStrCat(arg2),
+                             ::tsl::errors::internal::PrepareForStrCat(arg3),
+                             ::tsl::errors::internal::PrepareForStrCat(arg4)),
+      loc);
+}
+template <typename Arg1, typename Arg2, typename Arg3>
+::absl::Status InvalidArgument(
+    Arg1 arg1, Arg2 arg2, Arg3 arg3,
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return ::tsl::Status(
+      absl::StatusCode::kInvalidArgument,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1),
+                             ::tsl::errors::internal::PrepareForStrCat(arg2),
+                             ::tsl::errors::internal::PrepareForStrCat(arg3)),
+      loc);
+}
+template <typename Arg1, typename Arg2>
+::absl::Status InvalidArgument(
+    Arg1 arg1, Arg2 arg2,
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return ::tsl::Status(
+      absl::StatusCode::kInvalidArgument,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1),
+                             ::tsl::errors::internal::PrepareForStrCat(arg2)),
+      loc);
+}
+template <typename Arg1>
+::absl::Status InvalidArgument(
+    Arg1 arg1, absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return ::tsl::Status(
+      absl::StatusCode::kInvalidArgument,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1)),
+      loc);
+}
+template <typename... Args>
+::absl::Status InvalidArgumentWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads,
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return errors::Create(absl::StatusCode::kInvalidArgument, message, payloads,
+                        loc);
+}
+#else
+template <typename Arg1, typename Arg2, typename Arg3>
+::absl::Status InvalidArgument(Arg1 arg1, Arg2 arg2, Arg3 arg3) {
+  return ::absl::Status(
+      absl::StatusCode::kInvalidArgument,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1),
+                             ::tsl::errors::internal::PrepareForStrCat(arg2),
+                             ::tsl::errors::internal::PrepareForStrCat(arg3)));
+}
+template <typename Arg1, typename Arg2>
+::absl::Status InvalidArgument(Arg1 arg1, Arg2 arg2) {
+  return ::absl::Status(
+      absl::StatusCode::kInvalidArgument,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1),
+                             ::tsl::errors::internal::PrepareForStrCat(arg2)));
+}
+template <typename Arg1>
+::absl::Status InvalidArgument(Arg1 arg1) {
+  return ::absl::Status(
+      absl::StatusCode::kInvalidArgument,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1)));
+}
+template <typename... Args>
+::absl::Status InvalidArgumentWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kInvalidArgument, message, payloads);
+}
+#endif
+
+// NotFound
+template <typename... Args>
+::tsl::Status NotFound(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kNotFound,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+#if defined(PLATFORM_GOOGLE)
+// Specialized overloads to capture source location for up to three arguments.
+template <typename Arg1, typename Arg2, typename Arg3>
+::absl::Status NotFound(
+    Arg1 arg1, Arg2 arg2, Arg3 arg3,
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return ::tsl::Status(
+      absl::StatusCode::kNotFound,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1),
+                             ::tsl::errors::internal::PrepareForStrCat(arg2),
+                             ::tsl::errors::internal::PrepareForStrCat(arg3)),
+      loc);
+}
+template <typename Arg1, typename Arg2>
+::absl::Status NotFound(
+    Arg1 arg1, Arg2 arg2,
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return ::tsl::Status(
+      absl::StatusCode::kNotFound,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1),
+                             ::tsl::errors::internal::PrepareForStrCat(arg2)),
+      loc);
+}
+template <typename Arg1>
+::absl::Status NotFound(
+    Arg1 arg1, absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return ::tsl::Status(
+      absl::StatusCode::kNotFound,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1)),
+      loc);
+}
+template <typename... Args>
+::absl::Status NotFoundWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads,
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return errors::Create(absl::StatusCode::kNotFound, message, payloads, loc);
+}
+#else
+template <typename Arg1, typename Arg2, typename Arg3>
+::absl::Status NotFound(Arg1 arg1, Arg2 arg2, Arg3 arg3) {
+  return ::absl::Status(
+      absl::StatusCode::kNotFound,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1),
+                             ::tsl::errors::internal::PrepareForStrCat(arg2),
+                             ::tsl::errors::internal::PrepareForStrCat(arg3)));
+}
+template <typename Arg1, typename Arg2>
+::absl::Status NotFound(Arg1 arg1, Arg2 arg2) {
+  return ::absl::Status(
+      absl::StatusCode::kNotFound,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1),
+                             ::tsl::errors::internal::PrepareForStrCat(arg2)));
+}
+template <typename Arg1>
+::absl::Status NotFound(Arg1 arg1) {
+  return ::absl::Status(
+      absl::StatusCode::kNotFound,
+      ::tsl::strings::StrCat(::tsl::errors::internal::PrepareForStrCat(arg1)));
+}
+template <typename... Args>
+::absl::Status NotFoundWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kNotFound, message, payloads);
+}
+#endif
+
+// AlreadyExists
+template <typename... Args>
+::tsl::Status AlreadyExists(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kAlreadyExists,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status AlreadyExistsWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kAlreadyExists, message, payloads);
+}
+
+// ResourceExhausted
+template <typename... Args>
+::tsl::Status ResourceExhausted(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kResourceExhausted,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status ResourceExhaustedWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kResourceExhausted, message,
+                        payloads);
+}
+
+// Unavailable
+template <typename... Args>
+::tsl::Status Unavailable(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kUnavailable,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status UnavailableWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kUnavailable, message, payloads);
+}
+
+// FailedPrecondition
+template <typename... Args>
+::tsl::Status FailedPrecondition(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kFailedPrecondition,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status FailedPreconditionWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kFailedPrecondition, message,
+                        payloads);
+}
+
+// OutOfRange
+template <typename... Args>
+::tsl::Status OutOfRange(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kOutOfRange,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status OutOfRangeWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kOutOfRange, message, payloads);
+}
+
+// Unimplemented
+template <typename... Args>
+::tsl::Status Unimplemented(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kUnimplemented,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status UnimplementedWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kUnimplemented, message, payloads);
+}
+
+// Internal
+template <typename... Args>
+::tsl::Status Internal(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kInternal,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status InternalWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kInternal, message, payloads);
+}
+
+// Aborted
+template <typename... Args>
+::tsl::Status Aborted(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kAborted,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status AbortedWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kAborted, message, payloads);
+}
+
+// DeadlineExceeded
+template <typename... Args>
+::tsl::Status DeadlineExceeded(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kDeadlineExceeded,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status DeadlineExceededWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kDeadlineExceeded, message, payloads);
+}
+
+// DataLoss
+template <typename... Args>
+::tsl::Status DataLoss(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kDataLoss,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status DataLossWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kDataLoss, message, payloads);
+}
+
+// Unknown
+template <typename... Args>
+::tsl::Status Unknown(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kUnknown,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status UnknownPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kUnknown, message, payloads);
+}
+// PermissionDenied
+template <typename... Args>
+::tsl::Status PermissionDenied(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kPermissionDenied,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status PermissionDeniedWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kPermissionDenied, message, payloads);
+}
+
+// Unauthenticated
+template <typename... Args>
+::tsl::Status Unauthenticated(Args... args) {
+  return ::tsl::Status(absl::StatusCode::kUnauthenticated,
+                       ::tsl::strings::StrCat(
+                           ::tsl::errors::internal::PrepareForStrCat(args)...));
+}
+template <typename... Args>
+::tsl::Status UnauthenticatedWithPayloads(
+    const ::tsl::StringPiece& message,
+    const std::unordered_map<std::string, std::string>& payloads) {
+  return errors::Create(absl::StatusCode::kUnauthenticated, message, payloads);
+}
+
+bool IsAborted(const Status& status);
+bool IsAlreadyExists(const Status& status);
+bool IsCancelled(const Status& status);
+bool IsDataLoss(const Status& status);
+bool IsDeadlineExceeded(const Status& status);
+bool IsFailedPrecondition(const Status& status);
+bool IsInternal(const Status& status);
+bool IsInvalidArgument(const Status& status);
+bool IsNotFound(const Status& status);
+bool IsOutOfRange(const Status& status);
+bool IsPermissionDenied(const Status& status);
+bool IsResourceExhausted(const Status& status);
+bool IsUnauthenticated(const Status& status);
+bool IsUnavailable(const Status& status);
+bool IsUnimplemented(const Status& status);
+bool IsUnknown(const Status& status);
+
+// Produces a formatted string pattern from the name which can uniquely identify
+// this node upstream to produce an informative error message. The pattern
+// followed is: {{node <name>}}
+// Note: The pattern below determines the regex _NODEDEF_NAME_RE in the file
+// tensorflow/python/client/session.py
+// LINT.IfChange
+inline std::string FormatNodeNameForError(absl::string_view name) {
+  return strings::StrCat("{{node ", name, "}}");
+}
+// LINT.ThenChange(//tensorflow/python/client/session.py)
+template <typename T>
+std::string FormatNodeNamesForError(const T& names) {
+  return absl::StrJoin(
+      names, ", ", [](std::string* output, absl::string_view s) {
+        ::tsl::strings::StrAppend(output, FormatNodeNameForError(s));
+      });
+}
+// LINT.IfChange
+inline std::string FormatColocationNodeForError(absl::string_view name) {
+  return strings::StrCat("{{colocation_node ", name, "}}");
+}
+// LINT.ThenChange(//tensorflow/python/framework/error_interpolation.py)
+template <typename T, typename = std::enable_if_t<
+                          !std::is_convertible_v<T, absl::string_view>>>
+std::string FormatColocationNodeForError(const T& names) {
+  return absl::StrJoin(
+      names, ", ", [](std::string* output, absl::string_view s) {
+        ::tsl::strings::StrAppend(output, FormatColocationNodeForError(s));
+      });
+}
+
+inline std::string FormatFunctionForError(absl::string_view name) {
+  return strings::StrCat("{{function_node ", name, "}}");
+}
+
+inline Status ReplaceErrorFromNonCommunicationOps(const Status s,
+                                                  absl::string_view op_name) {
+  assert(::tsl::errors::IsUnavailable(s));
+  return Status(
+      absl::StatusCode::kInternal,
+      strings::StrCat(
+          s.message(), "\nExecuting non-communication op <", op_name,
+          "> originally returned UnavailableError, and was replaced by "
+          "InternalError to avoid invoking TF network error handling logic."));
+}
+
+template <typename T>
+std::string FormatOriginalNodeLocationForError(const T& node_names,
+                                               const T& func_names) {
+  std::vector<std::string> error_message;
+  for (int i = 0; i != node_names.size(); ++i) {
+    if (i != 0) {
+      error_message.push_back(", ");
+    }
+    if (i < func_names.size()) {
+      error_message.push_back(FormatFunctionForError(func_names[i]));
+    }
+    error_message.push_back(FormatNodeNameForError(node_names[i]));
+  }
+  return absl::StrJoin(error_message, "");
+}
+
+// The CanonicalCode() for non-errors.
+using ::tsl::error::OK;  // NOLINT
+
+}  // namespace errors
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_ERRORS_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/file_statistics.h

@@ -0,0 +1,39 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_FILE_STATISTICS_H_
+#define TENSORFLOW_TSL_PLATFORM_FILE_STATISTICS_H_
+
+#include "tsl/platform/types.h"
+
+namespace tsl {
+
+struct FileStatistics {
+  // The length of the file or -1 if finding file length is not supported.
+  int64_t length = -1;
+  // The last modified time in nanoseconds.
+  int64_t mtime_nsec = 0;
+  // True if the file is a directory, otherwise false.
+  bool is_directory = false;
+
+  FileStatistics() {}
+  FileStatistics(int64_t length, int64_t mtime_nsec, bool is_directory)
+      : length(length), mtime_nsec(mtime_nsec), is_directory(is_directory) {}
+  ~FileStatistics() {}
+};
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_FILE_STATISTICS_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/file_system.h

@@ -0,0 +1,923 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_FILE_SYSTEM_H_
+#define TENSORFLOW_TSL_PLATFORM_FILE_SYSTEM_H_
+
+#include <stdint.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "tsl/platform/cord.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/file_statistics.h"
+#include "tsl/platform/macros.h"
+#include "tsl/platform/platform.h"
+#include "tsl/platform/stringpiece.h"
+#include "tsl/platform/types.h"
+
+#ifdef PLATFORM_WINDOWS
+#undef DeleteFile
+#undef CopyFile
+#undef TranslateName
+#endif
+
+namespace tsl {
+
+class FileAcl;
+class RandomAccessFile;
+class ReadOnlyMemoryRegion;
+class WritableFile;
+
+class FileSystem;
+struct TransactionToken {
+  FileSystem* owner;
+  void* token;
+};
+
+/// A generic interface for accessing a file system.  Implementations
+/// of custom filesystem adapters must implement this interface,
+/// RandomAccessFile, WritableFile, and ReadOnlyMemoryRegion classes.
+class FileSystem {
+ public:
+  /// \brief Creates a brand new random access read-only file with the
+  /// specified name.
+  ///
+  /// On success, stores a pointer to the new file in
+  /// *result and returns OK.  On failure stores NULL in *result and
+  /// returns non-OK.  If the file does not exist, returns a non-OK
+  /// status.
+  ///
+  /// The returned file may be concurrently accessed by multiple threads.
+  ///
+  /// The ownership of the returned RandomAccessFile is passed to the caller
+  /// and the object should be deleted when is not used.
+  virtual tsl::Status NewRandomAccessFile(
+      const std::string& fname, std::unique_ptr<RandomAccessFile>* result) {
+    return NewRandomAccessFile(fname, nullptr, result);
+  }
+
+  virtual tsl::Status NewRandomAccessFile(
+      const std::string& fname, TransactionToken* token,
+      std::unique_ptr<RandomAccessFile>* result) {
+    // We duplicate these methods due to Google internal coding style prevents
+    // virtual functions with default arguments. See PR #41615.
+    return OkStatus();
+  }
+
+  /// \brief Creates an object that writes to a new file with the specified
+  /// name.
+  ///
+  /// Deletes any existing file with the same name and creates a
+  /// new file.  On success, stores a pointer to the new file in
+  /// *result and returns OK.  On failure stores NULL in *result and
+  /// returns non-OK.
+  ///
+  /// The returned file will only be accessed by one thread at a time.
+  ///
+  /// The ownership of the returned WritableFile is passed to the caller
+  /// and the object should be deleted when is not used.
+  virtual tsl::Status NewWritableFile(const std::string& fname,
+                                      std::unique_ptr<WritableFile>* result) {
+    return NewWritableFile(fname, nullptr, result);
+  }
+
+  virtual tsl::Status NewWritableFile(const std::string& fname,
+                                      TransactionToken* token,
+                                      std::unique_ptr<WritableFile>* result) {
+    return OkStatus();
+  }
+
+  /// \brief Creates an object that either appends to an existing file, or
+  /// writes to a new file (if the file does not exist to begin with).
+  ///
+  /// On success, stores a pointer to the new file in *result and
+  /// returns OK.  On failure stores NULL in *result and returns
+  /// non-OK.
+  ///
+  /// The returned file will only be accessed by one thread at a time.
+  ///
+  /// The ownership of the returned WritableFile is passed to the caller
+  /// and the object should be deleted when is not used.
+  virtual tsl::Status NewAppendableFile(const std::string& fname,
+                                        std::unique_ptr<WritableFile>* result) {
+    return NewAppendableFile(fname, nullptr, result);
+  }
+
+  virtual tsl::Status NewAppendableFile(const std::string& fname,
+                                        TransactionToken* token,
+                                        std::unique_ptr<WritableFile>* result) {
+    return OkStatus();
+  }
+
+  /// \brief Creates a readonly region of memory with the file context.
+  ///
+  /// On success, it returns a pointer to read-only memory region
+  /// from the content of file fname. The ownership of the region is passed to
+  /// the caller. On failure stores nullptr in *result and returns non-OK.
+  ///
+  /// The returned memory region can be accessed from many threads in parallel.
+  ///
+  /// The ownership of the returned ReadOnlyMemoryRegion is passed to the caller
+  /// and the object should be deleted when is not used.
+  virtual tsl::Status NewReadOnlyMemoryRegionFromFile(
+      const std::string& fname, std::unique_ptr<ReadOnlyMemoryRegion>* result) {
+    return NewReadOnlyMemoryRegionFromFile(fname, nullptr, result);
+  }
+
+  virtual tsl::Status NewReadOnlyMemoryRegionFromFile(
+      const std::string& fname, TransactionToken* token,
+      std::unique_ptr<ReadOnlyMemoryRegion>* result) {
+    return OkStatus();
+  }
+
+  /// Returns OK if the named path exists and NOT_FOUND otherwise.
+  virtual tsl::Status FileExists(const std::string& fname) {
+    return FileExists(fname, nullptr);
+  }
+
+  virtual tsl::Status FileExists(const std::string& fname,
+                                 TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// Returns true if all the listed files exist, false otherwise.
+  /// if status is not null, populate the vector with a detailed status
+  /// for each file.
+  virtual bool FilesExist(const std::vector<string>& files,
+                          std::vector<Status>* status) {
+    return FilesExist(files, nullptr, status);
+  }
+
+  virtual bool FilesExist(const std::vector<string>& files,
+                          TransactionToken* token, std::vector<Status>* status);
+
+  /// \brief Returns the immediate children in the given directory.
+  ///
+  /// The returned paths are relative to 'dir'.
+  virtual tsl::Status GetChildren(const std::string& dir,
+                                  std::vector<string>* result) {
+    return GetChildren(dir, nullptr, result);
+  }
+
+  virtual tsl::Status GetChildren(const std::string& dir,
+                                  TransactionToken* token,
+                                  std::vector<string>* result) {
+    return OkStatus();
+  }
+
+  /// \brief Given a pattern, stores in *results the set of paths that matches
+  /// that pattern. *results is cleared.
+  ///
+  /// pattern must match all of a name, not just a substring.
+  ///
+  /// pattern: { term }
+  /// term:
+  ///   '*': matches any sequence of non-'/' characters
+  ///   '?': matches a single non-'/' character
+  ///   '[' [ '^' ] { match-list } ']':
+  ///        matches any single character (not) on the list
+  ///   c: matches character c (c != '*', '?', '\\', '[')
+  ///   '\\' c: matches character c
+  /// character-range:
+  ///   c: matches character c (c != '\\', '-', ']')
+  ///   '\\' c: matches character c
+  ///   lo '-' hi: matches character c for lo <= c <= hi
+  ///
+  /// Typical return codes:
+  ///  * OK - no errors
+  ///  * UNIMPLEMENTED - Some underlying functions (like GetChildren) are not
+  ///                    implemented
+  virtual tsl::Status GetMatchingPaths(const std::string& pattern,
+                                       std::vector<string>* results) {
+    return GetMatchingPaths(pattern, nullptr, results);
+  }
+
+  virtual tsl::Status GetMatchingPaths(const std::string& pattern,
+                                       TransactionToken* token,
+                                       std::vector<string>* results) {
+    return OkStatus();
+  }
+
+  /// \brief Checks if the given filename matches the pattern.
+  ///
+  /// This function provides the equivalent of posix fnmatch, however it is
+  /// implemented without fnmatch to ensure that this can be used for cloud
+  /// filesystems on windows. For windows filesystems, it uses PathMatchSpec.
+  virtual bool Match(const std::string& filename, const std::string& pattern);
+
+  /// \brief Obtains statistics for the given path.
+  virtual tsl::Status Stat(const std::string& fname, FileStatistics* stat) {
+    return Stat(fname, nullptr, stat);
+  }
+
+  virtual tsl::Status Stat(const std::string& fname, TransactionToken* token,
+                           FileStatistics* stat) {
+    return OkStatus();
+  }
+
+  /// \brief Deletes the named file.
+  virtual tsl::Status DeleteFile(const std::string& fname) {
+    return DeleteFile(fname, nullptr);
+  }
+
+  virtual tsl::Status DeleteFile(const std::string& fname,
+                                 TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// \brief Creates the specified directory.
+  /// Typical return codes:
+  ///  * OK - successfully created the directory.
+  ///  * ALREADY_EXISTS - directory with name dirname already exists.
+  ///  * PERMISSION_DENIED - dirname is not writable.
+  virtual tsl::Status CreateDir(const std::string& dirname) {
+    return CreateDir(dirname, nullptr);
+  }
+
+  virtual tsl::Status CreateDir(const std::string& dirname,
+                                TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// \brief Creates the specified directory and all the necessary
+  /// subdirectories.
+  /// Typical return codes:
+  ///  * OK - successfully created the directory and sub directories, even if
+  ///         they were already created.
+  ///  * PERMISSION_DENIED - dirname or some subdirectory is not writable.
+  virtual tsl::Status RecursivelyCreateDir(const std::string& dirname) {
+    return RecursivelyCreateDir(dirname, nullptr);
+  }
+
+  virtual tsl::Status RecursivelyCreateDir(const std::string& dirname,
+                                           TransactionToken* token);
+
+  /// \brief Deletes the specified directory.
+  virtual tsl::Status DeleteDir(const std::string& dirname) {
+    return DeleteDir(dirname, nullptr);
+  }
+
+  virtual tsl::Status DeleteDir(const std::string& dirname,
+                                TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// \brief Deletes the specified directory and all subdirectories and files
+  /// underneath it. This is accomplished by traversing the directory tree
+  /// rooted at dirname and deleting entries as they are encountered.
+  ///
+  /// If dirname itself is not readable or does not exist, *undeleted_dir_count
+  /// is set to 1, *undeleted_file_count is set to 0 and an appropriate status
+  /// (e.g. NOT_FOUND) is returned.
+  ///
+  /// If dirname and all its descendants were successfully deleted, TF_OK is
+  /// returned and both error counters are set to zero.
+  ///
+  /// Otherwise, while traversing the tree, undeleted_file_count and
+  /// undeleted_dir_count are updated if an entry of the corresponding type
+  /// could not be deleted. The returned error status represents the reason that
+  /// any one of these entries could not be deleted.
+  ///
+  /// REQUIRES: undeleted_files, undeleted_dirs to be not null.
+  ///
+  /// Typical return codes:
+  ///  * OK - dirname exists and we were able to delete everything underneath.
+  ///  * NOT_FOUND - dirname doesn't exist
+  ///  * PERMISSION_DENIED - dirname or some descendant is not writable
+  ///  * UNIMPLEMENTED - Some underlying functions (like Delete) are not
+  ///                    implemented
+  virtual tsl::Status DeleteRecursively(const std::string& dirname,
+                                        int64_t* undeleted_files,
+                                        int64_t* undeleted_dirs) {
+    return DeleteRecursively(dirname, nullptr, undeleted_files, undeleted_dirs);
+  }
+
+  virtual tsl::Status DeleteRecursively(const std::string& dirname,
+                                        TransactionToken* token,
+                                        int64_t* undeleted_files,
+                                        int64_t* undeleted_dirs);
+
+  /// \brief Stores the size of `fname` in `*file_size`.
+  virtual tsl::Status GetFileSize(const std::string& fname, uint64* file_size) {
+    return GetFileSize(fname, nullptr, file_size);
+  }
+
+  virtual tsl::Status GetFileSize(const std::string& fname,
+                                  TransactionToken* token, uint64* file_size) {
+    return OkStatus();
+  }
+
+  /// \brief Overwrites the target if it exists.
+  virtual tsl::Status RenameFile(const std::string& src,
+                                 const std::string& target) {
+    return RenameFile(src, target, nullptr);
+  }
+
+  virtual tsl::Status RenameFile(const std::string& src,
+                                 const std::string& target,
+                                 TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// \brief Copy the src to target.
+  virtual tsl::Status CopyFile(const std::string& src,
+                               const std::string& target) {
+    return CopyFile(src, target, nullptr);
+  }
+
+  virtual tsl::Status CopyFile(const std::string& src,
+                               const std::string& target,
+                               TransactionToken* token);
+
+  /// \brief Translate an URI to a filename for the FileSystem implementation.
+  ///
+  /// The implementation in this class cleans up the path, removing
+  /// duplicate /'s, resolving .. and removing trailing '/'.
+  /// This respects relative vs. absolute paths, but does not
+  /// invoke any system calls (getcwd(2)) in order to resolve relative
+  /// paths with respect to the actual working directory.  That is, this is
+  /// purely string manipulation, completely independent of process state.
+  virtual std::string TranslateName(const std::string& name) const;
+
+  /// \brief Returns whether the given path is a directory or not.
+  ///
+  /// Typical return codes (not guaranteed exhaustive):
+  ///  * OK - The path exists and is a directory.
+  ///  * FAILED_PRECONDITION - The path exists and is not a directory.
+  ///  * NOT_FOUND - The path entry does not exist.
+  ///  * PERMISSION_DENIED - Insufficient permissions.
+  ///  * UNIMPLEMENTED - The file factory doesn't support directories.
+  virtual tsl::Status IsDirectory(const std::string& fname) {
+    return IsDirectory(fname, nullptr);
+  }
+
+  virtual tsl::Status IsDirectory(const std::string& fname,
+                                  TransactionToken* token);
+
+  /// \brief Returns whether the given path is on a file system
+  /// that has atomic move capabilities. This can be used
+  /// to determine if there needs to be a temp location to safely write objects.
+  /// The second boolean argument has_atomic_move contains this information.
+  ///
+  /// Returns one of the following status codes (not guaranteed exhaustive):
+  ///  * OK - The path is on a recognized file system,
+  ///         so has_atomic_move holds the above information.
+  ///  * UNIMPLEMENTED - The file system of the path hasn't been implemented in
+  ///  TF
+  virtual Status HasAtomicMove(const std::string& path, bool* has_atomic_move);
+
+  /// \brief Flushes any cached filesystem objects from memory.
+  virtual void FlushCaches() { FlushCaches(nullptr); }
+
+  virtual void FlushCaches(TransactionToken* token);
+
+  /// \brief The separator this filesystem uses.
+  ///
+  /// This is implemented as a part of the filesystem, because even on windows,
+  /// a user may need access to filesystems with '/' separators, such as cloud
+  /// filesystems.
+  virtual char Separator() const;
+
+  /// \brief Split a path to its basename and dirname.
+  ///
+  /// Helper function for Basename and Dirname.
+  std::pair<StringPiece, StringPiece> SplitPath(StringPiece uri) const;
+
+  /// \brief returns the final file name in the given path.
+  ///
+  /// Returns the part of the path after the final "/".  If there is no
+  /// "/" in the path, the result is the same as the input.
+  virtual StringPiece Basename(StringPiece path) const;
+
+  /// \brief Returns the part of the path before the final "/".
+  ///
+  /// If there is a single leading "/" in the path, the result will be the
+  /// leading "/".  If there is no "/" in the path, the result is the empty
+  /// prefix of the input.
+  StringPiece Dirname(StringPiece path) const;
+
+  /// \brief Returns the part of the basename of path after the final ".".
+  ///
+  /// If there is no "." in the basename, the result is empty.
+  StringPiece Extension(StringPiece path) const;
+
+  /// \brief Clean duplicate and trailing, "/"s, and resolve ".." and ".".
+  ///
+  /// NOTE: This respects relative vs. absolute paths, but does not
+  /// invoke any system calls (getcwd(2)) in order to resolve relative
+  /// paths with respect to the actual working directory.  That is, this is
+  /// purely string manipulation, completely independent of process state.
+  std::string CleanPath(StringPiece path) const;
+
+  /// \brief Creates a URI from a scheme, host, and path.
+  ///
+  /// If the scheme is empty, we just return the path.
+  std::string CreateURI(StringPiece scheme, StringPiece host,
+                        StringPiece path) const;
+
+  /// \brief Return true if path is absolute.
+  bool IsAbsolutePath(tsl::StringPiece path) const;
+
+#ifndef SWIG  // variadic templates
+  /// \brief Join multiple paths together.
+  ///
+  /// This function also removes the unnecessary path separators.
+  /// For example:
+  ///
+  ///  Arguments                  | JoinPath
+  ///  ---------------------------+----------
+  ///  '/foo', 'bar'              | /foo/bar
+  ///  '/foo/', 'bar'             | /foo/bar
+  ///  '/foo', '/bar'             | /foo/bar
+  ///
+  /// Usage:
+  /// string path = io::JoinPath("/mydir", filename);
+  /// string path = io::JoinPath(FLAGS_test_srcdir, filename);
+  /// string path = io::JoinPath("/full", "path", "to", "filename");
+  template <typename... T>
+  std::string JoinPath(const T&... args) {
+    return JoinPathImpl({args...});
+  }
+#endif /* SWIG */
+
+  std::string JoinPathImpl(std::initializer_list<tsl::StringPiece> paths);
+
+  /// \brief Populates the scheme, host, and path from a URI.
+  ///
+  /// scheme, host, and path are guaranteed by this function to point into the
+  /// contents of uri, even if empty.
+  ///
+  /// Corner cases:
+  /// - If the URI is invalid, scheme and host are set to empty strings and the
+  ///  passed string is assumed to be a path
+  /// - If the URI omits the path (e.g. file://host), then the path is left
+  /// empty.
+  void ParseURI(StringPiece remaining, StringPiece* scheme, StringPiece* host,
+                StringPiece* path) const;
+
+  // Transaction related API
+
+  /// \brief Starts a new transaction
+  virtual tsl::Status StartTransaction(TransactionToken** token) {
+    *token = nullptr;
+    return OkStatus();
+  }
+
+  /// \brief Adds `path` to transaction in `token`
+  virtual tsl::Status AddToTransaction(const std::string& path,
+                                       TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// \brief Ends transaction
+  virtual tsl::Status EndTransaction(TransactionToken* token) {
+    return OkStatus();
+  }
+
+  /// \brief Get token for `path` or start a new transaction and add `path` to
+  /// it.
+  virtual tsl::Status GetTokenOrStartTransaction(const std::string& path,
+                                                 TransactionToken** token) {
+    *token = nullptr;
+    return OkStatus();
+  }
+
+  /// \brief Return transaction for `path` or nullptr in `token`
+  virtual tsl::Status GetTransactionForPath(const std::string& path,
+                                            TransactionToken** token) {
+    *token = nullptr;
+    return OkStatus();
+  }
+
+  /// \brief Decode transaction to human readable string.
+  virtual std::string DecodeTransaction(const TransactionToken* token);
+
+  /// \brief Set File System Configuration Options
+  virtual Status SetOption(const string& key, const string& value) {
+    return errors::Unimplemented("SetOption");
+  }
+
+  /// \brief Set File System Configuration Option
+  virtual tsl::Status SetOption(const std::string& name,
+                                const std::vector<string>& values) {
+    return errors::Unimplemented("SetOption");
+  }
+
+  /// \brief Set File System Configuration Option
+  virtual tsl::Status SetOption(const std::string& name,
+                                const std::vector<int64_t>& values) {
+    return errors::Unimplemented("SetOption");
+  }
+
+  /// \brief Set File System Configuration Option
+  virtual tsl::Status SetOption(const std::string& name,
+                                const std::vector<double>& values) {
+    return errors::Unimplemented("SetOption");
+  }
+
+  /// \brief Set File System ACL checker.
+  ///
+  /// No checks are enforced if a FileAcl is never set.
+  virtual tsl::Status SetFileAcl(std::shared_ptr<FileAcl> file_acl) {
+    return errors::Unimplemented("SetFileAcl");
+  }
+
+  FileSystem() {}
+
+  virtual ~FileSystem() = default;
+};
+/// This macro adds forwarding methods from FileSystem class to
+/// used class since name hiding will prevent these to be accessed from
+/// derived classes and would require all use locations to migrate to
+/// Transactional API. This is an interim solution until ModularFileSystem class
+/// becomes a singleton.
+// TODO(sami): Remove this macro when filesystem plugins migration is complete.
+#define TF_USE_FILESYSTEM_METHODS_WITH_NO_TRANSACTION_SUPPORT \
+  using FileSystem::NewRandomAccessFile;                      \
+  using FileSystem::NewWritableFile;                          \
+  using FileSystem::NewAppendableFile;                        \
+  using FileSystem::NewReadOnlyMemoryRegionFromFile;          \
+  using FileSystem::FileExists;                               \
+  using FileSystem::GetChildren;                              \
+  using FileSystem::GetMatchingPaths;                         \
+  using FileSystem::Stat;                                     \
+  using FileSystem::DeleteFile;                               \
+  using FileSystem::RecursivelyCreateDir;                     \
+  using FileSystem::DeleteDir;                                \
+  using FileSystem::DeleteRecursively;                        \
+  using FileSystem::GetFileSize;                              \
+  using FileSystem::RenameFile;                               \
+  using FileSystem::CopyFile;                                 \
+  using FileSystem::IsDirectory;                              \
+  using FileSystem::FlushCaches
+
+/// A Wrapper class for Transactional FileSystem support.
+/// This provides means to make use of the transactions with minimal code change
+/// Any operations that are done through this interface will be through the
+/// transaction created at the time of construction of this instance.
+/// See FileSystem documentation for method descriptions.
+/// This class simply forwards all calls to wrapped filesystem either with given
+/// transaction token or with token used in its construction. This allows doing
+/// transactional filesystem access with minimal code change.
+class WrappedFileSystem : public FileSystem {
+ public:
+  TF_USE_FILESYSTEM_METHODS_WITH_NO_TRANSACTION_SUPPORT;
+
+  tsl::Status NewRandomAccessFile(
+      const std::string& fname, TransactionToken* token,
+      std::unique_ptr<RandomAccessFile>* result) override {
+    return fs_->NewRandomAccessFile(fname, (token ? token : token_), result);
+  }
+
+  tsl::Status NewWritableFile(const std::string& fname, TransactionToken* token,
+                              std::unique_ptr<WritableFile>* result) override {
+    return fs_->NewWritableFile(fname, (token ? token : token_), result);
+  }
+
+  tsl::Status NewAppendableFile(
+      const std::string& fname, TransactionToken* token,
+      std::unique_ptr<WritableFile>* result) override {
+    return fs_->NewAppendableFile(fname, (token ? token : token_), result);
+  }
+
+  tsl::Status NewReadOnlyMemoryRegionFromFile(
+      const std::string& fname, TransactionToken* token,
+      std::unique_ptr<ReadOnlyMemoryRegion>* result) override {
+    return fs_->NewReadOnlyMemoryRegionFromFile(fname, (token ? token : token_),
+                                                result);
+  }
+
+  tsl::Status FileExists(const std::string& fname,
+                         TransactionToken* token) override {
+    return fs_->FileExists(fname, (token ? token : token_));
+  }
+
+  bool FilesExist(const std::vector<string>& files, TransactionToken* token,
+                  std::vector<Status>* status) override {
+    return fs_->FilesExist(files, (token ? token : token_), status);
+  }
+
+  tsl::Status GetChildren(const std::string& dir, TransactionToken* token,
+                          std::vector<string>* result) override {
+    return fs_->GetChildren(dir, (token ? token : token_), result);
+  }
+
+  tsl::Status GetMatchingPaths(const std::string& pattern,
+                               TransactionToken* token,
+                               std::vector<string>* results) override {
+    return fs_->GetMatchingPaths(pattern, (token ? token : token_), results);
+  }
+
+  bool Match(const std::string& filename, const std::string& pattern) override {
+    return fs_->Match(filename, pattern);
+  }
+
+  tsl::Status Stat(const std::string& fname, TransactionToken* token,
+                   FileStatistics* stat) override {
+    return fs_->Stat(fname, (token ? token : token_), stat);
+  }
+
+  tsl::Status DeleteFile(const std::string& fname,
+                         TransactionToken* token) override {
+    return fs_->DeleteFile(fname, (token ? token : token_));
+  }
+
+  tsl::Status CreateDir(const std::string& dirname,
+                        TransactionToken* token) override {
+    return fs_->CreateDir(dirname, (token ? token : token_));
+  }
+
+  tsl::Status RecursivelyCreateDir(const std::string& dirname,
+                                   TransactionToken* token) override {
+    return fs_->RecursivelyCreateDir(dirname, (token ? token : token_));
+  }
+
+  tsl::Status DeleteDir(const std::string& dirname,
+                        TransactionToken* token) override {
+    return fs_->DeleteDir(dirname, (token ? token : token_));
+  }
+
+  tsl::Status DeleteRecursively(const std::string& dirname,
+                                TransactionToken* token,
+                                int64_t* undeleted_files,
+                                int64_t* undeleted_dirs) override {
+    return fs_->DeleteRecursively(dirname, (token ? token : token_),
+                                  undeleted_files, undeleted_dirs);
+  }
+
+  tsl::Status GetFileSize(const std::string& fname, TransactionToken* token,
+                          uint64* file_size) override {
+    return fs_->GetFileSize(fname, (token ? token : token_), file_size);
+  }
+
+  tsl::Status RenameFile(const std::string& src, const std::string& target,
+                         TransactionToken* token) override {
+    return fs_->RenameFile(src, target, (token ? token : token_));
+  }
+
+  tsl::Status CopyFile(const std::string& src, const std::string& target,
+                       TransactionToken* token) override {
+    return fs_->CopyFile(src, target, (token ? token : token_));
+  }
+
+  std::string TranslateName(const std::string& name) const override {
+    return fs_->TranslateName(name);
+  }
+
+  tsl::Status IsDirectory(const std::string& fname,
+                          TransactionToken* token) override {
+    return fs_->IsDirectory(fname, (token ? token : token_));
+  }
+
+  Status HasAtomicMove(const std::string& path,
+                       bool* has_atomic_move) override {
+    return fs_->HasAtomicMove(path, has_atomic_move);
+  }
+
+  void FlushCaches(TransactionToken* token) override {
+    return fs_->FlushCaches((token ? token : token_));
+  }
+
+  char Separator() const override { return fs_->Separator(); }
+
+  StringPiece Basename(StringPiece path) const override {
+    return fs_->Basename(path);
+  }
+
+  tsl::Status StartTransaction(TransactionToken** token) override {
+    return fs_->StartTransaction(token);
+  }
+
+  tsl::Status AddToTransaction(const std::string& path,
+                               TransactionToken* token) override {
+    return fs_->AddToTransaction(path, (token ? token : token_));
+  }
+
+  tsl::Status EndTransaction(TransactionToken* token) override {
+    return fs_->EndTransaction(token);
+  }
+
+  tsl::Status GetTransactionForPath(const std::string& path,
+                                    TransactionToken** token) override {
+    return fs_->GetTransactionForPath(path, token);
+  }
+
+  tsl::Status GetTokenOrStartTransaction(const std::string& path,
+                                         TransactionToken** token) override {
+    return fs_->GetTokenOrStartTransaction(path, token);
+  }
+
+  std::string DecodeTransaction(const TransactionToken* token) override {
+    return fs_->DecodeTransaction((token ? token : token_));
+  }
+
+  WrappedFileSystem(FileSystem* file_system, TransactionToken* token)
+      : fs_(file_system), token_(token) {}
+
+  ~WrappedFileSystem() override = default;
+
+ private:
+  FileSystem* fs_;
+  TransactionToken* token_;
+};
+
+/// A file abstraction for randomly reading the contents of a file.
+class RandomAccessFile {
+ public:
+  RandomAccessFile() {}
+  virtual ~RandomAccessFile() = default;
+
+  /// \brief Returns the name of the file.
+  ///
+  /// This is an optional operation that may not be implemented by every
+  /// filesystem.
+  virtual tsl::Status Name(StringPiece* result) const {
+    return errors::Unimplemented("This filesystem does not support Name()");
+  }
+
+  /// \brief Reads up to `n` bytes from the file starting at `offset`.
+  ///
+  /// `scratch[0..n-1]` may be written by this routine.  Sets `*result`
+  /// to the data that was read (including if fewer than `n` bytes were
+  /// successfully read).  May set `*result` to point at data in
+  /// `scratch[0..n-1]`, so `scratch[0..n-1]` must be live when
+  /// `*result` is used.
+  ///
+  /// On OK returned status: `n` bytes have been stored in `*result`.
+  /// On non-OK returned status: `[0..n]` bytes have been stored in `*result`.
+  ///
+  /// Returns `OUT_OF_RANGE` if fewer than n bytes were stored in `*result`
+  /// because of EOF.
+  ///
+  /// Safe for concurrent use by multiple threads.
+  virtual tsl::Status Read(uint64 offset, size_t n, StringPiece* result,
+                           char* scratch) const = 0;
+
+#if defined(TF_CORD_SUPPORT)
+  /// \brief Read up to `n` bytes from the file starting at `offset`.
+  virtual tsl::Status Read(uint64 offset, size_t n, absl::Cord* cord) const {
+    return errors::Unimplemented(
+        "Read(uint64, size_t, absl::Cord*) is not "
+        "implemented");
+  }
+#endif
+
+ private:
+  RandomAccessFile(const RandomAccessFile&) = delete;
+  void operator=(const RandomAccessFile&) = delete;
+};
+
+/// \brief A file abstraction for sequential writing.
+///
+/// The implementation must provide buffering since callers may append
+/// small fragments at a time to the file.
+class WritableFile {
+ public:
+  WritableFile() {}
+  virtual ~WritableFile() = default;
+
+  /// \brief Append 'data' to the file.
+  virtual tsl::Status Append(StringPiece data) = 0;
+
+#if defined(TF_CORD_SUPPORT)
+  // \brief Append 'data' to the file.
+  virtual tsl::Status Append(const absl::Cord& cord) {
+    for (StringPiece chunk : cord.Chunks()) {
+      TF_RETURN_IF_ERROR(Append(chunk));
+    }
+    return OkStatus();
+  }
+#endif
+
+  /// \brief Close the file.
+  ///
+  /// Flush() and de-allocate resources associated with this file
+  ///
+  /// Typical return codes (not guaranteed to be exhaustive):
+  ///  * OK
+  ///  * Other codes, as returned from Flush()
+  virtual tsl::Status Close() = 0;
+
+  /// \brief Flushes the file and optionally syncs contents to filesystem.
+  ///
+  /// This should flush any local buffers whose contents have not been
+  /// delivered to the filesystem.
+  ///
+  /// If the process terminates after a successful flush, the contents
+  /// may still be persisted, since the underlying filesystem may
+  /// eventually flush the contents.  If the OS or machine crashes
+  /// after a successful flush, the contents may or may not be
+  /// persisted, depending on the implementation.
+  virtual tsl::Status Flush() = 0;
+
+  // \brief Returns the name of the file.
+  ///
+  /// This is an optional operation that may not be implemented by every
+  /// filesystem.
+  virtual tsl::Status Name(StringPiece* result) const {
+    return errors::Unimplemented("This filesystem does not support Name()");
+  }
+
+  /// \brief Syncs contents of file to filesystem.
+  ///
+  /// This waits for confirmation from the filesystem that the contents
+  /// of the file have been persisted to the filesystem; if the OS
+  /// or machine crashes after a successful Sync, the contents should
+  /// be properly saved.
+  virtual tsl::Status Sync() = 0;
+
+  /// \brief Retrieves the current write position in the file, or -1 on
+  /// error.
+  ///
+  /// This is an optional operation, subclasses may choose to return
+  /// errors::Unimplemented.
+  virtual tsl::Status Tell(int64_t* position) {
+    *position = -1;
+    return errors::Unimplemented("This filesystem does not support Tell()");
+  }
+
+ private:
+  WritableFile(const WritableFile&) = delete;
+  void operator=(const WritableFile&) = delete;
+};
+
+/// \brief A readonly memmapped file abstraction.
+///
+/// The implementation must guarantee that all memory is accessible when the
+/// object exists, independently from the Env that created it.
+class ReadOnlyMemoryRegion {
+ public:
+  ReadOnlyMemoryRegion() {}
+  virtual ~ReadOnlyMemoryRegion() = default;
+
+  /// \brief Returns a pointer to the memory region.
+  virtual const void* data() = 0;
+
+  /// \brief Returns the length of the memory region in bytes.
+  virtual uint64 length() = 0;
+};
+
+/// \brief A registry for file system implementations.
+///
+/// Filenames are specified as an URI, which is of the form
+/// [scheme://]<filename>.
+/// File system implementations are registered using the REGISTER_FILE_SYSTEM
+/// macro, providing the 'scheme' as the key.
+///
+/// There are two `Register` methods: one using `Factory` for legacy filesystems
+/// (deprecated mechanism of subclassing `FileSystem` and using
+/// `REGISTER_FILE_SYSTEM` macro), and one using `std::unique_ptr<FileSystem>`
+/// for the new modular approach.
+///
+/// Note that the new API expects a pointer to `ModularFileSystem` but this is
+/// not checked as there should be exactly one caller to the API and doing the
+/// check results in a circular dependency between `BUILD` targets.
+///
+/// Plan is to completely remove the filesystem registration from `Env` and
+/// incorporate it into `ModularFileSystem` class (which will be renamed to be
+/// the only `FileSystem` class and marked as `final`). But this will happen at
+/// a later time, after we convert all filesystems to the new API.
+///
+/// TODO(b/139060984): After all filesystems are converted, remove old
+/// registration and update comment.
+class FileSystemRegistry {
+ public:
+  typedef std::function<FileSystem*()> Factory;
+
+  virtual ~FileSystemRegistry() = default;
+  virtual tsl::Status Register(const std::string& scheme, Factory factory) = 0;
+  virtual tsl::Status Register(const std::string& scheme,
+                               std::unique_ptr<FileSystem> filesystem) = 0;
+  virtual FileSystem* Lookup(const std::string& scheme) = 0;
+  virtual tsl::Status GetRegisteredFileSystemSchemes(
+      std::vector<std::string>* schemes) = 0;
+};
+
+/// \brief An abstraction for enforcing ACL checks in FileSystem.
+class FileAcl {
+ public:
+  virtual absl::Status CheckAccess(std::string_view path) = 0;
+  virtual ~FileAcl() = default;
+};
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_FILE_SYSTEM_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/file_system_helper.h

@@ -0,0 +1,64 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_FILE_SYSTEM_HELPER_H_
+#define TENSORFLOW_TSL_PLATFORM_FILE_SYSTEM_HELPER_H_
+
+#include <string>
+#include <vector>
+
+#include "tsl/platform/env.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace tsl {
+
+class FileSystem;
+class Env;
+
+namespace internal {
+
+// Given a pattern, stores in 'results' the set of paths (in the given file
+// system) that match that pattern.
+//
+// This helper may be used by implementations of FileSystem::GetMatchingPaths()
+// in order to provide parallel scanning of subdirectories (except on iOS).
+//
+// Arguments:
+//   fs: may not be null and will be used to identify directories and list
+//       their contents.
+//   env: may not be null and will be used to check if a match has been found.
+//   pattern: see FileSystem::GetMatchingPaths() for details.
+//   results: will be cleared and may not be null.
+//
+// Returns an error status if any call to 'fs' failed.
+Status GetMatchingPaths(FileSystem* fs, Env* env, const string& pattern,
+                        std::vector<string>* results);
+
+// Given a file path, determines whether the file exists. This helper simplifies
+// the use of Env::FileExists.
+//
+// Arguments:
+//   env: may not be null.
+//   fname: the file path to look up
+//
+// Returns true if the file exists, false if it does not exist, or an error
+// Status.
+StatusOr<bool> FileExists(Env* env, const string& fname);
+
+}  // namespace internal
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_FILE_SYSTEM_HELPER_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/fingerprint.h

@@ -0,0 +1,127 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_FINGERPRINT_H_
+#define TENSORFLOW_TSL_PLATFORM_FINGERPRINT_H_
+
+#include "tsl/platform/platform.h"
+#include "tsl/platform/stringpiece.h"
+#include "tsl/platform/types.h"
+
+#if TSL_IS_IN_OSS
+#define USE_OSS_FARMHASH
+#endif  // TSL_IS_IN_OSS
+
+#ifdef USE_OSS_FARMHASH
+#include <farmhash.h>
+#else
+#include "util/hash/farmhash_fingerprint.h"
+#endif
+
+namespace tsl {
+
+struct Fprint128 {
+  uint64_t low64;
+  uint64_t high64;
+};
+
+inline bool operator==(const Fprint128& lhs, const Fprint128& rhs) {
+  return lhs.low64 == rhs.low64 && lhs.high64 == rhs.high64;
+}
+
+struct Fprint128Hasher {
+  size_t operator()(const Fprint128& v) const {
+    // Low64 should be sufficiently mixed to allow use of it as a Hash.
+    return static_cast<size_t>(v.low64);
+  }
+};
+
+namespace internal {
+// Mixes some of the bits that got propagated to the high bits back into the
+// low bits.
+inline uint64_t ShiftMix(const uint64_t val) { return val ^ (val >> 47); }
+}  // namespace internal
+
+// This concatenates two 64-bit fingerprints. It is a convenience function to
+// get a fingerprint for a combination of already fingerprinted components. For
+// example this code is used to concatenate the hashes from each of the features
+// on sparse crosses.
+//
+// One shouldn't expect FingerprintCat64(Fingerprint64(x), Fingerprint64(y))
+// to indicate anything about FingerprintCat64(StrCat(x, y)). This operation
+// is not commutative.
+//
+// From a security standpoint, we don't encourage this pattern to be used
+// for everything as it is vulnerable to length-extension attacks and it
+// is easier to compute multicollisions.
+inline uint64_t FingerprintCat64(const uint64_t fp1, const uint64_t fp2) {
+  static const uint64_t kMul = 0xc6a4a7935bd1e995ULL;
+  uint64_t result = fp1 ^ kMul;
+  result ^= internal::ShiftMix(fp2 * kMul) * kMul;
+  result *= kMul;
+  result = internal::ShiftMix(result) * kMul;
+  result = internal::ShiftMix(result);
+  return result;
+}
+
+// This is a portable fingerprint interface for strings that will never change.
+// However, it is not suitable for cryptography.
+inline uint64_t Fingerprint64(const tsl::StringPiece s) {
+#ifdef USE_OSS_FARMHASH
+  return ::util::Fingerprint64(s.data(), s.size());
+#else
+  // Fingerprint op depends on the fact that Fingerprint64() is implemented by
+  // Farmhash. If the implementation ever changes, Fingerprint op should be
+  // modified to keep using Farmhash.
+  // LINT.IfChange
+  return farmhash::Fingerprint64(s.data(), s.size());
+  // LINT.ThenChange(//tensorflow/core/kernels/fingerprint_op.cc)
+#endif
+}
+
+// 32-bit variant of Fingerprint64 above (same properties and caveats apply).
+inline uint32_t Fingerprint32(const tsl::StringPiece s) {
+#ifdef USE_OSS_FARMHASH
+  return ::util::Fingerprint32(s.data(), s.size());
+#else
+  return farmhash::Fingerprint32(s.data(), s.size());
+#endif
+}
+
+// 128-bit variant of Fingerprint64 above (same properties and caveats apply).
+inline Fprint128 Fingerprint128(const tsl::StringPiece s) {
+#ifdef USE_OSS_FARMHASH
+  const auto fingerprint = ::util::Fingerprint128(s.data(), s.size());
+  return {::util::Uint128Low64(fingerprint),
+          ::util::Uint128High64(fingerprint)};
+#else
+  const auto fingerprint = farmhash::Fingerprint128(s.data(), s.size());
+  return {absl::Uint128Low64(fingerprint), absl::Uint128High64(fingerprint)};
+#endif
+}
+
+inline Fprint128 FingerprintCat128(const Fprint128& a, const Fprint128& b) {
+  return {FingerprintCat64(a.low64, b.low64),
+          FingerprintCat64(a.high64, b.high64)};
+}
+
+inline Fprint128 FingerprintCat128(const Fprint128& a, const uint64_t b) {
+  auto x = FingerprintCat64(a.low64, b);
+  return {x, FingerprintCat64(a.high64, x)};
+}
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_FINGERPRINT_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/gif.h

@@ -0,0 +1,21 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_GIF_H_
+#define TENSORFLOW_TSL_PLATFORM_GIF_H_
+
+#include "gif_lib.h"  // from @gif
+
+#endif  // TENSORFLOW_TSL_PLATFORM_GIF_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/hash.h

@@ -0,0 +1,135 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Simple hash functions used for internal data structures
+
+#ifndef TENSORFLOW_TSL_PLATFORM_HASH_H_
+#define TENSORFLOW_TSL_PLATFORM_HASH_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <functional>
+#include <string>
+
+#include "tsl/platform/stringpiece.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+
+extern uint32 Hash32(const char* data, size_t n, uint32 seed);
+extern uint64 Hash64(const char* data, size_t n, uint64 seed);
+
+inline uint64 Hash64(const char* data, size_t n) {
+  return Hash64(data, n, 0xDECAFCAFFE);
+}
+
+inline uint64 Hash64(const char* data) { return Hash64(data, ::strlen(data)); }
+
+inline uint64 Hash64(const std::string& str) {
+  return Hash64(str.data(), str.size());
+}
+
+inline uint64 Hash64(const tstring& str) {
+  return Hash64(str.data(), str.size());
+}
+
+inline uint64 Hash64Combine(uint64 a, uint64 b) {
+  return a ^ (b + 0x9e3779b97f4a7800ULL + (a << 10) + (a >> 4));
+}
+
+// Combine two hashes in an order-independent way. This operation should be
+// associative and compute the same hash for a collection of elements
+// independent of traversal order. Note that it is better to combine hashes
+// symmetrically with addition rather than XOR, since (x^x) == 0 but (x+x) != 0.
+inline uint64 Hash64CombineUnordered(uint64 a, uint64 b) { return a + b; }
+
+// Hash functor suitable for use with power-of-two sized hashtables.  Use
+// instead of std::hash<T>.
+//
+// In particular, tsl::hash is not the identity function for pointers.
+// This is important for power-of-two sized hashtables like FlatMap and FlatSet,
+// because otherwise they waste the majority of their hash buckets.
+//
+// The second type argument is only used for SFNIAE below.
+template <typename T, typename = void>
+struct hash {
+  size_t operator()(const T& t) const { return std::hash<T>()(t); }
+};
+
+template <typename T>
+struct hash<T, typename std::enable_if<std::is_enum<T>::value>::type> {
+  size_t operator()(T value) const {
+    // This works around a defect in the std::hash C++ spec that isn't fixed in
+    // (at least) gcc 4.8.4:
+    // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2148
+    //
+    // We should be able to remove this and use the default
+    // tsl::hash<EnumTy>() once we stop building with GCC versions old
+    // enough to not have this defect fixed.
+    return std::hash<uint64>()(static_cast<uint64>(value));
+  }
+};
+
+template <typename T>
+struct hash<T*> {
+  size_t operator()(const T* t) const {
+    // Hash pointers as integers, but bring more entropy to the lower bits.
+    size_t k = static_cast<size_t>(reinterpret_cast<uintptr_t>(t));
+    return k + (k >> 6);
+  }
+};
+
+template <>
+struct hash<string> {
+  size_t operator()(const string& s) const {
+    return static_cast<size_t>(Hash64(s));
+  }
+};
+
+template <>
+struct hash<tstring> {
+  size_t operator()(const tstring& s) const {
+    return static_cast<size_t>(Hash64(s.data(), s.size()));
+  }
+};
+
+template <>
+struct hash<StringPiece> {
+  size_t operator()(StringPiece sp) const {
+    return static_cast<size_t>(Hash64(sp.data(), sp.size()));
+  }
+};
+using StringPieceHasher = ::tsl::hash<StringPiece>;
+
+template <typename T, typename U>
+struct hash<std::pair<T, U>> {
+  size_t operator()(const std::pair<T, U>& p) const {
+    return Hash64Combine(hash<T>()(p.first), hash<U>()(p.second));
+  }
+};
+
+}  // namespace tsl
+
+namespace std {
+template <>
+struct hash<tsl::tstring> {
+  size_t operator()(const tsl::tstring& s) const {
+    return static_cast<size_t>(tsl::Hash64(s.data(), s.size()));
+  }
+};
+}  // namespace std
+
+#endif  // TENSORFLOW_TSL_PLATFORM_HASH_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/host_info.h

@@ -0,0 +1,58 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_HOST_INFO_H_
+#define TENSORFLOW_TSL_PLATFORM_HOST_INFO_H_
+
+#include <cstdint>
+
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace port {
+
+// Statistical data of IO operations performed by the job.
+struct IOStatistics {
+  struct Distribution {
+    uint64_t count = 0;
+    double mean = 0.0;
+    double std_dev = 0.0;
+  };
+  // Distribution of round trip IO latency in microseconds.
+  Distribution roundtrip_latency_usec;
+  // Distribution of data received by IO reads in bytes.
+  Distribution response_bytes;
+};
+
+// Return the hostname of the machine on which this process is running.
+string Hostname();
+
+// Return the job name as a string if it exists, otherwise return an empty
+// string.
+string JobName();
+
+// Returns the Borg job UID as an int64_t if it exists. Otherwise return -1.
+int64_t JobUid();
+
+// Returns the Borg task ID as an int64_t if it exists. Otherwise return -1.
+int64_t TaskId();
+
+// Retrieves the host file read statistics.
+IOStatistics GetIOStatistics();
+
+}  // namespace port
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_HOST_INFO_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/human_readable_json.h

@@ -0,0 +1,45 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_HUMAN_READABLE_JSON_H_
+#define TENSORFLOW_TSL_PLATFORM_HUMAN_READABLE_JSON_H_
+
+#include "tsl/platform/protobuf.h"
+#include "tsl/platform/status.h"
+
+namespace tsl {
+
+// Converts a proto to a JSON-like string that's meant to be human-readable
+// but still machine-parseable.
+//
+// This string may not be strictly JSON-compliant, but it must be parseable by
+// HumanReadableJSONToProto.
+//
+// When ignore_accuracy_loss = true, this function may ignore JavaScript
+// accuracy loss with large integers.
+Status ProtoToHumanReadableJson(const protobuf::Message& proto, string* result,
+                                bool ignore_accuracy_loss);
+Status ProtoToHumanReadableJson(const protobuf::MessageLite& proto,
+                                string* result, bool ignore_accuracy_loss);
+
+// Converts a string produced by ProtoToHumanReadableJSON to a protobuf.  Not
+// guaranteed to work for general JSON.
+Status HumanReadableJsonToProto(const string& str, protobuf::Message* proto);
+Status HumanReadableJsonToProto(const string& str,
+                                protobuf::MessageLite* proto);
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_HUMAN_READABLE_JSON_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/init_main.h

@@ -0,0 +1,27 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_INIT_MAIN_H_
+#define TENSORFLOW_TSL_PLATFORM_INIT_MAIN_H_
+
+namespace tsl {
+namespace port {
+
+void InitMain(const char* usage, int* argc, char*** argv);
+
+}  // namespace port
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_INIT_MAIN_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/jpeg.h

@@ -0,0 +1,29 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_JPEG_H_
+#define TENSORFLOW_TSL_PLATFORM_JPEG_H_
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+extern "C" {
+#include "jerror.h"  // from @libjpeg_turbo   // IWYU pragma: export
+#include "jpeglib.h"  // from @libjpeg_turbo  // IWYU pragma: export
+}
+
+#endif  // TENSORFLOW_TSL_PLATFORM_JPEG_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/load_library.h

@@ -0,0 +1,37 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_LOAD_LIBRARY_H_
+#define TENSORFLOW_TSL_PLATFORM_LOAD_LIBRARY_H_
+
+#include <string>
+
+#include "absl/status/status.h"
+
+namespace tsl {
+
+namespace internal {
+
+absl::Status LoadDynamicLibrary(const char* library_filename, void** handle);
+absl::Status GetSymbolFromLibrary(void* handle, const char* symbol_name,
+                                  void** symbol);
+std::string FormatLibraryFileName(const std::string& name,
+                                  const std::string& version);
+
+}  // namespace internal
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_LOAD_LIBRARY_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/logging.h

@@ -0,0 +1,29 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_LOGGING_H_
+#define TENSORFLOW_TSL_PLATFORM_LOGGING_H_
+
+#include "tsl/platform/platform.h"
+
+#if defined(PLATFORM_GOOGLE) || defined(PLATFORM_GOOGLE_ANDROID) || \
+    defined(PLATFORM_GOOGLE_IOS) || defined(GOOGLE_LOGGING) ||      \
+    defined(__EMSCRIPTEN__) || defined(PLATFORM_CHROMIUMOS)
+#include "tsl/platform/google/logging.h"  // IWYU pragma: export
+#else
+#include "tsl/platform/default/logging.h"  // IWYU pragma: export
+#endif
+
+#endif  // TENSORFLOW_TSL_PLATFORM_LOGGING_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/macros.h

@@ -0,0 +1,162 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_MACROS_H_
+#define TENSORFLOW_TSL_PLATFORM_MACROS_H_
+
+// Compiler attributes
+#if (defined(__GNUC__) || defined(__APPLE__)) && !defined(SWIG)
+// Compiler supports GCC-style attributes
+#define TF_ATTRIBUTE_NORETURN __attribute__((noreturn))
+#define TF_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
+#define TF_ATTRIBUTE_NOINLINE __attribute__((noinline))
+#define TF_ATTRIBUTE_UNUSED __attribute__((unused))
+#define TF_ATTRIBUTE_COLD __attribute__((cold))
+#define TF_ATTRIBUTE_WEAK __attribute__((weak))
+#define TF_PACKED __attribute__((packed))
+#define TF_MUST_USE_RESULT __attribute__((warn_unused_result))
+#define TF_PRINTF_ATTRIBUTE(string_index, first_to_check) \
+  __attribute__((__format__(__printf__, string_index, first_to_check)))
+#define TF_SCANF_ATTRIBUTE(string_index, first_to_check) \
+  __attribute__((__format__(__scanf__, string_index, first_to_check)))
+#elif defined(_MSC_VER)
+// Non-GCC equivalents
+#define TF_ATTRIBUTE_NORETURN __declspec(noreturn)
+#define TF_ATTRIBUTE_ALWAYS_INLINE __forceinline
+#define TF_ATTRIBUTE_NOINLINE
+#define TF_ATTRIBUTE_UNUSED
+#define TF_ATTRIBUTE_COLD
+#define TF_ATTRIBUTE_WEAK
+#define TF_MUST_USE_RESULT
+#define TF_PACKED
+#define TF_PRINTF_ATTRIBUTE(string_index, first_to_check)
+#define TF_SCANF_ATTRIBUTE(string_index, first_to_check)
+#else
+// Non-GCC equivalents
+#define TF_ATTRIBUTE_NORETURN
+#define TF_ATTRIBUTE_ALWAYS_INLINE
+#define TF_ATTRIBUTE_NOINLINE
+#define TF_ATTRIBUTE_UNUSED
+#define TF_ATTRIBUTE_COLD
+#define TF_ATTRIBUTE_WEAK
+#define TF_MUST_USE_RESULT
+#define TF_PACKED
+#define TF_PRINTF_ATTRIBUTE(string_index, first_to_check)
+#define TF_SCANF_ATTRIBUTE(string_index, first_to_check)
+#endif
+
+// Control visibility outside .so
+#if defined(_WIN32)
+#ifdef TF_COMPILE_LIBRARY
+#define TF_EXPORT __declspec(dllexport)
+#else
+#define TF_EXPORT __declspec(dllimport)
+#endif  // TF_COMPILE_LIBRARY
+#else
+#define TF_EXPORT __attribute__((visibility("default")))
+#endif  // _WIN32
+
+#ifdef __has_builtin
+#define TF_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#define TF_HAS_BUILTIN(x) 0
+#endif
+
+// C++11-style attributes (N2761)
+#if defined(__has_cpp_attribute)
+// Safely checks if an attribute is supported. Equivalent to
+// ABSL_HAVE_CPP_ATTRIBUTE.
+#define TF_HAS_CPP_ATTRIBUTE(n) __has_cpp_attribute(n)
+#else
+#define TF_HAS_CPP_ATTRIBUTE(n) 0
+#endif
+
+// [[clang::annotate("x")]] allows attaching custom strings (e.g. "x") to
+// declarations (variables, functions, fields, etc.) for use by tools. They are
+// represented in the Clang AST (as AnnotateAttr nodes) and in LLVM IR, but not
+// in final output.
+#if TF_HAS_CPP_ATTRIBUTE(clang::annotate)
+#define TF_ATTRIBUTE_ANNOTATE(str) [[clang::annotate(str)]]
+#else
+#define TF_ATTRIBUTE_ANNOTATE(str)
+#endif
+
+// A variable declaration annotated with the `TF_CONST_INIT` attribute will
+// not compile (on supported platforms) unless the variable has a constant
+// initializer.
+#if TF_HAS_CPP_ATTRIBUTE(clang::require_constant_initialization)
+#define TF_CONST_INIT [[clang::require_constant_initialization]]
+#else
+#define TF_CONST_INIT
+#endif
+
+// Compilers can be told that a certain branch is not likely to be taken
+// (for instance, a CHECK failure), and use that information in static
+// analysis. Giving it this information can help it optimize for the
+// common case in the absence of better information (ie.
+// -fprofile-arcs).
+#if TF_HAS_BUILTIN(__builtin_expect) || (defined(__GNUC__) && __GNUC__ >= 3)
+#define TF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
+#define TF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
+#else
+#define TF_PREDICT_FALSE(x) (x)
+#define TF_PREDICT_TRUE(x) (x)
+#endif
+
+// DEPRECATED: directly use the macro implementation instead.
+// A macro to disallow the copy constructor and operator= functions
+// This is usually placed in the private: declarations for a class.
+#define TF_DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&) = delete;         \
+  void operator=(const TypeName&) = delete
+
+// The TF_ARRAYSIZE(arr) macro returns the # of elements in an array arr.
+//
+// The expression TF_ARRAYSIZE(a) is a compile-time constant of type
+// size_t.
+#define TF_ARRAYSIZE(a)         \
+  ((sizeof(a) / sizeof(*(a))) / \
+   static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
+
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L || \
+    (defined(_MSC_VER) && _MSC_VER >= 1900)
+// Define this to 1 if the code is compiled in C++11 mode; leave it
+// undefined otherwise.  Do NOT define it to 0 -- that causes
+// '#ifdef LANG_CXX11' to behave differently from '#if LANG_CXX11'.
+#define LANG_CXX11 1
+#endif
+
+#if defined(__clang__) && defined(LANG_CXX11) && defined(__has_warning)
+#if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+#define TF_FALLTHROUGH_INTENDED [[clang::fallthrough]]  // NOLINT
+#endif
+#endif
+
+#ifndef TF_FALLTHROUGH_INTENDED
+#define TF_FALLTHROUGH_INTENDED \
+  do {                          \
+  } while (0)
+#endif
+
+namespace tsl {
+namespace internal {
+template <typename T>
+void remove_unused_variable_compiler_warning(const T&){};
+}  // namespace internal
+}  // namespace tsl
+#define TF_UNUSED_VARIABLE(x) \
+  tensorflow::internal::remove_unused_variable_compiler_warning(x)
+
+#endif  // TENSORFLOW_TSL_PLATFORM_MACROS_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/mem.h

@@ -0,0 +1,86 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_MEM_H_
+#define TENSORFLOW_TSL_PLATFORM_MEM_H_
+
+// TODO(cwhipkey): remove this when callers use annotations directly.
+#include "tsl/platform/dynamic_annotations.h"
+#include "tsl/platform/platform.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace port {
+
+// Aligned allocation/deallocation. `minimum_alignment` must be a power of 2
+// and a multiple of sizeof(void*).
+void* AlignedMalloc(size_t size, int minimum_alignment);
+void AlignedFree(void* aligned_memory);
+
+void* Malloc(size_t size);
+void* Realloc(void* ptr, size_t size);
+void Free(void* ptr);
+
+// Tries to release num_bytes of free memory back to the operating
+// system for reuse.  Use this routine with caution -- to get this
+// memory back may require faulting pages back in by the OS, and
+// that may be slow.
+//
+// Currently, if a malloc implementation does not support this
+// routine, this routine is a no-op.
+void MallocExtension_ReleaseToSystem(std::size_t num_bytes);
+
+// Returns the actual number N of bytes reserved by the malloc for the
+// pointer p.  This number may be equal to or greater than the number
+// of bytes requested when p was allocated.
+//
+// This routine is just useful for statistics collection.  The
+// client must *not* read or write from the extra bytes that are
+// indicated by this call.
+//
+// Example, suppose the client gets memory by calling
+//    p = malloc(10)
+// and GetAllocatedSize(p) may return 16.  The client must only use the
+// first 10 bytes p[0..9], and not attempt to read or write p[10..15].
+//
+// Currently, if a malloc implementation does not support this
+// routine, this routine returns 0.
+std::size_t MallocExtension_GetAllocatedSize(const void* p);
+
+struct MemoryInfo {
+  int64_t total = 0;
+  int64_t free = 0;
+};
+
+struct MemoryBandwidthInfo {
+  int64_t bw_used = 0;  // memory bandwidth used across all CPU (in MBs/second)
+};
+
+// Retrieves the host memory information. If any of the fields in the returned
+// MemoryInfo structure is INT64_MAX, it means such information is not
+// available.
+MemoryInfo GetMemoryInfo();
+
+// Retrieves the host memory bandwidth information. If any field in the returned
+// structure is INT64_MAX, it means such information is not available.
+MemoryBandwidthInfo GetMemoryBandwidthInfo();
+
+// Returns the amount of RAM available in bytes, or INT64_MAX if unknown.
+static inline int64_t AvailableRam() { return GetMemoryInfo().free; }
+
+}  // namespace port
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_MEM_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/ml_dtypes.h

@@ -0,0 +1,35 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_ML_DTYPES_H_
+#define TENSORFLOW_TSL_PLATFORM_ML_DTYPES_H_
+
+#include "ml_dtypes/include/float8.h"  // from @ml_dtypes
+#include "ml_dtypes/include/int4.h"  // from @ml_dtypes
+
+namespace tsl {
+using float8_e4m3fn = ml_dtypes::float8_e4m3fn;
+using float8_e4m3fnuz = ml_dtypes::float8_e4m3fnuz;
+using float8_e4m3b11fnuz = ml_dtypes::float8_e4m3b11fnuz;
+using float8_e4m3b11 = float8_e4m3b11fnuz;  // Deprecated: old name for
+                                            // backward-compatibility only.
+using float8_e5m2 = ml_dtypes::float8_e5m2;
+using float8_e5m2fnuz = ml_dtypes::float8_e5m2fnuz;
+
+using int4 = ml_dtypes::int4;
+using uint4 = ml_dtypes::uint4;
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_ML_DTYPES_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/mutex.h

@@ -0,0 +1,332 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_MUTEX_H_
+#define TENSORFLOW_TSL_PLATFORM_MUTEX_H_
+
+#include <chrono>  // NOLINT
+// for std::try_to_lock_t and std::cv_status
+#include <condition_variable>  // NOLINT
+#include <mutex>               // NOLINT
+
+#include "tsl/platform/platform.h"
+#include "tsl/platform/thread_annotations.h"
+#include "tsl/platform/types.h"
+
+// Include appropriate platform-dependent implementation details of mutex etc.
+#if defined(PLATFORM_GOOGLE)
+#include "tsl/platform/google/mutex_data.h"
+#elif defined(PLATFORM_POSIX) || defined(PLATFORM_POSIX_ANDROID) ||    \
+    defined(PLATFORM_GOOGLE_ANDROID) || defined(PLATFORM_POSIX_IOS) || \
+    defined(PLATFORM_GOOGLE_IOS) || defined(PLATFORM_WINDOWS)
+#include "tsl/platform/default/mutex_data.h"
+#else
+#error Define the appropriate PLATFORM_<foo> macro for this platform
+#endif
+
+namespace tsl {
+
+enum ConditionResult { kCond_Timeout, kCond_MaybeNotified };
+enum LinkerInitialized { LINKER_INITIALIZED };
+
+class condition_variable;
+class Condition;
+
+// Mimic std::mutex + C++17's shared_mutex, adding a LinkerInitialized
+// constructor interface.  This type is as fast as mutex, but is also a shared
+// lock, and provides conditional critical sections (via Await()), as an
+// alternative to condition variables.
+class TF_LOCKABLE mutex {
+ public:
+  mutex();
+  // The default implementation of the underlying mutex is safe to use after
+  // the linker initialization to zero.
+  explicit constexpr mutex(LinkerInitialized x)
+      :
+#if defined(PLATFORM_GOOGLE)
+        mu_(absl::kConstInit)
+#else
+        mu_()
+#endif
+  {
+  }
+
+  void lock() TF_EXCLUSIVE_LOCK_FUNCTION();
+  bool try_lock() TF_EXCLUSIVE_TRYLOCK_FUNCTION(true);
+  void unlock() TF_UNLOCK_FUNCTION();
+
+  void lock_shared() TF_SHARED_LOCK_FUNCTION();
+  bool try_lock_shared() TF_SHARED_TRYLOCK_FUNCTION(true);
+  void unlock_shared() TF_UNLOCK_FUNCTION();
+
+  // -------
+  // Conditional critical sections.
+  // These represent an alternative to condition variables that is easier to
+  // use.  The predicate must be encapsulated in a function (via Condition),
+  // but there is no need to use a while-loop, and no need to signal the
+  // condition.  Example:  suppose "mu" protects "counter"; we wish one thread
+  // to wait until counter is decremented to zero by another thread.
+  //   // Predicate expressed as a function:
+  //   static bool IntIsZero(int* pi) { return *pi == 0; }
+  //
+  //   // Waiter:
+  //   mu.lock();
+  //   mu.Await(Condition(&IntIsZero, &counter));   // no loop needed
+  //   // lock is held and counter==0...
+  //   mu.unlock();
+  //
+  //   // Decrementer:
+  //   mu.lock();
+  //   counter--;
+  //   mu.unlock();    // no need to signal; mutex will check condition
+  //
+  // A mutex may be used with condition variables and conditional critical
+  // sections at the same time.  Conditional critical sections are easier to
+  // use, but if there are multiple conditions that are simultaneously false,
+  // condition variables may be faster.
+
+  // Unlock *this and wait until cond.Eval() is true, then atomically reacquire
+  // *this in the same mode in which it was previously held and return.
+  void Await(const Condition& cond);
+
+  // Unlock *this and wait until either cond.Eval is true, or abs_deadline_ns
+  // has been reached, then atomically reacquire *this in the same mode in
+  // which it was previously held, and return whether cond.Eval() is true.
+  // See tsl/tsl/platform/env_time.h for the time interface.
+  bool AwaitWithDeadline(const Condition& cond, uint64 abs_deadline_ns);
+  // -------
+
+ private:
+  friend class condition_variable;
+  internal::MuData mu_;
+};
+
+// A Condition represents a predicate on state protected by a mutex.  The
+// function must have no side-effects on that state.  When passed to
+// mutex::Await(), the function will be called with the mutex held.  It may be
+// called:
+// - any number of times;
+// - by any thread using the mutex; and/or
+// - with the mutex held in any mode (read or write).
+// If you must use a lambda, prefix the lambda with +, and capture no variables.
+// For example:  Condition(+[](int *pi)->bool { return *pi == 0; }, &i)
+class Condition {
+ public:
+  template <typename T>
+  Condition(bool (*func)(T* arg), T* arg);  // Value is (*func)(arg)
+  template <typename T>
+  Condition(T* obj, bool (T::*method)());  // Value is obj->*method()
+  template <typename T>
+  Condition(T* obj, bool (T::*method)() const);  // Value is obj->*method()
+  explicit Condition(const bool* flag);          // Value is *flag
+
+  // Return the value of the predicate represented by this Condition.
+  bool Eval() const { return (*this->eval_)(this); }
+
+ private:
+  bool (*eval_)(const Condition*);  // CallFunction, CallMethod, or, ReturnBool
+  bool (*function_)(void*);         // predicate of form (*function_)(arg_)
+  bool (Condition::*method_)();     // predicate of form arg_->method_()
+  void* arg_;
+  Condition();
+  // The following functions can be pointed to by the eval_ field.
+  template <typename T>
+  static bool CallFunction(const Condition* cond);  // call function_
+  template <typename T>
+  static bool CallMethod(const Condition* cond);  // call method_
+  static bool ReturnBool(const Condition* cond);  // access *(bool *)arg_
+};
+
+// Mimic a subset of the std::unique_lock<tsl::mutex> functionality.
+class TF_SCOPED_LOCKABLE mutex_lock {
+ public:
+  typedef ::tsl::mutex mutex_type;
+
+  explicit mutex_lock(mutex_type& mu) TF_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(&mu) {
+    mu_->lock();
+  }
+
+  mutex_lock(mutex_type& mu, std::try_to_lock_t) TF_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(&mu) {
+    if (!mu.try_lock()) {
+      mu_ = nullptr;
+    }
+  }
+
+  // Manually nulls out the source to prevent double-free.
+  // (std::move does not null the source pointer by default.)
+  mutex_lock(mutex_lock&& ml) noexcept TF_EXCLUSIVE_LOCK_FUNCTION(ml.mu_)
+      : mu_(ml.mu_) {
+    ml.mu_ = nullptr;
+  }
+  ~mutex_lock() TF_UNLOCK_FUNCTION() {
+    if (mu_ != nullptr) {
+      mu_->unlock();
+    }
+  }
+  mutex_type* mutex() { return mu_; }
+
+  explicit operator bool() const { return mu_ != nullptr; }
+
+ private:
+  mutex_type* mu_;
+};
+
+// Catch bug where variable name is omitted, e.g. mutex_lock (mu);
+#define mutex_lock(x) static_assert(0, "mutex_lock_decl_missing_var_name");
+
+// Mimic a subset of the std::shared_lock<tsl::mutex> functionality.
+// Name chosen to minimize conflicts with the tf_shared_lock macro, below.
+class TF_SCOPED_LOCKABLE tf_shared_lock {
+ public:
+  typedef ::tsl::mutex mutex_type;
+
+  explicit tf_shared_lock(mutex_type& mu) TF_SHARED_LOCK_FUNCTION(mu)
+      : mu_(&mu) {
+    mu_->lock_shared();
+  }
+
+  tf_shared_lock(mutex_type& mu, std::try_to_lock_t) TF_SHARED_LOCK_FUNCTION(mu)
+      : mu_(&mu) {
+    if (!mu.try_lock_shared()) {
+      mu_ = nullptr;
+    }
+  }
+
+  // Manually nulls out the source to prevent double-free.
+  // (std::move does not null the source pointer by default.)
+  tf_shared_lock(tf_shared_lock&& ml) noexcept TF_SHARED_LOCK_FUNCTION(ml.mu_)
+      : mu_(ml.mu_) {
+    ml.mu_ = nullptr;
+  }
+  ~tf_shared_lock() TF_UNLOCK_FUNCTION() {
+    if (mu_ != nullptr) {
+      mu_->unlock_shared();
+    }
+  }
+  mutex_type* mutex() { return mu_; }
+
+  explicit operator bool() const { return mu_ != nullptr; }
+
+ private:
+  mutex_type* mu_;
+};
+
+// Catch bug where variable name is omitted, e.g. tf_shared_lock (mu);
+#define tf_shared_lock(x) \
+  static_assert(0, "tf_shared_lock_decl_missing_var_name");
+
+// Mimic std::condition_variable.
+class condition_variable {
+ public:
+  condition_variable();
+
+  void wait(mutex_lock& lock);
+
+  template <class Predicate>
+  void wait(mutex_lock& lock, Predicate stop_waiting) {
+    while (!stop_waiting()) {
+      wait(lock);
+    }
+  }
+
+  template <class Rep, class Period>
+  std::cv_status wait_for(mutex_lock& lock,
+                          std::chrono::duration<Rep, Period> dur);
+  void notify_one();
+  void notify_all();
+
+ private:
+  friend ConditionResult WaitForMilliseconds(mutex_lock* mu,
+                                             condition_variable* cv,
+                                             int64_t ms);
+  internal::CVData cv_;
+};
+
+// Like "cv->wait(*mu)", except that it only waits for up to "ms" milliseconds.
+//
+// Returns kCond_Timeout if the timeout expired without this
+// thread noticing a signal on the condition variable.  Otherwise may
+// return either kCond_Timeout or kCond_MaybeNotified
+inline ConditionResult WaitForMilliseconds(mutex_lock* mu,
+                                           condition_variable* cv, int64_t ms) {
+  std::cv_status s = cv->wait_for(*mu, std::chrono::milliseconds(ms));
+  return (s == std::cv_status::timeout) ? kCond_Timeout : kCond_MaybeNotified;
+}
+
+// ------------------------------------------------------------
+// Implementation details follow.   Clients should ignore them.
+
+// private static
+template <typename T>
+inline bool Condition::CallFunction(const Condition* cond) {
+  bool (*fn)(T*) = reinterpret_cast<bool (*)(T*)>(cond->function_);
+  return (*fn)(static_cast<T*>(cond->arg_));
+}
+
+template <typename T>
+inline Condition::Condition(bool (*func)(T*), T* arg)
+    : eval_(&CallFunction<T>),
+      function_(reinterpret_cast<bool (*)(void*)>(func)),
+      method_(nullptr),
+      arg_(const_cast<void*>(static_cast<const void*>(arg))) {}
+
+// private static
+template <typename T>
+inline bool Condition::CallMethod(const Condition* cond) {
+  bool (T::*m)() = reinterpret_cast<bool (T::*)()>(cond->method_);
+  return (static_cast<T*>(cond->arg_)->*m)();
+}
+
+template <typename T>
+inline Condition::Condition(T* obj, bool (T::*method)())
+    : eval_(&CallMethod<T>),
+      function_(nullptr),
+      method_(reinterpret_cast<bool (Condition::*)()>(method)),
+      arg_(const_cast<void*>(static_cast<const void*>(obj))) {}
+
+template <typename T>
+inline Condition::Condition(T* obj, bool (T::*method)() const)
+    : eval_(&CallMethod<T>),
+      function_(nullptr),
+      method_(reinterpret_cast<bool (Condition::*)()>(method)),
+      arg_(const_cast<void*>(static_cast<const void*>(obj))) {}
+
+// private static
+inline bool Condition::ReturnBool(const Condition* cond) {
+  return *static_cast<bool*>(cond->arg_);
+}
+
+inline Condition::Condition(const bool* flag)
+    : eval_(&ReturnBool),
+      function_(nullptr),
+      method_(nullptr),
+      arg_(const_cast<void*>(static_cast<const void*>(flag))) {}
+
+}  // namespace tsl
+
+// Include appropriate platform-dependent implementation details of mutex etc.
+#if defined(PLATFORM_GOOGLE)
+#include "tsl/platform/google/mutex.h"
+#elif defined(PLATFORM_POSIX) || defined(PLATFORM_POSIX_ANDROID) ||    \
+    defined(PLATFORM_GOOGLE_ANDROID) || defined(PLATFORM_POSIX_IOS) || \
+    defined(PLATFORM_GOOGLE_IOS) || defined(PLATFORM_WINDOWS)
+#include "tsl/platform/default/mutex.h"
+#else
+#error Define the appropriate PLATFORM_<foo> macro for this platform
+#endif
+
+#endif  // TENSORFLOW_TSL_PLATFORM_MUTEX_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/net.h

@@ -0,0 +1,27 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_NET_H_
+#define TENSORFLOW_TSL_PLATFORM_NET_H_
+
+namespace tsl {
+namespace internal {
+
+int PickUnusedPortOrDie();
+
+}  // namespace internal
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_NET_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/notification.h

@@ -0,0 +1,40 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_NOTIFICATION_H_
+#define TENSORFLOW_TSL_PLATFORM_NOTIFICATION_H_
+
+#include <chrono>              // NOLINT
+#include <condition_variable>  // NOLINT
+#include <cstdint>
+#include <mutex>  // NOLINT
+
+#include "absl/synchronization/notification.h"
+#include "absl/time/time.h"
+
+namespace tsl {
+
+using absl::Notification;
+
+// TODO(ddunleavy): remove this method and replace uses of `tsl::Notification`
+// with `absl::Notification`.
+inline bool WaitForNotificationWithTimeout(Notification* n,
+                                           int64_t timeout_in_us) {
+  return n->WaitForNotificationWithTimeout(absl::Microseconds(timeout_in_us));
+}
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_NOTIFICATION_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/null_file_system.h

@@ -0,0 +1,111 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_NULL_FILE_SYSTEM_H_
+#define TENSORFLOW_TSL_PLATFORM_NULL_FILE_SYSTEM_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tsl/platform/env.h"
+#include "tsl/platform/file_system.h"
+#include "tsl/platform/file_system_helper.h"
+
+namespace tsl {
+
+// START_SKIP_DOXYGEN
+
+#ifndef SWIG
+// Degenerate file system that provides no implementations.
+class NullFileSystem : public FileSystem {
+ public:
+  NullFileSystem() {}
+
+  ~NullFileSystem() override = default;
+
+  TF_USE_FILESYSTEM_METHODS_WITH_NO_TRANSACTION_SUPPORT;
+
+  Status NewRandomAccessFile(
+      const string& fname, TransactionToken* token,
+      std::unique_ptr<RandomAccessFile>* result) override {
+    return errors::Unimplemented("NewRandomAccessFile unimplemented");
+  }
+
+  Status NewWritableFile(const string& fname, TransactionToken* token,
+                         std::unique_ptr<WritableFile>* result) override {
+    return errors::Unimplemented("NewWritableFile unimplemented");
+  }
+
+  Status NewAppendableFile(const string& fname, TransactionToken* token,
+                           std::unique_ptr<WritableFile>* result) override {
+    return errors::Unimplemented("NewAppendableFile unimplemented");
+  }
+
+  Status NewReadOnlyMemoryRegionFromFile(
+      const string& fname, TransactionToken* token,
+      std::unique_ptr<ReadOnlyMemoryRegion>* result) override {
+    return errors::Unimplemented(
+        "NewReadOnlyMemoryRegionFromFile unimplemented");
+  }
+
+  Status FileExists(const string& fname, TransactionToken* token) override {
+    return errors::Unimplemented("FileExists unimplemented");
+  }
+
+  Status GetChildren(const string& dir, TransactionToken* token,
+                     std::vector<string>* result) override {
+    return errors::Unimplemented("GetChildren unimplemented");
+  }
+
+  Status GetMatchingPaths(const string& pattern, TransactionToken* token,
+                          std::vector<string>* results) override {
+    return internal::GetMatchingPaths(this, Env::Default(), pattern, results);
+  }
+
+  Status DeleteFile(const string& fname, TransactionToken* token) override {
+    return errors::Unimplemented("DeleteFile unimplemented");
+  }
+
+  Status CreateDir(const string& dirname, TransactionToken* token) override {
+    return errors::Unimplemented("CreateDir unimplemented");
+  }
+
+  Status DeleteDir(const string& dirname, TransactionToken* token) override {
+    return errors::Unimplemented("DeleteDir unimplemented");
+  }
+
+  Status GetFileSize(const string& fname, TransactionToken* token,
+                     uint64* file_size) override {
+    return errors::Unimplemented("GetFileSize unimplemented");
+  }
+
+  Status RenameFile(const string& src, const string& target,
+                    TransactionToken* token) override {
+    return errors::Unimplemented("RenameFile unimplemented");
+  }
+
+  Status Stat(const string& fname, TransactionToken* token,
+              FileStatistics* stat) override {
+    return errors::Unimplemented("Stat unimplemented");
+  }
+};
+#endif
+
+// END_SKIP_DOXYGEN
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_NULL_FILE_SYSTEM_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/numa.h

@@ -0,0 +1,62 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_NUMA_H_
+#define TENSORFLOW_TSL_PLATFORM_NUMA_H_
+
+#include "tsl/platform/platform.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace port {
+
+// Returns true iff NUMA functions are supported.
+bool NUMAEnabled();
+
+// Returns the number of NUMA nodes present with respect to CPU operations.
+// Typically this will be the number of sockets where some RAM has greater
+// affinity with one socket than another.
+int NUMANumNodes();
+
+static const int kNUMANoAffinity = -1;
+
+// If possible sets affinity of the current thread to the specified NUMA node.
+// If node == kNUMANoAffinity removes affinity to any particular node.
+void NUMASetThreadNodeAffinity(int node);
+
+// Returns NUMA node affinity of the current thread, kNUMANoAffinity if none.
+int NUMAGetThreadNodeAffinity();
+
+// Like AlignedMalloc, but allocates memory with affinity to the specified NUMA
+// node.
+//
+// Notes:
+//  1. node must be >= 0 and < NUMANumNodes.
+//  1. minimum_alignment must a factor of system page size, the memory
+//     returned will be page-aligned.
+//  2. This function is likely significantly slower than AlignedMalloc
+//     and should not be used for lots of small allocations.  It makes more
+//     sense as a backing allocator for BFCAllocator, PoolAllocator, or similar.
+void* NUMAMalloc(int node, size_t size, int minimum_alignment);
+
+// Memory allocated by NUMAMalloc must be freed via NUMAFree.
+void NUMAFree(void* ptr, size_t size);
+
+// Returns NUMA node affinity of memory address, kNUMANoAffinity if none.
+int NUMAGetMemAffinity(const void* ptr);
+
+}  // namespace port
+}  // namespace tsl
+#endif  // TENSORFLOW_TSL_PLATFORM_NUMA_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/numbers.h

@@ -0,0 +1,180 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_NUMBERS_H_
+#define TENSORFLOW_TSL_PLATFORM_NUMBERS_H_
+
+#include <cstdint>
+#include <string>
+
+#include "tsl/platform/stringpiece.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace strings {
+
+// ----------------------------------------------------------------------
+// FastIntToBufferLeft()
+//    These are intended for speed.
+//
+//    All functions take the output buffer as an arg.  FastInt() uses
+//    at most 22 bytes, FastTime() uses exactly 30 bytes.  They all
+//    return a pointer to the beginning of the output, which is the same as
+//    the beginning of the input buffer.
+//
+//    NOTE: In 64-bit land, sizeof(time_t) is 8, so it is possible
+//    to pass to FastTimeToBuffer() a time whose year cannot be
+//    represented in 4 digits. In this case, the output buffer
+//    will contain the string "Invalid:<value>"
+// ----------------------------------------------------------------------
+
+// Previously documented minimums -- the buffers provided must be at least this
+// long, though these numbers are subject to change:
+//     Int32, UInt32:                   12 bytes
+//     Int64, UInt64, Int, Uint:        22 bytes
+//     Time:                            30 bytes
+// Use kFastToBufferSize rather than hardcoding constants.
+static const int kFastToBufferSize = 32;
+
+// ----------------------------------------------------------------------
+// FastInt32ToBufferLeft()
+// FastUInt32ToBufferLeft()
+// FastInt64ToBufferLeft()
+// FastUInt64ToBufferLeft()
+//
+// These functions convert their numeric argument to an ASCII
+// representation of the numeric value in base 10, with the
+// representation being left-aligned in the buffer.  The caller is
+// responsible for ensuring that the buffer has enough space to hold
+// the output.  The buffer should typically be at least kFastToBufferSize
+// bytes.
+//
+// Returns the number of characters written.
+// ----------------------------------------------------------------------
+
+size_t FastInt32ToBufferLeft(int32_t i, char* buffer);  // at least 12 bytes
+size_t FastUInt32ToBufferLeft(uint32_t i, char* buffer);  // at least 12 bytes
+size_t FastInt64ToBufferLeft(int64_t i, char* buffer);  // at least 22 bytes
+size_t FastUInt64ToBufferLeft(uint64_t i, char* buffer);  // at least 22 bytes
+
+// Required buffer size for DoubleToBuffer is kFastToBufferSize.
+// Required buffer size for FloatToBuffer is kFastToBufferSize.
+size_t DoubleToBuffer(double value, char* buffer);
+size_t FloatToBuffer(float value, char* buffer);
+
+// Convert a 64-bit fingerprint value to an ASCII representation.
+std::string FpToString(Fprint fp);
+
+// Attempt to parse a fingerprint in the form encoded by FpToString.  If
+// successful, stores the fingerprint in *fp and returns true.  Otherwise,
+// returns false.
+bool StringToFp(const std::string& s, Fprint* fp);
+
+// Convert a 64-bit fingerprint value to an ASCII representation that
+// is terminated by a '\0'.
+// Buf must point to an array of at least kFastToBufferSize characters
+StringPiece Uint64ToHexString(uint64_t v, char* buf);
+
+// Attempt to parse a uint64 in the form encoded by FastUint64ToHexString.  If
+// successful, stores the value in *v and returns true.  Otherwise,
+// returns false.
+bool HexStringToUint64(const StringPiece& s, uint64_t* result);
+
+// Convert strings to 32bit integer values.
+// Leading and trailing spaces are allowed.
+// Return false with overflow or invalid input.
+bool safe_strto32(StringPiece str, int32_t* value);
+
+// Convert strings to unsigned 32bit integer values.
+// Leading and trailing spaces are allowed.
+// Return false with overflow or invalid input.
+bool safe_strtou32(StringPiece str, uint32_t* value);
+
+// Convert strings to 64bit integer values.
+// Leading and trailing spaces are allowed.
+// Return false with overflow or invalid input.
+bool safe_strto64(StringPiece str, int64_t* value);
+
+// Convert strings to unsigned 64bit integer values.
+// Leading and trailing spaces are allowed.
+// Return false with overflow or invalid input.
+bool safe_strtou64(StringPiece str, uint64_t* value);
+
+// Convert strings to floating point values.
+// Leading and trailing spaces are allowed.
+// Values may be rounded on over- and underflow.
+// Returns false on invalid input or if `strlen(value) >= kFastToBufferSize`.
+bool safe_strtof(StringPiece str, float* value);
+
+// Convert strings to double precision floating point values.
+// Leading and trailing spaces are allowed.
+// Values may be rounded on over- and underflow.
+// Returns false on invalid input or if `strlen(value) >= kFastToBufferSize`.
+bool safe_strtod(StringPiece str, double* value);
+
+inline bool ProtoParseNumeric(StringPiece s, int32_t* value) {
+  return safe_strto32(s, value);
+}
+
+inline bool ProtoParseNumeric(StringPiece s, uint32_t* value) {
+  return safe_strtou32(s, value);
+}
+
+inline bool ProtoParseNumeric(StringPiece s, int64_t* value) {
+  return safe_strto64(s, value);
+}
+
+inline bool ProtoParseNumeric(StringPiece s, uint64_t* value) {
+  return safe_strtou64(s, value);
+}
+
+inline bool ProtoParseNumeric(StringPiece s, float* value) {
+  return safe_strtof(s, value);
+}
+
+inline bool ProtoParseNumeric(StringPiece s, double* value) {
+  return safe_strtod(s, value);
+}
+
+// Convert strings to number of type T.
+// Leading and trailing spaces are allowed.
+// Values may be rounded on over- and underflow.
+template <typename T>
+bool SafeStringToNumeric(StringPiece s, T* value) {
+  return ProtoParseNumeric(s, value);
+}
+
+// Converts from an int64 to a human readable string representing the
+// same number, using decimal powers.  e.g. 1200000 -> "1.20M".
+std::string HumanReadableNum(int64_t value);
+
+// Converts from an int64 representing a number of bytes to a
+// human readable string representing the same number.
+// e.g. 12345678 -> "11.77MiB".
+std::string HumanReadableNumBytes(int64_t num_bytes);
+
+// Converts a time interval as double to a human readable
+// string. For example:
+//   0.001       -> "1 ms"
+//   10.0        -> "10 s"
+//   933120.0    -> "10.8 days"
+//   39420000.0  -> "1.25 years"
+//   -10         -> "-10 s"
+std::string HumanReadableElapsedTime(double seconds);
+
+}  // namespace strings
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_NUMBERS_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/path.h

@@ -0,0 +1,132 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_PATH_H_
+#define TENSORFLOW_TSL_PLATFORM_PATH_H_
+
+#include <string>
+
+#include "tsl/platform/stringpiece.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace io {
+namespace internal {
+std::string JoinPathImpl(std::initializer_list<tsl::StringPiece> paths);
+}
+
+// Utility routines for processing filenames
+
+#ifndef SWIG  // variadic templates
+// Join multiple paths together, without introducing unnecessary path
+// separators.
+// For example:
+//
+//  Arguments                  | JoinPath
+//  ---------------------------+----------
+//  '/foo', 'bar'              | /foo/bar
+//  '/foo/', 'bar'             | /foo/bar
+//  '/foo', '/bar'             | /foo/bar
+//
+// Usage:
+// string path = io::JoinPath("/mydir", filename);
+// string path = io::JoinPath(FLAGS_test_srcdir, filename);
+// string path = io::JoinPath("/full", "path", "to", "filename");
+template <typename... T>
+std::string JoinPath(const T&... args) {
+  return internal::JoinPathImpl({args...});
+}
+#endif /* SWIG */
+
+// Return true if path is absolute.
+bool IsAbsolutePath(tsl::StringPiece path);
+
+// Returns the part of the path before the final "/".  If there is a single
+// leading "/" in the path, the result will be the leading "/".  If there is
+// no "/" in the path, the result is the empty prefix of the input.
+tsl::StringPiece Dirname(tsl::StringPiece path);
+
+// Returns the part of the path after the final "/".  If there is no
+// "/" in the path, the result is the same as the input.
+tsl::StringPiece Basename(tsl::StringPiece path);
+
+// Returns the part of the basename of path after the final ".".  If
+// there is no "." in the basename, the result is empty.
+tsl::StringPiece Extension(tsl::StringPiece path);
+
+// Returns the part of the basename of path before the final ".".  If
+// there is no "." in the basename, the result is empty.
+tsl::StringPiece BasenamePrefix(tsl::StringPiece path);
+
+// Returns the largest common subpath of `paths`.
+//
+// For example, for "/alpha/beta/gamma" and "/alpha/beta/ga" returns
+// "/alpha/beta/". For "/alpha/beta/gamma" and "/alpha/beta/gamma" returns
+// "/alpha/beta/".
+//
+// Does not perform any path normalization.
+std::string CommonPathPrefix(absl::Span<std::string const> paths);
+
+// Collapse duplicate "/"s, resolve ".." and "." path elements, remove
+// trailing "/".
+//
+// NOTE: This respects relative vs. absolute paths, but does not
+// invoke any system calls (getcwd(2)) in order to resolve relative
+// paths with respect to the actual working directory.  That is, this is purely
+// string manipulation, completely independent of process state.
+std::string CleanPath(tsl::StringPiece path);
+
+// Populates the scheme, host, and path from a URI. scheme, host, and path are
+// guaranteed by this function to point into the contents of uri, even if
+// empty.
+//
+// Corner cases:
+// - If the URI is invalid, scheme and host are set to empty strings and the
+//   passed string is assumed to be a path
+// - If the URI omits the path (e.g. file://host), then the path is left empty.
+void ParseURI(tsl::StringPiece uri, tsl::StringPiece* scheme,
+              tsl::StringPiece* host, tsl::StringPiece* path);
+
+// Creates a URI from a scheme, host, and path. If the scheme is empty, we just
+// return the path.
+std::string CreateURI(tsl::StringPiece scheme, tsl::StringPiece host,
+                      tsl::StringPiece path);
+
+// Creates a temporary file name with an extension.
+std::string GetTempFilename(const std::string& extension);
+
+// Returns whether the test workspace directory is known. If it's known and dir
+// != nullptr then sets *dir to that.
+//
+// The test workspace directory is known to be TEST_SRCDIR/TEST_WORKSPACE if
+// both the TEST_SRCDIR and TEST_WORKSPACE environment variables are set.
+bool GetTestWorkspaceDir(std::string* dir);
+
+// Returns whether the TEST_UNDECLARED_OUTPUTS_DIR environment variable is set.
+// If it's set and dir != nullptr then sets *dir to that.
+bool GetTestUndeclaredOutputsDir(std::string* dir);
+
+// Resolves paths to help tests find files in their workspace or output
+// directory. Returns whether the path can be resolved. If it can be then sets
+// resolved_path to that.
+//
+// Currently the TEST_WORKSPACE and the TEST_UNDECLARED_OUTPUTS_DIR prefixes can
+// be resolved.
+bool ResolveTestPrefixes(tsl::StringPiece path, std::string& resolved_path);
+
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_PATH_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/prefetch.h

@@ -0,0 +1,45 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_PREFETCH_H_
+#define TENSORFLOW_TSL_PLATFORM_PREFETCH_H_
+
+#include "absl/base/prefetch.h"
+
+namespace tsl {
+namespace port {
+
+// Prefetching support.
+// Deprecated. Prefer to call absl::Prefetch* directly.
+
+enum PrefetchHint {
+  PREFETCH_HINT_T0 = 3,  // Temporal locality
+  PREFETCH_HINT_NTA = 0  // No temporal locality
+};
+
+template <PrefetchHint hint>
+void prefetch(const void* x) {
+  absl::PrefetchToLocalCache(x);
+}
+
+template <>
+inline void prefetch<PREFETCH_HINT_NTA>(const void* x) {
+  absl::PrefetchToLocalCacheNta(x);
+}
+
+}  // namespace port
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_PREFETCH_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/protobuf.h

@@ -0,0 +1,130 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_PROTOBUF_H_
+#define TENSORFLOW_TSL_PLATFORM_PROTOBUF_H_
+
+#include <cstdint>
+
+#include "tsl/platform/platform.h"
+#include "tsl/platform/types.h"
+
+// Import whatever namespace protobuf comes from into the
+// ::tsl::protobuf namespace.
+//
+// TensorFlow code should use the ::tensorflow::protobuf namespace to
+// refer to all protobuf APIs.
+
+#include "google/protobuf/descriptor.pb.h"         // IWYU pragma:export
+#include "google/protobuf/arena.h"                // IWYU pragma:export
+#include "google/protobuf/descriptor.h"           // IWYU pragma:export
+#include "google/protobuf/dynamic_message.h"      // IWYU pragma:export
+#include "google/protobuf/io/coded_stream.h"      // IWYU pragma:export
+#include "google/protobuf/io/tokenizer.h"         // IWYU pragma:export
+#include "google/protobuf/io/zero_copy_stream.h"  // IWYU pragma:export
+#include "google/protobuf/io/zero_copy_stream_impl_lite.h"  // IWYU pragma:export
+#include "google/protobuf/map.h"                    // IWYU pragma:export
+#include "google/protobuf/message.h"                // IWYU pragma:export
+#include "google/protobuf/repeated_field.h"         // IWYU pragma:export
+#include "google/protobuf/repeated_ptr_field.h"     // IWYU pragma:export
+#include "google/protobuf/text_format.h"            // IWYU pragma:export
+#include "google/protobuf/util/field_comparator.h"  // IWYU pragma:export
+#include "google/protobuf/util/json_util.h"         // IWYU pragma:export
+#include "google/protobuf/util/message_differencer.h"  // IWYU pragma:export
+#include "google/protobuf/util/type_resolver_util.h"  // IWYU pragma:export
+
+#if !TSL_IS_IN_OSS
+#define TENSORFLOW_PROTOBUF_USES_CORD 1
+#endif  // TSL_IS_IN_OSS
+
+namespace tsl {
+
+namespace protobuf = ::google::protobuf;
+using protobuf_int64 = int64_t;
+using protobuf_uint64 = uint64_t;
+extern const char* kProtobufInt64Typename;
+extern const char* kProtobufUint64Typename;
+
+// Parses a protocol buffer contained in a string in the binary wire format.
+// Returns true on success. Note: Unlike protobuf's builtin ParseFromString,
+// this function has no size restrictions on the total size of the encoded
+// protocol buffer.
+bool ParseProtoUnlimited(protobuf::MessageLite* proto,
+                         const std::string& serialized);
+bool ParseProtoUnlimited(protobuf::MessageLite* proto, const void* serialized,
+                         size_t size);
+inline bool ParseProtoUnlimited(protobuf::MessageLite* proto,
+                                const tstring& serialized) {
+  return ParseProtoUnlimited(proto, serialized.data(), serialized.size());
+}
+
+// Returns the string value for the value of a string or bytes protobuf field.
+inline const std::string& ProtobufStringToString(const std::string& s) {
+  return s;
+}
+
+// Set <dest> to <src>. Swapping is allowed, as <src> does not need to be
+// preserved.
+inline void SetProtobufStringSwapAllowed(std::string* src, std::string* dest) {
+  *dest = std::move(*src);
+}
+
+#if defined(TENSORFLOW_PROTOBUF_USES_CORD)
+// These versions of ProtobufStringToString and SetProtobufString get used by
+// tools/proto_text's generated code.  They have the same name as the versions
+// in tsl/platform/protobuf.h, so the generation code doesn't need to determine
+// if the type is Cord or string at generation time.
+inline std::string ProtobufStringToString(const absl::Cord& s) {
+  return std::string(s);
+}
+inline void SetProtobufStringSwapAllowed(std::string* src, absl::Cord* dest) {
+  dest->CopyFrom(*src);
+}
+#endif  // defined(TENSORFLOW_PROTOBUF_USES_CORD)
+
+inline bool SerializeToTString(const protobuf::MessageLite& proto,
+                               tstring* output) {
+  size_t size = proto.ByteSizeLong();
+  output->resize_uninitialized(size);
+  return proto.SerializeWithCachedSizesToArray(
+      reinterpret_cast<uint8*>(output->data()));
+}
+
+inline bool ParseFromTString(const tstring& input,
+                             protobuf::MessageLite* proto) {
+  return proto->ParseFromArray(input.data(), static_cast<int>(input.size()));
+}
+
+// Analogue to StringOutputStream for tstring.
+class TStringOutputStream : public protobuf::io::ZeroCopyOutputStream {
+ public:
+  explicit TStringOutputStream(tstring* target);
+  ~TStringOutputStream() override = default;
+
+  TStringOutputStream(const TStringOutputStream&) = delete;
+  void operator=(const TStringOutputStream&) = delete;
+
+  bool Next(void** data, int* size) override;
+  void BackUp(int count) override;
+  int64_t ByteCount() const override;
+
+ private:
+  static constexpr int kMinimumSize = 16;
+
+  tstring* target_;
+};
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_PROTOBUF_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/ram_file_system.h

@@ -0,0 +1,358 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_RAM_FILE_SYSTEM_H_
+#define TENSORFLOW_TSL_PLATFORM_RAM_FILE_SYSTEM_H_
+
+// Implementation of an in-memory TF filesystem for simple prototyping (e.g.
+// via Colab). The TPU TF server does not have local filesystem access, which
+// makes it difficult to provide Colab tutorials: users must have GCS access
+// and sign-in in order to try out an example.
+//
+// Files are implemented on top of std::string. Directories, as with GCS or S3,
+// are implicit based on the existence of child files. Multiple files may
+// reference a single FS location, though no thread-safety guarantees are
+// provided.
+
+#include <string>
+
+#include "absl/strings/match.h"
+#include "tsl/platform/env.h"
+#include "tsl/platform/file_system.h"
+#include "tsl/platform/mutex.h"
+#include "tsl/platform/stringpiece.h"
+#include "tsl/platform/types.h"
+
+#ifdef PLATFORM_WINDOWS
+#undef DeleteFile
+#undef CopyFile
+#undef TranslateName
+#endif
+
+namespace tsl {
+
+class RamRandomAccessFile : public RandomAccessFile, public WritableFile {
+ public:
+  RamRandomAccessFile(std::string name, std::shared_ptr<std::string> cord)
+      : name_(name), data_(cord) {}
+  ~RamRandomAccessFile() override {}
+
+  Status Name(StringPiece* result) const override {
+    *result = name_;
+    return OkStatus();
+  }
+
+  Status Read(uint64 offset, size_t n, StringPiece* result,
+              char* scratch) const override {
+    if (offset >= data_->size()) {
+      return errors::OutOfRange("");
+    }
+
+    uint64 left = std::min(static_cast<uint64>(n), data_->size() - offset);
+    auto start = data_->begin() + offset;
+    auto end = data_->begin() + offset + left;
+
+    std::copy(start, end, scratch);
+    *result = StringPiece(scratch, left);
+
+    // In case of a partial read, we must still fill `result`, but also return
+    // OutOfRange.
+    if (left < n) {
+      return errors::OutOfRange("");
+    }
+    return OkStatus();
+  }
+
+  Status Append(StringPiece data) override {
+    data_->append(data.data(), data.size());
+    return OkStatus();
+  }
+
+#if defined(TF_CORD_SUPPORT)
+  Status Append(const absl::Cord& cord) override {
+    data_->append(cord.char_begin(), cord.char_end());
+    return OkStatus();
+  }
+#endif
+
+  Status Close() override { return OkStatus(); }
+  Status Flush() override { return OkStatus(); }
+  Status Sync() override { return OkStatus(); }
+
+  Status Tell(int64_t* position) override {
+    *position = -1;
+    return errors::Unimplemented("This filesystem does not support Tell()");
+  }
+
+ private:
+  RamRandomAccessFile(const RamRandomAccessFile&) = delete;
+  void operator=(const RamRandomAccessFile&) = delete;
+  std::string name_;
+  std::shared_ptr<std::string> data_;
+};
+
+class RamFileSystem : public FileSystem {
+ public:
+  TF_USE_FILESYSTEM_METHODS_WITH_NO_TRANSACTION_SUPPORT;
+
+  Status NewRandomAccessFile(
+      const std::string& fname_, TransactionToken* token,
+      std::unique_ptr<RandomAccessFile>* result) override {
+    mutex_lock m(mu_);
+    auto fname = StripRamFsPrefix(fname_);
+
+    if (fs_.find(fname) == fs_.end()) {
+      return errors::NotFound("");
+    }
+    if (fs_[fname] == nullptr) {
+      return errors::InvalidArgument(fname_, " is a directory.");
+    }
+    *result = std::unique_ptr<RandomAccessFile>(
+        new RamRandomAccessFile(fname, fs_[fname]));
+    return OkStatus();
+  }
+
+  Status NewWritableFile(const std::string& fname_, TransactionToken* token,
+                         std::unique_ptr<WritableFile>* result) override {
+    mutex_lock m(mu_);
+    auto fname = StripRamFsPrefix(fname_);
+
+    if (fs_.find(fname) == fs_.end()) {
+      fs_[fname] = std::make_shared<std::string>();
+    }
+    if (fs_[fname] == nullptr) {
+      return errors::InvalidArgument(fname_, " is a directory.");
+    }
+    *result = std::unique_ptr<WritableFile>(
+        new RamRandomAccessFile(fname, fs_[fname]));
+    return OkStatus();
+  }
+
+  Status NewAppendableFile(const std::string& fname_, TransactionToken* token,
+                           std::unique_ptr<WritableFile>* result) override {
+    mutex_lock m(mu_);
+    auto fname = StripRamFsPrefix(fname_);
+
+    if (fs_.find(fname) == fs_.end()) {
+      fs_[fname] = std::make_shared<std::string>();
+    }
+    if (fs_[fname] == nullptr) {
+      return errors::InvalidArgument(fname_, " is a directory.");
+    }
+    *result = std::unique_ptr<WritableFile>(
+        new RamRandomAccessFile(fname, fs_[fname]));
+    return OkStatus();
+  }
+
+  Status NewReadOnlyMemoryRegionFromFile(
+      const std::string& fname, TransactionToken* token,
+      std::unique_ptr<ReadOnlyMemoryRegion>* result) override {
+    return errors::Unimplemented("");
+  }
+
+  Status FileExists(const std::string& fname_,
+                    TransactionToken* token) override {
+    FileStatistics stat;
+    auto fname = StripRamFsPrefix(fname_);
+
+    return Stat(fname, token, &stat);
+  }
+
+  Status GetChildren(const std::string& dir_, TransactionToken* token,
+                     std::vector<std::string>* result) override {
+    mutex_lock m(mu_);
+    auto dir = StripRamFsPrefix(dir_);
+
+    auto it = fs_.lower_bound(dir);
+    while (it != fs_.end() && StartsWith(it->first, dir)) {
+      auto filename = StripPrefix(StripPrefix(it->first, dir), "/");
+      // It is not either (a) the parent directory itself or (b) a subdirectory
+      if (!filename.empty() && filename.find("/") == std::string::npos) {
+        result->push_back(filename);
+      }
+      ++it;
+    }
+
+    return OkStatus();
+  }
+
+  Status GetMatchingPaths(const std::string& pattern_, TransactionToken* token,
+                          std::vector<std::string>* results) override {
+    mutex_lock m(mu_);
+    auto pattern = StripRamFsPrefix(pattern_);
+
+    Env* env = Env::Default();
+    for (auto it = fs_.begin(); it != fs_.end(); ++it) {
+      if (env->MatchPath(it->first, pattern)) {
+        results->push_back("ram://" + it->first);
+      }
+    }
+    return OkStatus();
+  }
+
+  Status Stat(const std::string& fname_, TransactionToken* token,
+              FileStatistics* stat) override {
+    mutex_lock m(mu_);
+    auto fname = StripRamFsPrefix(fname_);
+
+    auto it = fs_.lower_bound(fname);
+    if (it == fs_.end() || !StartsWith(it->first, fname)) {
+      return errors::NotFound("");
+    }
+
+    if (it->first == fname && it->second != nullptr) {
+      stat->is_directory = false;
+      stat->length = fs_[fname]->size();
+      stat->mtime_nsec = 0;
+      return OkStatus();
+    }
+
+    stat->is_directory = true;
+    stat->length = 0;
+    stat->mtime_nsec = 0;
+    return OkStatus();
+  }
+
+  Status DeleteFile(const std::string& fname_,
+                    TransactionToken* token) override {
+    mutex_lock m(mu_);
+    auto fname = StripRamFsPrefix(fname_);
+
+    if (fs_.find(fname) != fs_.end()) {
+      fs_.erase(fname);
+      return OkStatus();
+    }
+
+    return errors::NotFound("");
+  }
+
+  Status CreateDir(const std::string& dirname_,
+                   TransactionToken* token) override {
+    mutex_lock m(mu_);
+    auto dirname = StripRamFsPrefix(dirname_);
+
+    auto it = fs_.find(dirname);
+    if (it != fs_.end() && it->second != nullptr) {
+      return errors::AlreadyExists(
+          "cannot create directory with same name as an existing file");
+    }
+
+    fs_[dirname] = nullptr;
+    return OkStatus();
+  }
+
+  Status RecursivelyCreateDir(const std::string& dirname_,
+                              TransactionToken* token) override {
+    auto dirname = StripRamFsPrefix(dirname_);
+
+    std::vector<std::string> dirs = StrSplit(dirname, "/");
+    Status last_status;
+    std::string dir = dirs[0];
+    last_status = CreateDir(dir, token);
+
+    for (int i = 1; i < dirs.size(); ++i) {
+      dir = dir + "/" + dirs[i];
+      last_status = CreateDir(dir, token);
+    }
+    return last_status;
+  }
+
+  Status DeleteDir(const std::string& dirname_,
+                   TransactionToken* token) override {
+    mutex_lock m(mu_);
+    auto dirname = StripRamFsPrefix(dirname_);
+
+    auto it = fs_.find(dirname);
+    if (it == fs_.end()) {
+      return errors::NotFound("");
+    }
+    if (it->second != nullptr) {
+      return errors::InvalidArgument("Not a directory");
+    }
+    fs_.erase(dirname);
+
+    return OkStatus();
+  }
+
+  Status GetFileSize(const std::string& fname_, TransactionToken* token,
+                     uint64* file_size) override {
+    mutex_lock m(mu_);
+    auto fname = StripRamFsPrefix(fname_);
+
+    if (fs_.find(fname) != fs_.end()) {
+      if (fs_[fname] == nullptr) {
+        return errors::InvalidArgument("Not a file");
+      }
+      *file_size = fs_[fname]->size();
+      return OkStatus();
+    }
+    return errors::NotFound("");
+  }
+
+  Status RenameFile(const std::string& src_, const std::string& target_,
+                    TransactionToken* token) override {
+    mutex_lock m(mu_);
+    auto src = StripRamFsPrefix(src_);
+    auto target = StripRamFsPrefix(target_);
+
+    if (fs_.find(src) != fs_.end()) {
+      fs_[target] = fs_[src];
+      fs_.erase(fs_.find(src));
+      return OkStatus();
+    }
+    return errors::NotFound("");
+  }
+
+  RamFileSystem() {}
+  ~RamFileSystem() override {}
+
+ private:
+  mutex mu_;
+  std::map<std::string, std::shared_ptr<std::string>> fs_;
+
+  std::vector<std::string> StrSplit(std::string s, std::string delim) {
+    std::vector<std::string> ret;
+    size_t curr_pos = 0;
+    while ((curr_pos = s.find(delim)) != std::string::npos) {
+      ret.push_back(s.substr(0, curr_pos));
+      s.erase(0, curr_pos + delim.size());
+    }
+    ret.push_back(s);
+    return ret;
+  }
+
+  bool StartsWith(std::string s, std::string prefix) {
+    return absl::StartsWith(s, prefix);
+  }
+
+  string StripPrefix(std::string s, std::string prefix) {
+    if (absl::StartsWith(s, prefix)) {
+      return s.erase(0, prefix.size());
+    }
+    return s;
+  }
+
+  string StripRamFsPrefix(std::string name) {
+    std::string s = StripPrefix(name, "ram://");
+    if (*(s.rbegin()) == '/') {
+      s.pop_back();
+    }
+    return s;
+  }
+};
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_RAM_FILE_SYSTEM_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/platform/random.h

@@ -0,0 +1,38 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_PLATFORM_RANDOM_H_
+#define TENSORFLOW_TSL_PLATFORM_RANDOM_H_
+
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace random {
+
+// Return a 64-bit random value.  Different sequences are generated
+// in different processes.
+uint64 New64();
+
+// Same as previous method, but uses a different RNG for each thread.
+uint64 ThreadLocalNew64();
+
+// Return a 64-bit random value. Uses
+// std::mersenne_twister_engine::default_seed as seed value.
+uint64 New64DefaultSeed();
+
+}  // namespace random
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_PLATFORM_RANDOM_H_