diaspora-event-sdk 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

diaspora_event_sdk/sdk/botocore/awsrequest.py

@@ -0,0 +1,271 @@
+# Copyright (c) 2012-2013 Mitch Garnaat http://garnaat.org/
+# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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 functools
+import logging
+from collections.abc import Mapping
+
+from .compat import (
+    HTTPHeaders,
+    MutableMapping,
+    urlencode,
+    urlparse,
+)
+from .exceptions import UnseekableStreamError
+from .utils import determine_content_length
+
+logger = logging.getLogger(__name__)
+
+
+class AWSRequestPreparer:
+    """
+    This class performs preparation on AWSRequest objects similar to that of
+    the PreparedRequest class does in the requests library. However, the logic
+    has been boiled down to meet the specific use cases in botocore. Of note
+    there are the following differences:
+        This class does not heavily prepare the URL. Requests performed many
+        validations and corrections to ensure the URL is properly formatted.
+        Botocore either performs these validations elsewhere or otherwise
+        consistently provides well formatted URLs.
+
+        This class does not heavily prepare the body. Body preperation is
+        simple and supports only the cases that we document: bytes and
+        file-like objects to determine the content-length. This will also
+        additionally prepare a body that is a dict to be url encoded params
+        string as some signers rely on this. Finally, this class does not
+        support multipart file uploads.
+
+        This class does not prepare the method, auth or cookies.
+    """
+
+    def prepare(self, original):
+        method = original.method
+        url = self._prepare_url(original)
+        body = self._prepare_body(original)
+        headers = self._prepare_headers(original, body)
+        stream_output = original.stream_output
+
+        return AWSPreparedRequest(method, url, headers, body, stream_output)
+
+    def _prepare_url(self, original):
+        url = original.url
+        if original.params:
+            url_parts = urlparse(url)
+            delim = '&' if url_parts.query else '?'
+            if isinstance(original.params, Mapping):
+                params_to_encode = list(original.params.items())
+            else:
+                params_to_encode = original.params
+            params = urlencode(params_to_encode, doseq=True)
+            url = delim.join((url, params))
+        return url
+
+    def _prepare_headers(self, original, prepared_body=None):
+        headers = HeadersDict(original.headers.items())
+
+        # If the transfer encoding or content length is already set, use that
+        if 'Transfer-Encoding' in headers or 'Content-Length' in headers:
+            return headers
+
+        # Ensure we set the content length when it is expected
+        if original.method not in ('GET', 'HEAD', 'OPTIONS'):
+            length = self._determine_content_length(prepared_body)
+            if length is not None:
+                headers['Content-Length'] = str(length)
+            else:
+                # Failed to determine content length, using chunked
+                # NOTE: This shouldn't ever happen in practice
+                body_type = type(prepared_body)
+                logger.debug('Failed to determine length of %s', body_type)
+                headers['Transfer-Encoding'] = 'chunked'
+
+        return headers
+
+    def _to_utf8(self, item):
+        key, value = item
+        if isinstance(key, str):
+            key = key.encode('utf-8')
+        if isinstance(value, str):
+            value = value.encode('utf-8')
+        return key, value
+
+    def _prepare_body(self, original):
+        """Prepares the given HTTP body data."""
+        body = original.data
+        if body == b'':
+            body = None
+
+        if isinstance(body, dict):
+            params = [self._to_utf8(item) for item in body.items()]
+            body = urlencode(params, doseq=True)
+
+        return body
+
+    def _determine_content_length(self, body):
+        return determine_content_length(body)
+
+
+class AWSRequest:
+    """Represents the elements of an HTTP request.
+
+    This class was originally inspired by requests.models.Request, but has been
+    boiled down to meet the specific use cases in botocore. That being said this
+    class (even in requests) is effectively a named-tuple.
+    """
+
+    _REQUEST_PREPARER_CLS = AWSRequestPreparer
+
+    def __init__(
+        self,
+        method=None,
+        url=None,
+        headers=None,
+        data=None,
+        params=None,
+        auth_path=None,
+        stream_output=False,
+    ):
+        self._request_preparer = self._REQUEST_PREPARER_CLS()
+
+        # Default empty dicts for dict params.
+        params = {} if params is None else params
+
+        self.method = method
+        self.url = url
+        self.headers = HTTPHeaders()
+        self.data = data
+        self.params = params
+        self.auth_path = auth_path
+        self.stream_output = stream_output
+
+        if headers is not None:
+            for key, value in headers.items():
+                self.headers[key] = value
+
+        # This is a dictionary to hold information that is used when
+        # processing the request. What is inside of ``context`` is open-ended.
+        # For example, it may have a timestamp key that is used for holding
+        # what the timestamp is when signing the request. Note that none
+        # of the information that is inside of ``context`` is directly
+        # sent over the wire; the information is only used to assist in
+        # creating what is sent over the wire.
+        self.context = {}
+
+    def prepare(self):
+        """Constructs a :class:`AWSPreparedRequest <AWSPreparedRequest>`."""
+        return self._request_preparer.prepare(self)
+
+    @property
+    def body(self):
+        body = self.prepare().body
+        if isinstance(body, str):
+            body = body.encode('utf-8')
+        return body
+
+
+class AWSPreparedRequest:
+    """A data class representing a finalized request to be sent over the wire.
+
+    Requests at this stage should be treated as final, and the properties of
+    the request should not be modified.
+
+    :ivar method: The HTTP Method
+    :ivar url: The full url
+    :ivar headers: The HTTP headers to send.
+    :ivar body: The HTTP body.
+    :ivar stream_output: If the response for this request should be streamed.
+    """
+
+    def __init__(self, method, url, headers, body, stream_output):
+        self.method = method
+        self.url = url
+        self.headers = headers
+        self.body = body
+        self.stream_output = stream_output
+
+    def __repr__(self):
+        fmt = (
+            '<AWSPreparedRequest stream_output=%s, method=%s, url=%s, '
+            'headers=%s>'
+        )
+        return fmt % (self.stream_output, self.method, self.url, self.headers)
+
+    def reset_stream(self):
+        """Resets the streaming body to it's initial position.
+
+        If the request contains a streaming body (a streamable file-like object)
+        seek to the object's initial position to ensure the entire contents of
+        the object is sent. This is a no-op for static bytes-like body types.
+        """
+        # Trying to reset a stream when there is a no stream will
+        # just immediately return.  It's not an error, it will produce
+        # the same result as if we had actually reset the stream (we'll send
+        # the entire body contents again if we need to).
+        # Same case if the body is a string/bytes/bytearray type.
+
+        non_seekable_types = (bytes, str, bytearray)
+        if self.body is None or isinstance(self.body, non_seekable_types):
+            return
+        try:
+            logger.debug("Rewinding stream: %s", self.body)
+            self.body.seek(0)
+        except Exception as e:
+            logger.debug("Unable to rewind stream: %s", e)
+            raise UnseekableStreamError(stream_object=self.body)
+
+
+class _HeaderKey:
+    def __init__(self, key):
+        self._key = key
+        self._lower = key.lower()
+
+    def __hash__(self):
+        return hash(self._lower)
+
+    def __eq__(self, other):
+        return isinstance(other, _HeaderKey) and self._lower == other._lower
+
+    def __str__(self):
+        return self._key
+
+    def __repr__(self):
+        return repr(self._key)
+
+
+class HeadersDict(MutableMapping):
+    """A case-insenseitive dictionary to represent HTTP headers."""
+
+    def __init__(self, *args, **kwargs):
+        self._dict = {}
+        self.update(*args, **kwargs)
+
+    def __setitem__(self, key, value):
+        self._dict[_HeaderKey(key)] = value
+
+    def __getitem__(self, key):
+        return self._dict[_HeaderKey(key)]
+
+    def __delitem__(self, key):
+        del self._dict[_HeaderKey(key)]
+
+    def __iter__(self):
+        return (str(key) for key in self._dict)
+
+    def __len__(self):
+        return len(self._dict)
+
+    def __repr__(self):
+        return repr(self._dict)
+
+    def copy(self):
+        return HeadersDict(self.items())

