@uns-kit/cli 0.0.51 → 0.0.53

package/templates/python/venv/lib/python3.12/site-packages/grpc/framework/foundation/future.py

@@ -1,219 +0,0 @@
-# Copyright 2015 gRPC authors.
-#
-# 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.
-"""A Future interface.
-
-Python doesn't have a Future interface in its standard library. In the absence
-of such a standard, three separate, incompatible implementations
-(concurrent.futures.Future, ndb.Future, and asyncio.Future) have appeared. This
-interface attempts to be as compatible as possible with
-concurrent.futures.Future. From ndb.Future it adopts a traceback-object accessor
-method.
-
-Unlike the concrete and implemented Future classes listed above, the Future
-class defined in this module is an entirely abstract interface that anyone may
-implement and use.
-
-The one known incompatibility between this interface and the interface of
-concurrent.futures.Future is that this interface defines its own CancelledError
-and TimeoutError exceptions rather than raising the implementation-private
-concurrent.futures._base.CancelledError and the
-built-in-but-only-in-3.3-and-later TimeoutError.
-"""
-
-import abc
-
-
-class TimeoutError(Exception):
-    """Indicates that a particular call timed out."""
-
-
-class CancelledError(Exception):
-    """Indicates that the computation underlying a Future was cancelled."""
-
-
-class Future(abc.ABC):
-    """A representation of a computation in another control flow.
-
-    Computations represented by a Future may be yet to be begun, may be ongoing,
-    or may have already completed.
-    """
-
-    # NOTE(nathaniel): This isn't the return type that I would want to have if it
-    # were up to me. Were this interface being written from scratch, the return
-    # type of this method would probably be a sum type like:
-    #
-    # NOT_COMMENCED
-    # COMMENCED_AND_NOT_COMPLETED
-    # PARTIAL_RESULT<Partial_Result_Type>
-    # COMPLETED<Result_Type>
-    # UNCANCELLABLE
-    # NOT_IMMEDIATELY_DETERMINABLE
-    @abc.abstractmethod
-    def cancel(self):
-        """Attempts to cancel the computation.
-
-        This method does not block.
-
-        Returns:
-          True if the computation has not yet begun, will not be allowed to take
-            place, and determination of both was possible without blocking. False
-            under all other circumstances including but not limited to the
-            computation's already having begun, the computation's already having
-            finished, and the computation's having been scheduled for execution on a
-            remote system for which a determination of whether or not it commenced
-            before being cancelled cannot be made without blocking.
-        """
-        raise NotImplementedError()
-
-    # NOTE(nathaniel): Here too this isn't the return type that I'd want this
-    # method to have if it were up to me. I think I'd go with another sum type
-    # like:
-    #
-    # NOT_CANCELLED (this object's cancel method hasn't been called)
-    # NOT_COMMENCED
-    # COMMENCED_AND_NOT_COMPLETED
-    # PARTIAL_RESULT<Partial_Result_Type>
-    # COMPLETED<Result_Type>
-    # UNCANCELLABLE
-    # NOT_IMMEDIATELY_DETERMINABLE
-    #
-    # Notice how giving the cancel method the right semantics obviates most
-    # reasons for this method to exist.
-    @abc.abstractmethod
-    def cancelled(self):
-        """Describes whether the computation was cancelled.
-
-        This method does not block.
-
-        Returns:
-          True if the computation was cancelled any time before its result became
-            immediately available. False under all other circumstances including but
-            not limited to this object's cancel method not having been called and
-            the computation's result having become immediately available.
-        """
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def running(self):
-        """Describes whether the computation is taking place.
-
-        This method does not block.
-
-        Returns:
-          True if the computation is scheduled to take place in the future or is
-            taking place now, or False if the computation took place in the past or
-            was cancelled.
-        """
-        raise NotImplementedError()
-
-    # NOTE(nathaniel): These aren't quite the semantics I'd like here either. I
-    # would rather this only returned True in cases in which the underlying
-    # computation completed successfully. A computation's having been cancelled
-    # conflicts with considering that computation "done".
-    @abc.abstractmethod
-    def done(self):
-        """Describes whether the computation has taken place.
-
-        This method does not block.
-
-        Returns:
-          True if the computation is known to have either completed or have been
-            unscheduled or interrupted. False if the computation may possibly be
-            executing or scheduled to execute later.
-        """
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def result(self, timeout=None):
-        """Accesses the outcome of the computation or raises its exception.
-
-        This method may return immediately or may block.
-
-        Args:
-          timeout: The length of time in seconds to wait for the computation to
-            finish or be cancelled, or None if this method should block until the
-            computation has finished or is cancelled no matter how long that takes.
-
-        Returns:
-          The return value of the computation.
-
-        Raises:
-          TimeoutError: If a timeout value is passed and the computation does not
-            terminate within the allotted time.
-          CancelledError: If the computation was cancelled.
-          Exception: If the computation raised an exception, this call will raise
-            the same exception.
-        """
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def exception(self, timeout=None):
-        """Return the exception raised by the computation.
-
-        This method may return immediately or may block.
-
-        Args:
-          timeout: The length of time in seconds to wait for the computation to
-            terminate or be cancelled, or None if this method should block until
-            the computation is terminated or is cancelled no matter how long that
-            takes.
-
-        Returns:
-          The exception raised by the computation, or None if the computation did
-            not raise an exception.
-
-        Raises:
-          TimeoutError: If a timeout value is passed and the computation does not
-            terminate within the allotted time.
-          CancelledError: If the computation was cancelled.
-        """
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def traceback(self, timeout=None):
-        """Access the traceback of the exception raised by the computation.
-
-        This method may return immediately or may block.
-
-        Args:
-          timeout: The length of time in seconds to wait for the computation to
-            terminate or be cancelled, or None if this method should block until
-            the computation is terminated or is cancelled no matter how long that
-            takes.
-
-        Returns:
-          The traceback of the exception raised by the computation, or None if the
-            computation did not raise an exception.
-
-        Raises:
-          TimeoutError: If a timeout value is passed and the computation does not
-            terminate within the allotted time.
-          CancelledError: If the computation was cancelled.
-        """
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def add_done_callback(self, fn):
-        """Adds a function to be called at completion of the computation.
-
-        The callback will be passed this Future object describing the outcome of
-        the computation.
-
-        If the computation has already completed, the callback will be called
-        immediately.
-
-        Args:
-          fn: A callable taking this Future object as its single parameter.
-        """
-        raise NotImplementedError()

