@scrypted/server 0.0.139 → 0.0.143

package/.venv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/filewrapper.py

@@ -1,80 +0,0 @@
-from io import BytesIO
-
-
-class CallbackFileWrapper(object):
-    """
-    Small wrapper around a fp object which will tee everything read into a
-    buffer, and when that file is closed it will execute a callback with the
-    contents of that buffer.
-
-    All attributes are proxied to the underlying file object.
-
-    This class uses members with a double underscore (__) leading prefix so as
-    not to accidentally shadow an attribute.
-    """
-
-    def __init__(self, fp, callback):
-        self.__buf = BytesIO()
-        self.__fp = fp
-        self.__callback = callback
-
-    def __getattr__(self, name):
-        # The vaguaries of garbage collection means that self.__fp is
-        # not always set.  By using __getattribute__ and the private
-        # name[0] allows looking up the attribute value and raising an
-        # AttributeError when it doesn't exist. This stop thigns from
-        # infinitely recursing calls to getattr in the case where
-        # self.__fp hasn't been set.
-        #
-        # [0] https://docs.python.org/2/reference/expressions.html#atom-identifiers
-        fp = self.__getattribute__("_CallbackFileWrapper__fp")
-        return getattr(fp, name)
-
-    def __is_fp_closed(self):
-        try:
-            return self.__fp.fp is None
-
-        except AttributeError:
-            pass
-
-        try:
-            return self.__fp.closed
-
-        except AttributeError:
-            pass
-
-        # We just don't cache it then.
-        # TODO: Add some logging here...
-        return False
-
-    def _close(self):
-        if self.__callback:
-            self.__callback(self.__buf.getvalue())
-
-        # We assign this to None here, because otherwise we can get into
-        # really tricky problems where the CPython interpreter dead locks
-        # because the callback is holding a reference to something which
-        # has a __del__ method. Setting this to None breaks the cycle
-        # and allows the garbage collector to do it's thing normally.
-        self.__callback = None
-
-    def read(self, amt=None):
-        data = self.__fp.read(amt)
-        self.__buf.write(data)
-        if self.__is_fp_closed():
-            self._close()
-
-        return data
-
-    def _safe_read(self, amt):
-        data = self.__fp._safe_read(amt)
-        if amt == 2 and data == b"\r\n":
-            # urllib executes this read to toss the CRLF at the end
-            # of the chunk.
-            return data
-
-        self.__buf.write(data)
-        if self.__is_fp_closed():
-            self._close()
-
-        return data

package/.venv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/heuristics.py

@@ -1,135 +0,0 @@
-import calendar
-import time
-
-from email.utils import formatdate, parsedate, parsedate_tz
-
-from datetime import datetime, timedelta
-
-TIME_FMT = "%a, %d %b %Y %H:%M:%S GMT"
-
-
-def expire_after(delta, date=None):
-    date = date or datetime.utcnow()
-    return date + delta
-
-
-def datetime_to_header(dt):
-    return formatdate(calendar.timegm(dt.timetuple()))
-
-
-class BaseHeuristic(object):
-
-    def warning(self, response):
-        """
-        Return a valid 1xx warning header value describing the cache
-        adjustments.
-
-        The response is provided too allow warnings like 113
-        http://tools.ietf.org/html/rfc7234#section-5.5.4 where we need
-        to explicitly say response is over 24 hours old.
-        """
-        return '110 - "Response is Stale"'
-
-    def update_headers(self, response):
-        """Update the response headers with any new headers.
-
-        NOTE: This SHOULD always include some Warning header to
-              signify that the response was cached by the client, not
-              by way of the provided headers.
-        """
-        return {}
-
-    def apply(self, response):
-        updated_headers = self.update_headers(response)
-
-        if updated_headers:
-            response.headers.update(updated_headers)
-            warning_header_value = self.warning(response)
-            if warning_header_value is not None:
-                response.headers.update({"Warning": warning_header_value})
-
-        return response
-
-
-class OneDayCache(BaseHeuristic):
-    """
-    Cache the response by providing an expires 1 day in the
-    future.
-    """
-
-    def update_headers(self, response):
-        headers = {}
-
-        if "expires" not in response.headers:
-            date = parsedate(response.headers["date"])
-            expires = expire_after(timedelta(days=1), date=datetime(*date[:6]))
-            headers["expires"] = datetime_to_header(expires)
-            headers["cache-control"] = "public"
-        return headers
-
-
-class ExpiresAfter(BaseHeuristic):
-    """
-    Cache **all** requests for a defined time period.
-    """
-
-    def __init__(self, **kw):
-        self.delta = timedelta(**kw)
-
-    def update_headers(self, response):
-        expires = expire_after(self.delta)
-        return {"expires": datetime_to_header(expires), "cache-control": "public"}
-
-    def warning(self, response):
-        tmpl = "110 - Automatically cached for %s. Response might be stale"
-        return tmpl % self.delta
-
-
-class LastModified(BaseHeuristic):
-    """
-    If there is no Expires header already, fall back on Last-Modified
-    using the heuristic from
-    http://tools.ietf.org/html/rfc7234#section-4.2.2
-    to calculate a reasonable value.
-
-    Firefox also does something like this per
-    https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching_FAQ
-    http://lxr.mozilla.org/mozilla-release/source/netwerk/protocol/http/nsHttpResponseHead.cpp#397
-    Unlike mozilla we limit this to 24-hr.
-    """
-    cacheable_by_default_statuses = {
-        200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501
-    }
-
-    def update_headers(self, resp):
-        headers = resp.headers
-
-        if "expires" in headers:
-            return {}
-
-        if "cache-control" in headers and headers["cache-control"] != "public":
-            return {}
-
-        if resp.status not in self.cacheable_by_default_statuses:
-            return {}
-
-        if "date" not in headers or "last-modified" not in headers:
-            return {}
-
-        date = calendar.timegm(parsedate_tz(headers["date"]))
-        last_modified = parsedate(headers["last-modified"])
-        if date is None or last_modified is None:
-            return {}
-
-        now = time.time()
-        current_age = max(0, now - date)
-        delta = date - calendar.timegm(last_modified)
-        freshness_lifetime = max(0, min(delta / 10, 24 * 3600))
-        if freshness_lifetime <= current_age:
-            return {}
-
-        expires = date + freshness_lifetime
-        return {"expires": time.strftime(TIME_FMT, time.gmtime(expires))}
-
-    def warning(self, resp):
-        return None

