@scrypted/server 0.0.141 → 0.0.142

package/.venv/lib/python3.9/site-packages/pip/_vendor/tenacity/wait.py

@@ -1,191 +0,0 @@
-# Copyright 2016–2021 Julien Danjou
-# Copyright 2016 Joshua Harlow
-# Copyright 2013-2014 Ray Holder
-#
-# 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.
-
-import abc
-import random
-import typing
-
-from pip._vendor.tenacity import _utils
-
-if typing.TYPE_CHECKING:
-    from pip._vendor.tenacity import RetryCallState
-
-
-class wait_base(abc.ABC):
-    """Abstract base class for wait strategies."""
-
-    @abc.abstractmethod
-    def __call__(self, retry_state: "RetryCallState") -> float:
-        pass
-
-    def __add__(self, other: "wait_base") -> "wait_combine":
-        return wait_combine(self, other)
-
-    def __radd__(self, other: "wait_base") -> typing.Union["wait_combine", "wait_base"]:
-        # make it possible to use multiple waits with the built-in sum function
-        if other == 0:
-            return self
-        return self.__add__(other)
-
-
-class wait_fixed(wait_base):
-    """Wait strategy that waits a fixed amount of time between each retry."""
-
-    def __init__(self, wait: float) -> None:
-        self.wait_fixed = wait
-
-    def __call__(self, retry_state: "RetryCallState") -> float:
-        return self.wait_fixed
-
-
-class wait_none(wait_fixed):
-    """Wait strategy that doesn't wait at all before retrying."""
-
-    def __init__(self) -> None:
-        super().__init__(0)
-
-
-class wait_random(wait_base):
-    """Wait strategy that waits a random amount of time between min/max."""
-
-    def __init__(self, min: typing.Union[int, float] = 0, max: typing.Union[int, float] = 1) -> None:  # noqa
-        self.wait_random_min = min
-        self.wait_random_max = max
-
-    def __call__(self, retry_state: "RetryCallState") -> float:
-        return self.wait_random_min + (random.random() * (self.wait_random_max - self.wait_random_min))
-
-
-class wait_combine(wait_base):
-    """Combine several waiting strategies."""
-
-    def __init__(self, *strategies: wait_base) -> None:
-        self.wait_funcs = strategies
-
-    def __call__(self, retry_state: "RetryCallState") -> float:
-        return sum(x(retry_state=retry_state) for x in self.wait_funcs)
-
-
-class wait_chain(wait_base):
-    """Chain two or more waiting strategies.
-
-    If all strategies are exhausted, the very last strategy is used
-    thereafter.
-
-    For example::
-
-        @retry(wait=wait_chain(*[wait_fixed(1) for i in range(3)] +
-                               [wait_fixed(2) for j in range(5)] +
-                               [wait_fixed(5) for k in range(4)))
-        def wait_chained():
-            print("Wait 1s for 3 attempts, 2s for 5 attempts and 5s
-                   thereafter.")
-    """
-
-    def __init__(self, *strategies: wait_base) -> None:
-        self.strategies = strategies
-
-    def __call__(self, retry_state: "RetryCallState") -> float:
-        wait_func_no = min(max(retry_state.attempt_number, 1), len(self.strategies))
-        wait_func = self.strategies[wait_func_no - 1]
-        return wait_func(retry_state=retry_state)
-
-
-class wait_incrementing(wait_base):
-    """Wait an incremental amount of time after each attempt.
-
-    Starting at a starting value and incrementing by a value for each attempt
-    (and restricting the upper limit to some maximum value).
-    """
-
-    def __init__(
-        self,
-        start: typing.Union[int, float] = 0,
-        increment: typing.Union[int, float] = 100,
-        max: typing.Union[int, float] = _utils.MAX_WAIT,  # noqa
-    ) -> None:
-        self.start = start
-        self.increment = increment
-        self.max = max
-
-    def __call__(self, retry_state: "RetryCallState") -> float:
-        result = self.start + (self.increment * (retry_state.attempt_number - 1))
-        return max(0, min(result, self.max))
-
-
-class wait_exponential(wait_base):
-    """Wait strategy that applies exponential backoff.
-
-    It allows for a customized multiplier and an ability to restrict the
-    upper and lower limits to some maximum and minimum value.
-
-    The intervals are fixed (i.e. there is no jitter), so this strategy is
-    suitable for balancing retries against latency when a required resource is
-    unavailable for an unknown duration, but *not* suitable for resolving
-    contention between multiple processes for a shared resource. Use
-    wait_random_exponential for the latter case.
-    """
-
-    def __init__(
-        self,
-        multiplier: typing.Union[int, float] = 1,
-        max: typing.Union[int, float] = _utils.MAX_WAIT,  # noqa
-        exp_base: typing.Union[int, float] = 2,
-        min: typing.Union[int, float] = 0,  # noqa
-    ) -> None:
-        self.multiplier = multiplier
-        self.min = min
-        self.max = max
-        self.exp_base = exp_base
-
-    def __call__(self, retry_state: "RetryCallState") -> float:
-        try:
-            exp = self.exp_base ** (retry_state.attempt_number - 1)
-            result = self.multiplier * exp
-        except OverflowError:
-            return self.max
-        return max(max(0, self.min), min(result, self.max))
-
-
-class wait_random_exponential(wait_exponential):
-    """Random wait with exponentially widening window.
-
-    An exponential backoff strategy used to mediate contention between multiple
-    uncoordinated processes for a shared resource in distributed systems. This
-    is the sense in which "exponential backoff" is meant in e.g. Ethernet
-    networking, and corresponds to the "Full Jitter" algorithm described in
-    this blog post:
-
-    https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
-
-    Each retry occurs at a random time in a geometrically expanding interval.
-    It allows for a custom multiplier and an ability to restrict the upper
-    limit of the random interval to some maximum value.
-
-    Example::
-
-        wait_random_exponential(multiplier=0.5,  # initial window 0.5s
-                                max=60)          # max 60s timeout
-
-    When waiting for an unavailable resource to become available again, as
-    opposed to trying to resolve contention for a shared resource, the
-    wait_exponential strategy (which uses a fixed interval) may be preferable.
-
-    """
-
-    def __call__(self, retry_state: "RetryCallState") -> float:
-        high = super().__call__(retry_state=retry_state)
-        return random.uniform(0, high)

package/.venv/lib/python3.9/site-packages/pip/_vendor/tomli/__init__.py

@@ -1,6 +0,0 @@
-"""A lil' TOML parser."""
-
-__all__ = ("loads", "load", "TOMLDecodeError")
-__version__ = "1.0.3"  # DO NOT EDIT THIS LINE MANUALLY. LET bump2version UTILITY DO IT
-
-from pip._vendor.tomli._parser import TOMLDecodeError, load, loads