diaspora_event_sdk/sdk/botocore/compat.py

@@ -0,0 +1,352 @@
+# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+
+from urllib.parse import (
+    quote,
+    urlencode,
+    unquote,
+    unquote_plus,
+    urlparse,
+    urlsplit,
+    urlunsplit,
+    urljoin,
+    parse_qsl,
+    parse_qs,
+)
+import json
+from itertools import zip_longest
+from email.utils import formatdate
+from base64 import encodebytes
+from io import IOBase as _IOBase
+from http.client import HTTPResponse
+import copy
+import datetime
+import sys
+import inspect
+import warnings
+import hashlib
+from http.client import HTTPMessage
+import logging
+import shlex
+import re
+import os
+from collections import OrderedDict
+from collections.abc import MutableMapping
+from math import floor
+
+# from dateutil.tz import tzlocal
+# from urllib3 import exceptions
+
+from .exceptions import MD5UnavailableError
+
+logger = logging.getLogger(__name__)
+
+
+class HTTPHeaders(HTTPMessage):
+    pass
+
+
+file_type = _IOBase
+zip = zip
+
+# In python3, unquote takes a str() object, url decodes it,
+# then takes the bytestring and decodes it to utf-8.
+unquote_str = unquote_plus
+
+
+def set_socket_timeout(http_response, timeout):
+    """Set the timeout of the socket from an HTTPResponse.
+
+    :param http_response: An instance of ``httplib.HTTPResponse``
+
+    """
+    http_response._fp.fp.raw._sock.settimeout(timeout)
+
+
+def accepts_kwargs(func):
+    # In python3.4.1, there's backwards incompatible
+    # changes when using getargspec with functools.partials.
+    return inspect.getfullargspec(func)[2]
+
+
+def ensure_unicode(s, encoding=None, errors=None):
+    # NOOP in Python 3, because every string is already unicode
+    return s
+
+
+def ensure_bytes(s, encoding='utf-8', errors='strict'):
+    if isinstance(s, str):
+        return s.encode(encoding, errors)
+    if isinstance(s, bytes):
+        return s
+    raise ValueError(f"Expected str or bytes, received {type(s)}.")
+
+
+try:
+    import xml.etree.cElementTree as ETree
+except ImportError:
+    # cElementTree does not exist from Python3.9+
+    import xml.etree.ElementTree as ETree
+XMLParseError = ETree.ParseError
+
+
+# def filter_ssl_warnings():
+#     # Ignore warnings related to SNI as it is not being used in validations.
+#     warnings.filterwarnings(
+#         'ignore',
+#         message="A true SSLContext object is not available.*",
+#         category=exceptions.InsecurePlatformWarning,
+#         module=r".*urllib3\.util\.ssl_",
+#     )
+
+
+@classmethod
+def from_dict(cls, d):
+    new_instance = cls()
+    for key, value in d.items():
+        new_instance[key] = value
+    return new_instance
+
+
+@classmethod
+def from_pairs(cls, pairs):
+    new_instance = cls()
+    for key, value in pairs:
+        new_instance[key] = value
+    return new_instance
+
+
+HTTPHeaders.from_dict = from_dict
+HTTPHeaders.from_pairs = from_pairs
+
+
+def copy_kwargs(kwargs):
+    """
+    This used to be a compat shim for 2.6 but is now just an alias.
+    """
+    copy_kwargs = copy.copy(kwargs)
+    return copy_kwargs
+
+
+def total_seconds(delta):
+    """
+    Returns the total seconds in a ``datetime.timedelta``.
+
+    This used to be a compat shim for 2.6 but is now just an alias.
+
+    :param delta: The timedelta object
+    :type delta: ``datetime.timedelta``
+    """
+    return delta.total_seconds()
+
+
+# Checks to see if md5 is available on this system. A given system might not
+# have access to it for various reasons, such as FIPS mode being enabled.
+try:
+    hashlib.md5()
+    MD5_AVAILABLE = True
+except ValueError:
+    MD5_AVAILABLE = False
+
+
+def get_md5(*args, **kwargs):
+    """
+    Attempts to get an md5 hashing object.
+
+    :param args: Args to pass to the MD5 constructor
+    :param kwargs: Key word arguments to pass to the MD5 constructor
+    :return: An MD5 hashing object if available. If it is unavailable, None
+        is returned if raise_error_if_unavailable is set to False.
+    """
+    if MD5_AVAILABLE:
+        return hashlib.md5(*args, **kwargs)
+    else:
+        raise MD5UnavailableError()
+
+
+def compat_shell_split(s, platform=None):
+    if platform is None:
+        platform = sys.platform
+
+    if platform == "win32":
+        return _windows_shell_split(s)
+    else:
+        return shlex.split(s)
+
+
+def _windows_shell_split(s):
+    """Splits up a windows command as the built-in command parser would.
+
+    Windows has potentially bizarre rules depending on where you look. When
+    spawning a process via the Windows C runtime (which is what python does
+    when you call popen) the rules are as follows:
+
+    https://docs.microsoft.com/en-us/cpp/cpp/parsing-cpp-command-line-arguments
+
+    To summarize:
+
+    * Only space and tab are valid delimiters
+    * Double quotes are the only valid quotes
+    * Backslash is interpreted literally unless it is part of a chain that
+      leads up to a double quote. Then the backslashes escape the backslashes,
+      and if there is an odd number the final backslash escapes the quote.
+
+    :param s: The command string to split up into parts.
+    :return: A list of command components.
+    """
+    if not s:
+        return []
+
+    components = []
+    buff = []
+    is_quoted = False
+    num_backslashes = 0
+    for character in s:
+        if character == '\\':
+            # We can't simply append backslashes because we don't know if
+            # they are being used as escape characters or not. Instead we
+            # keep track of how many we've encountered and handle them when
+            # we encounter a different character.
+            num_backslashes += 1
+        elif character == '"':
+            if num_backslashes > 0:
+                # The backslashes are in a chain leading up to a double
+                # quote, so they are escaping each other.
+                buff.append('\\' * int(floor(num_backslashes / 2)))
+                remainder = num_backslashes % 2
+                num_backslashes = 0
+                if remainder == 1:
+                    # The number of backslashes is uneven, so they are also
+                    # escaping the double quote, so it needs to be added to
+                    # the current component buffer.
+                    buff.append('"')
+                    continue
+
+            # We've encountered a double quote that is not escaped,
+            # so we toggle is_quoted.
+            is_quoted = not is_quoted
+
+            # If there are quotes, then we may want an empty string. To be
+            # safe, we add an empty string to the buffer so that we make
+            # sure it sticks around if there's nothing else between quotes.
+            # If there is other stuff between quotes, the empty string will
+            # disappear during the joining process.
+            buff.append('')
+        elif character in [' ', '\t'] and not is_quoted:
+            # Since the backslashes aren't leading up to a quote, we put in
+            # the exact number of backslashes.
+            if num_backslashes > 0:
+                buff.append('\\' * num_backslashes)
+                num_backslashes = 0
+
+            # Excess whitespace is ignored, so only add the components list
+            # if there is anything in the buffer.
+            if buff:
+                components.append(''.join(buff))
+                buff = []
+        else:
+            # Since the backslashes aren't leading up to a quote, we put in
+            # the exact number of backslashes.
+            if num_backslashes > 0:
+                buff.append('\\' * num_backslashes)
+                num_backslashes = 0
+            buff.append(character)
+
+    # Quotes must be terminated.
+    if is_quoted:
+        raise ValueError(f"No closing quotation in string: {s}")
+
+    # There may be some leftover backslashes, so we need to add them in.
+    # There's no quote so we add the exact number.
+    if num_backslashes > 0:
+        buff.append('\\' * num_backslashes)
+
+    # Add the final component in if there is anything in the buffer.
+    if buff:
+        components.append(''.join(buff))
+
+    return components
+
+
+# def get_tzinfo_options():
+#     # Due to dateutil/dateutil#197, Windows may fail to parse times in the past
+#     # with the system clock. We can alternatively fallback to tzwininfo when
+#     # this happens, which will get time info from the Windows registry.
+#     if sys.platform == 'win32':
+#         from dateutil.tz import tzwinlocal
+
+#         return (tzlocal, tzwinlocal)
+#     else:
+#         return (tzlocal,)
+
+
+# Detect if CRT is available for use
+try:
+    import awscrt.auth
+
+    # Allow user opt-out if needed
+    disabled = os.environ.get('BOTO_DISABLE_CRT', "false")
+    HAS_CRT = not disabled.lower() == 'true'
+except ImportError:
+    HAS_CRT = False
+
+
+########################################################
+#              urllib3 compat backports                #
+########################################################
+
+# Vendoring IPv6 validation regex patterns from urllib3
+# https://github.com/urllib3/urllib3/blob/7e856c0/src/urllib3/util/url.py
+IPV4_PAT = r"(?:[0-9]{1,3}\.){3}[0-9]{1,3}"
+IPV4_RE = re.compile("^" + IPV4_PAT + "$")
+HEX_PAT = "[0-9A-Fa-f]{1,4}"
+LS32_PAT = "(?:{hex}:{hex}|{ipv4})".format(hex=HEX_PAT, ipv4=IPV4_PAT)
+_subs = {"hex": HEX_PAT, "ls32": LS32_PAT}
+_variations = [
+    #                            6( h16 ":" ) ls32
+    "(?:%(hex)s:){6}%(ls32)s",
+    #                       "::" 5( h16 ":" ) ls32
+    "::(?:%(hex)s:){5}%(ls32)s",
+    # [               h16 ] "::" 4( h16 ":" ) ls32
+    "(?:%(hex)s)?::(?:%(hex)s:){4}%(ls32)s",
+    # [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
+    "(?:(?:%(hex)s:)?%(hex)s)?::(?:%(hex)s:){3}%(ls32)s",
+    # [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
+    "(?:(?:%(hex)s:){0,2}%(hex)s)?::(?:%(hex)s:){2}%(ls32)s",
+    # [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32
+    "(?:(?:%(hex)s:){0,3}%(hex)s)?::%(hex)s:%(ls32)s",
+    # [ *4( h16 ":" ) h16 ] "::"              ls32
+    "(?:(?:%(hex)s:){0,4}%(hex)s)?::%(ls32)s",
+    # [ *5( h16 ":" ) h16 ] "::"              h16
+    "(?:(?:%(hex)s:){0,5}%(hex)s)?::%(hex)s",
+    # [ *6( h16 ":" ) h16 ] "::"
+    "(?:(?:%(hex)s:){0,6}%(hex)s)?::",
+]
+
+UNRESERVED_PAT = (
+    r"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._!\-~"
+)
+IPV6_PAT = "(?:" + "|".join([x % _subs for x in _variations]) + ")"
+ZONE_ID_PAT = "(?:%25|%)(?:[" + UNRESERVED_PAT + "]|%[a-fA-F0-9]{2})+"
+IPV6_ADDRZ_PAT = r"\[" + IPV6_PAT + r"(?:" + ZONE_ID_PAT + r")?\]"
+IPV6_ADDRZ_RE = re.compile("^" + IPV6_ADDRZ_PAT + "$")
+
+# These are the characters that are stripped by post-bpo-43882 urlparse().
+UNSAFE_URL_CHARS = frozenset('\t\r\n')
+
+# Detect if gzip is available for use
+try:
+    import gzip
+    HAS_GZIP = True
+except ImportError:
+    HAS_GZIP = False