package/.venv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/serialize.py

@@ -1,188 +0,0 @@
-import base64
-import io
-import json
-import zlib
-
-from pip._vendor import msgpack
-from pip._vendor.requests.structures import CaseInsensitiveDict
-
-from .compat import HTTPResponse, pickle, text_type
-
-
-def _b64_decode_bytes(b):
-    return base64.b64decode(b.encode("ascii"))
-
-
-def _b64_decode_str(s):
-    return _b64_decode_bytes(s).decode("utf8")
-
-
-class Serializer(object):
-
-    def dumps(self, request, response, body=None):
-        response_headers = CaseInsensitiveDict(response.headers)
-
-        if body is None:
-            body = response.read(decode_content=False)
-
-            # NOTE: 99% sure this is dead code. I'm only leaving it
-            #       here b/c I don't have a test yet to prove
-            #       it. Basically, before using
-            #       `cachecontrol.filewrapper.CallbackFileWrapper`,
-            #       this made an effort to reset the file handle. The
-            #       `CallbackFileWrapper` short circuits this code by
-            #       setting the body as the content is consumed, the
-            #       result being a `body` argument is *always* passed
-            #       into cache_response, and in turn,
-            #       `Serializer.dump`.
-            response._fp = io.BytesIO(body)
-
-        # NOTE: This is all a bit weird, but it's really important that on
-        #       Python 2.x these objects are unicode and not str, even when
-        #       they contain only ascii. The problem here is that msgpack
-        #       understands the difference between unicode and bytes and we
-        #       have it set to differentiate between them, however Python 2
-        #       doesn't know the difference. Forcing these to unicode will be
-        #       enough to have msgpack know the difference.
-        data = {
-            u"response": {
-                u"body": body,
-                u"headers": dict(
-                    (text_type(k), text_type(v)) for k, v in response.headers.items()
-                ),
-                u"status": response.status,
-                u"version": response.version,
-                u"reason": text_type(response.reason),
-                u"strict": response.strict,
-                u"decode_content": response.decode_content,
-            }
-        }
-
-        # Construct our vary headers
-        data[u"vary"] = {}
-        if u"vary" in response_headers:
-            varied_headers = response_headers[u"vary"].split(",")
-            for header in varied_headers:
-                header = text_type(header).strip()
-                header_value = request.headers.get(header, None)
-                if header_value is not None:
-                    header_value = text_type(header_value)
-                data[u"vary"][header] = header_value
-
-        return b",".join([b"cc=4", msgpack.dumps(data, use_bin_type=True)])
-
-    def loads(self, request, data):
-        # Short circuit if we've been given an empty set of data
-        if not data:
-            return
-
-        # Determine what version of the serializer the data was serialized
-        # with
-        try:
-            ver, data = data.split(b",", 1)
-        except ValueError:
-            ver = b"cc=0"
-
-        # Make sure that our "ver" is actually a version and isn't a false
-        # positive from a , being in the data stream.
-        if ver[:3] != b"cc=":
-            data = ver + data
-            ver = b"cc=0"
-
-        # Get the version number out of the cc=N
-        ver = ver.split(b"=", 1)[-1].decode("ascii")
-
-        # Dispatch to the actual load method for the given version
-        try:
-            return getattr(self, "_loads_v{}".format(ver))(request, data)
-
-        except AttributeError:
-            # This is a version we don't have a loads function for, so we'll
-            # just treat it as a miss and return None
-            return
-
-    def prepare_response(self, request, cached):
-        """Verify our vary headers match and construct a real urllib3
-        HTTPResponse object.
-        """
-        # Special case the '*' Vary value as it means we cannot actually
-        # determine if the cached response is suitable for this request.
-        # This case is also handled in the controller code when creating
-        # a cache entry, but is left here for backwards compatibility.
-        if "*" in cached.get("vary", {}):
-            return
-
-        # Ensure that the Vary headers for the cached response match our
-        # request
-        for header, value in cached.get("vary", {}).items():
-            if request.headers.get(header, None) != value:
-                return
-
-        body_raw = cached["response"].pop("body")
-
-        headers = CaseInsensitiveDict(data=cached["response"]["headers"])
-        if headers.get("transfer-encoding", "") == "chunked":
-            headers.pop("transfer-encoding")
-
-        cached["response"]["headers"] = headers
-
-        try:
-            body = io.BytesIO(body_raw)
-        except TypeError:
-            # This can happen if cachecontrol serialized to v1 format (pickle)
-            # using Python 2. A Python 2 str(byte string) will be unpickled as
-            # a Python 3 str (unicode string), which will cause the above to
-            # fail with:
-            #
-            #     TypeError: 'str' does not support the buffer interface
-            body = io.BytesIO(body_raw.encode("utf8"))
-
-        return HTTPResponse(body=body, preload_content=False, **cached["response"])
-
-    def _loads_v0(self, request, data):
-        # The original legacy cache data. This doesn't contain enough
-        # information to construct everything we need, so we'll treat this as
-        # a miss.
-        return
-
-    def _loads_v1(self, request, data):
-        try:
-            cached = pickle.loads(data)
-        except ValueError:
-            return
-
-        return self.prepare_response(request, cached)
-
-    def _loads_v2(self, request, data):
-        try:
-            cached = json.loads(zlib.decompress(data).decode("utf8"))
-        except (ValueError, zlib.error):
-            return
-
-        # We need to decode the items that we've base64 encoded
-        cached["response"]["body"] = _b64_decode_bytes(cached["response"]["body"])
-        cached["response"]["headers"] = dict(
-            (_b64_decode_str(k), _b64_decode_str(v))
-            for k, v in cached["response"]["headers"].items()
-        )
-        cached["response"]["reason"] = _b64_decode_str(cached["response"]["reason"])
-        cached["vary"] = dict(
-            (_b64_decode_str(k), _b64_decode_str(v) if v is not None else v)
-            for k, v in cached["vary"].items()
-        )
-
-        return self.prepare_response(request, cached)
-
-    def _loads_v3(self, request, data):
-        # Due to Python 2 encoding issues, it's impossible to know for sure
-        # exactly how to load v3 entries, thus we'll treat these as a miss so
-        # that they get rewritten out as v4 entries.
-        return
-
-    def _loads_v4(self, request, data):
-        try:
-            cached = msgpack.loads(data, raw=False)
-        except ValueError:
-            return
-
-        return self.prepare_response(request, cached)