package/templates/python/venv/lib/python3.12/site-packages/grpc/framework/foundation/logging_pool.py

@@ -1,72 +0,0 @@
-# Copyright 2015 gRPC authors.
-#
-# 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.
-"""A thread pool that logs exceptions raised by tasks executed within it."""
-
-from concurrent import futures
-import logging
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def _wrap(behavior):
-    """Wraps an arbitrary callable behavior in exception-logging."""
-
-    def _wrapping(*args, **kwargs):
-        try:
-            return behavior(*args, **kwargs)
-        except Exception:
-            _LOGGER.exception(
-                "Unexpected exception from %s executed in logging pool!",
-                behavior,
-            )
-            raise
-
-    return _wrapping
-
-
-class _LoggingPool(object):
-    """An exception-logging futures.ThreadPoolExecutor-compatible thread pool."""
-
-    def __init__(self, backing_pool):
-        self._backing_pool = backing_pool
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._backing_pool.shutdown(wait=True)
-
-    def submit(self, fn, *args, **kwargs):
-        return self._backing_pool.submit(_wrap(fn), *args, **kwargs)
-
-    def map(self, func, *iterables, **kwargs):
-        return self._backing_pool.map(
-            _wrap(func), *iterables, timeout=kwargs.get("timeout", None)
-        )
-
-    def shutdown(self, wait=True):
-        self._backing_pool.shutdown(wait=wait)
-
-
-def pool(max_workers):
-    """Creates a thread pool that logs exceptions raised by the tasks within it.
-
-    Args:
-      max_workers: The maximum number of worker threads to allow the pool.
-
-    Returns:
-      A futures.ThreadPoolExecutor-compatible thread pool that logs exceptions
-        raised by the tasks executed within it.
-    """
-    return _LoggingPool(futures.ThreadPoolExecutor(max_workers))

package/templates/python/venv/lib/python3.12/site-packages/grpc/framework/foundation/stream.py

@@ -1,43 +0,0 @@
-# Copyright 2015 gRPC authors.
-#
-# 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.
-"""Interfaces related to streams of values or objects."""
-
-import abc
-
-
-class Consumer(abc.ABC):
-    """Interface for consumers of finite streams of values or objects."""
-
-    @abc.abstractmethod
-    def consume(self, value):
-        """Accepts a value.
-
-        Args:
-          value: Any value accepted by this Consumer.
-        """
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def terminate(self):
-        """Indicates to this Consumer that no more values will be supplied."""
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def consume_and_terminate(self, value):
-        """Supplies a value and signals that no more values will be supplied.
-
-        Args:
-          value: Any value accepted by this Consumer.
-        """
-        raise NotImplementedError()