diaspora_event_sdk/sdk/botocore/credentials.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2012-2013 Mitch Garnaat http://garnaat.org/
+# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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 logging
+from collections import namedtuple
+
+from .compat import ensure_unicode
+
+logger = logging.getLogger(__name__)
+ReadOnlyCredentials = namedtuple(
+    'ReadOnlyCredentials', ['access_key', 'secret_key', 'token']
+)
+
+_DEFAULT_MANDATORY_REFRESH_TIMEOUT = 10 * 60  # 10 min
+_DEFAULT_ADVISORY_REFRESH_TIMEOUT = 15 * 60  # 15 min
+
+
+class Credentials:
+    """
+    Holds the credentials needed to authenticate requests.
+
+    :param str access_key: The access key part of the credentials.
+    :param str secret_key: The secret key part of the credentials.
+    :param str token: The security token, valid only for session credentials.
+    :param str method: A string which identifies where the credentials
+        were found.
+    """
+
+    def __init__(self, access_key, secret_key, token=None, method=None):
+        self.access_key = access_key
+        self.secret_key = secret_key
+        self.token = token
+
+        if method is None:
+            method = 'explicit'
+        self.method = method
+
+        self._normalize()
+
+    def _normalize(self):
+        # Keys would sometimes (accidentally) contain non-ascii characters.
+        # It would cause a confusing UnicodeDecodeError in Python 2.
+        # We explicitly convert them into unicode to avoid such error.
+        #
+        # Eventually the service will decide whether to accept the credential.
+        # This also complies with the behavior in Python 3.
+        # self.access_key = botocore.compat.ensure_unicode(self.access_key)
+        # self.secret_key = botocore.compat.ensure_unicode(self.secret_key)
+        self.access_key = ensure_unicode(self.access_key)
+        self.secret_key = ensure_unicode(self.secret_key)
+
+    def get_frozen_credentials(self):
+        return ReadOnlyCredentials(
+            self.access_key, self.secret_key, self.token
+        )