package/.venv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/wrapper.py

@@ -1,29 +0,0 @@
-from .adapter import CacheControlAdapter
-from .cache import DictCache
-
-
-def CacheControl(
-    sess,
-    cache=None,
-    cache_etags=True,
-    serializer=None,
-    heuristic=None,
-    controller_class=None,
-    adapter_class=None,
-    cacheable_methods=None,
-):
-
-    cache = DictCache() if cache is None else cache
-    adapter_class = adapter_class or CacheControlAdapter
-    adapter = adapter_class(
-        cache,
-        cache_etags=cache_etags,
-        serializer=serializer,
-        heuristic=heuristic,
-        controller_class=controller_class,
-        cacheable_methods=cacheable_methods,
-    )
-    sess.mount("http://", adapter)
-    sess.mount("https://", adapter)
-
-    return sess

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

@@ -1,3 +0,0 @@
-from .core import contents, where
-
-__version__ = "2021.05.30"

package/.venv/lib/python3.9/site-packages/pip/_vendor/certifi/__main__.py

@@ -1,12 +0,0 @@
-import argparse
-
-from pip._vendor.certifi import contents, where
-
-parser = argparse.ArgumentParser()
-parser.add_argument("-c", "--contents", action="store_true")
-args = parser.parse_args()
-
-if args.contents:
-    print(contents())
-else:
-    print(where())