package/templates/python/venv/lib/python3.12/site-packages/grpc/framework/foundation/stream_util.py

@@ -1,148 +0,0 @@
-# Copyright 2015 gRPC authors.
-#
-# 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.
-"""Helpful utilities related to the stream module."""
-
-import logging
-import threading
-
-from grpc.framework.foundation import stream
-
-_NO_VALUE = object()
-_LOGGER = logging.getLogger(__name__)
-
-
-class TransformingConsumer(stream.Consumer):
-    """A stream.Consumer that passes a transformation of its input to another."""
-
-    def __init__(self, transformation, downstream):
-        self._transformation = transformation
-        self._downstream = downstream
-
-    def consume(self, value):
-        self._downstream.consume(self._transformation(value))
-
-    def terminate(self):
-        self._downstream.terminate()
-
-    def consume_and_terminate(self, value):
-        self._downstream.consume_and_terminate(self._transformation(value))
-
-
-class IterableConsumer(stream.Consumer):
-    """A Consumer that when iterated over emits the values it has consumed."""
-
-    def __init__(self):
-        self._condition = threading.Condition()
-        self._values = []
-        self._active = True
-
-    def consume(self, value):
-        with self._condition:
-            if self._active:
-                self._values.append(value)
-                self._condition.notify()
-
-    def terminate(self):
-        with self._condition:
-            self._active = False
-            self._condition.notify()
-
-    def consume_and_terminate(self, value):
-        with self._condition:
-            if self._active:
-                self._values.append(value)
-                self._active = False
-                self._condition.notify()
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        return self.next()
-
-    def next(self):
-        with self._condition:
-            while self._active and not self._values:
-                self._condition.wait()
-            if self._values:
-                return self._values.pop(0)
-            else:
-                raise StopIteration()
-
-
-class ThreadSwitchingConsumer(stream.Consumer):
-    """A Consumer decorator that affords serialization and asynchrony."""
-
-    def __init__(self, sink, pool):
-        self._lock = threading.Lock()
-        self._sink = sink
-        self._pool = pool
-        # True if self._spin has been submitted to the pool to be called once and
-        # that call has not yet returned, False otherwise.
-        self._spinning = False
-        self._values = []
-        self._active = True
-
-    def _spin(self, sink, value, terminate):
-        while True:
-            try:
-                if value is _NO_VALUE:
-                    sink.terminate()
-                elif terminate:
-                    sink.consume_and_terminate(value)
-                else:
-                    sink.consume(value)
-            except Exception as e:  # pylint:disable=broad-except
-                _LOGGER.exception(e)
-
-            with self._lock:
-                if terminate:
-                    self._spinning = False
-                    return
-                elif self._values:
-                    value = self._values.pop(0)
-                    terminate = not self._values and not self._active
-                elif not self._active:
-                    value = _NO_VALUE
-                    terminate = True
-                else:
-                    self._spinning = False
-                    return
-
-    def consume(self, value):
-        with self._lock:
-            if self._active:
-                if self._spinning:
-                    self._values.append(value)
-                else:
-                    self._pool.submit(self._spin, self._sink, value, False)
-                    self._spinning = True
-
-    def terminate(self):
-        with self._lock:
-            if self._active:
-                self._active = False
-                if not self._spinning:
-                    self._pool.submit(self._spin, self._sink, _NO_VALUE, True)
-                    self._spinning = True
-
-    def consume_and_terminate(self, value):
-        with self._lock:
-            if self._active:
-                self._active = False
-                if self._spinning:
-                    self._values.append(value)
-                else:
-                    self._pool.submit(self._spin, self._sink, value, True)
-                    self._spinning = True

package/templates/python/venv/lib/python3.12/site-packages/grpc/framework/interfaces/__init__.py

@@ -1,13 +0,0 @@
-# Copyright 2015 gRPC authors.
-#
-# 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.

package/templates/python/venv/lib/python3.12/site-packages/grpc/framework/interfaces/base/__init__.py

@@ -1,13 +0,0 @@
-# Copyright 2015 gRPC authors.
-#
-# 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.