@scrypted/arlo 0.11.26 → 0.11.27

package/venv/lib/python3.10/site-packages/requests_toolbelt/sessions.py

@@ -1,89 +0,0 @@
-import requests
-
-from ._compat import urljoin
-
-
-class BaseUrlSession(requests.Session):
-    """A Session with a URL that all requests will use as a base.
-
-    Let's start by looking at a few examples:
-
-    .. code-block:: python
-
-        >>> from requests_toolbelt import sessions
-        >>> s = sessions.BaseUrlSession(
-        ...     base_url='https://example.com/resource/')
-        >>> r = s.get('sub-resource/', params={'foo': 'bar'})
-        >>> print(r.request.url)
-        https://example.com/resource/sub-resource/?foo=bar
-
-    Our call to the ``get`` method will make a request to the URL passed in
-    when we created the Session and the partial resource name we provide.
-    We implement this by overriding the ``request`` method of the Session.
-
-    Likewise, we override the ``prepare_request`` method so you can construct
-    a PreparedRequest in the same way:
-
-    .. code-block:: python
-
-        >>> from requests import Request
-        >>> from requests_toolbelt import sessions
-        >>> s = sessions.BaseUrlSession(
-        ...     base_url='https://example.com/resource/')
-        >>> request = Request(method='GET', url='sub-resource/')
-        >>> prepared_request = s.prepare_request(request)
-        >>> r = s.send(prepared_request)
-        >>> print(r.request.url)
-        https://example.com/resource/sub-resource
-
-    .. note::
-
-        The base URL that you provide and the path you provide are **very**
-        important.
-
-    Let's look at another *similar* example
-
-    .. code-block:: python
-
-        >>> from requests_toolbelt import sessions
-        >>> s = sessions.BaseUrlSession(
-        ...     base_url='https://example.com/resource/')
-        >>> r = s.get('/sub-resource/', params={'foo': 'bar'})
-        >>> print(r.request.url)
-        https://example.com/sub-resource/?foo=bar
-
-    The key difference here is that we called ``get`` with ``/sub-resource/``,
-    i.e., there was a leading ``/``. This changes how we create the URL
-    because we rely on :mod:`urllib.parse.urljoin`.
-
-    To override how we generate the URL, sub-class this method and override the
-    ``create_url`` method.
-
-    Based on implementation from
-    https://github.com/kennethreitz/requests/issues/2554#issuecomment-109341010
-    """
-
-    base_url = None
-
-    def __init__(self, base_url=None):
-        if base_url:
-            self.base_url = base_url
-        super(BaseUrlSession, self).__init__()
-
-    def request(self, method, url, *args, **kwargs):
-        """Send the request after generating the complete URL."""
-        url = self.create_url(url)
-        return super(BaseUrlSession, self).request(
-            method, url, *args, **kwargs
-        )
-
-    def prepare_request(self, request, *args, **kwargs):
-        """Prepare the request after generating the complete URL."""
-        request.url = self.create_url(request.url)
-        return super(BaseUrlSession, self).prepare_request(
-            request, *args, **kwargs
-        )
-
-    def create_url(self, url):
-        """Create the URL based off this partial path."""
-        return urljoin(self.base_url, url)

package/venv/lib/python3.10/site-packages/requests_toolbelt/streaming_iterator.py

@@ -1,116 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-
-requests_toolbelt.streaming_iterator
-====================================
-
-This holds the implementation details for the :class:`StreamingIterator`. It
-is designed for the case where you, the user, know the size of the upload but
-need to provide the data as an iterator. This class will allow you to specify
-the size and stream the data without using a chunked transfer-encoding.
-
-"""
-from requests.utils import super_len
-
-from .multipart.encoder import CustomBytesIO, encode_with
-
-
-class StreamingIterator(object):
-
-    """
-    This class provides a way of allowing iterators with a known size to be
-    streamed instead of chunked.
-
-    In requests, if you pass in an iterator it assumes you want to use
-    chunked transfer-encoding to upload the data, which not all servers
-    support well. Additionally, you may want to set the content-length
-    yourself to avoid this but that will not work. The only way to preempt
-    requests using a chunked transfer-encoding and forcing it to stream the
-    uploads is to mimic a very specific interace. Instead of having to know
-    these details you can instead just use this class. You simply provide the
-    size and iterator and pass the instance of StreamingIterator to requests
-    via the data parameter like so:
-
-    .. code-block:: python
-
-        from requests_toolbelt import StreamingIterator
-
-        import requests
-
-        # Let iterator be some generator that you already have and size be
-        # the size of the data produced by the iterator
-
-        r = requests.post(url, data=StreamingIterator(size, iterator))
-
-    You can also pass file-like objects to :py:class:`StreamingIterator` in
-    case requests can't determize the filesize itself. This is the case with
-    streaming file objects like ``stdin`` or any sockets. Wrapping e.g. files
-    that are on disk with ``StreamingIterator`` is unnecessary, because
-    requests can determine the filesize itself.
-
-    Naturally, you should also set the `Content-Type` of your upload
-    appropriately because the toolbelt will not attempt to guess that for you.
-    """
-
-    def __init__(self, size, iterator, encoding='utf-8'):
-        #: The expected size of the upload
-        self.size = int(size)
-
-        if self.size < 0:
-            raise ValueError(
-                'The size of the upload must be a positive integer'
-                )
-
-        #: Attribute that requests will check to determine the length of the
-        #: body. See bug #80 for more details
-        self.len = self.size
-
-        #: Encoding the input data is using
-        self.encoding = encoding
-
-        #: The iterator used to generate the upload data
-        self.iterator = iterator
-
-        if hasattr(iterator, 'read'):
-            self._file = iterator
-        else:
-            self._file = _IteratorAsBinaryFile(iterator, encoding)
-
-    def read(self, size=-1):
-        return encode_with(self._file.read(size), self.encoding)
-
-
-class _IteratorAsBinaryFile(object):
-    def __init__(self, iterator, encoding='utf-8'):
-        #: The iterator used to generate the upload data
-        self.iterator = iterator
-
-        #: Encoding the iterator is using
-        self.encoding = encoding
-
-        # The buffer we use to provide the correct number of bytes requested
-        # during a read
-        self._buffer = CustomBytesIO()
-
-    def _get_bytes(self):
-        try:
-            return encode_with(next(self.iterator), self.encoding)
-        except StopIteration:
-            return b''
-
-    def _load_bytes(self, size):
-        self._buffer.smart_truncate()
-        amount_to_load = size - super_len(self._buffer)
-        bytes_to_append = True
-
-        while amount_to_load > 0 and bytes_to_append:
-            bytes_to_append = self._get_bytes()
-            amount_to_load -= self._buffer.append(bytes_to_append)
-
-    def read(self, size=-1):
-        size = int(size)
-        if size == -1:
-            return b''.join(self.iterator)
-
-        self._load_bytes(size)
-        return self._buffer.read(size)

package/venv/lib/python3.10/site-packages/requests_toolbelt/threaded/__init__.py

@@ -1,97 +0,0 @@
-"""
-This module provides the API for ``requests_toolbelt.threaded``.
-
-The module provides a clean and simple API for making requests via a thread
-pool. The thread pool will use sessions for increased performance.
-
-A simple use-case is:
-
-.. code-block:: python
-
-    from requests_toolbelt import threaded
-
-    urls_to_get = [{
-        'url': 'https://api.github.com/users/sigmavirus24',
-        'method': 'GET',
-    }, {
-        'url': 'https://api.github.com/repos/requests/toolbelt',
-        'method': 'GET',
-    }, {
-        'url': 'https://google.com',
-        'method': 'GET',
-    }]
-    responses, errors = threaded.map(urls_to_get)
-
-By default, the threaded submodule will detect the number of CPUs your
-computer has and use that if no other number of processes is selected. To
-change this, always use the keyword argument ``num_processes``. Using the
-above example, we would expand it like so:
-
-.. code-block:: python
-
-    responses, errors = threaded.map(urls_to_get, num_processes=10)
-
-You can also customize how a :class:`requests.Session` is initialized by
-creating a callback function:
-
-.. code-block:: python
-
-    from requests_toolbelt import user_agent
-
-    def initialize_session(session):
-        session.headers['User-Agent'] = user_agent('my-scraper', '0.1')
-        session.headers['Accept'] = 'application/json'
-
-    responses, errors = threaded.map(urls_to_get,
-                                     initializer=initialize_session)
-
-.. autofunction:: requests_toolbelt.threaded.map
-
-Inspiration is blatantly drawn from the standard library's multiprocessing
-library. See the following references:
-
-- multiprocessing's `pool source`_
-
-- map and map_async `inspiration`_
-
-.. _pool source:
-    https://hg.python.org/cpython/file/8ef4f75a8018/Lib/multiprocessing/pool.py
-.. _inspiration:
-    https://hg.python.org/cpython/file/8ef4f75a8018/Lib/multiprocessing/pool.py#l340
-"""
-from . import pool
-from .._compat import queue
-
-
-def map(requests, **kwargs):
-    r"""Simple interface to the threaded Pool object.
-
-    This function takes a list of dictionaries representing requests to make
-    using Sessions in threads and returns a tuple where the first item is
-    a generator of successful responses and the second is a generator of
-    exceptions.
-
-    :param list requests:
-        Collection of dictionaries representing requests to make with the Pool
-        object.
-    :param \*\*kwargs:
-        Keyword arguments that are passed to the
-        :class:`~requests_toolbelt.threaded.pool.Pool` object.
-    :returns: Tuple of responses and exceptions from the pool
-    :rtype: (:class:`~requests_toolbelt.threaded.pool.ThreadResponse`,
-        :class:`~requests_toolbelt.threaded.pool.ThreadException`)
-    """
-    if not (requests and all(isinstance(r, dict) for r in requests)):
-        raise ValueError('map expects a list of dictionaries.')
-
-    # Build our queue of requests
-    job_queue = queue.Queue()
-    for request in requests:
-        job_queue.put(request)
-
-    # Ensure the user doesn't try to pass their own job_queue
-    kwargs['job_queue'] = job_queue
-
-    threadpool = pool.Pool(**kwargs)
-    threadpool.join_all()
-    return threadpool.responses(), threadpool.exceptions()

package/venv/lib/python3.10/site-packages/requests_toolbelt/threaded/pool.py

@@ -1,211 +0,0 @@
-"""Module implementing the Pool for :mod:``requests_toolbelt.threaded``."""
-import multiprocessing
-import requests
-
-from . import thread
-from .._compat import queue
-
-
-class Pool(object):
-    """Pool that manages the threads containing sessions.
-
-    :param queue:
-        The queue you're expected to use to which you should add items.
-    :type queue: queue.Queue
-    :param initializer:
-        Function used to initialize an instance of ``session``.
-    :type initializer: collections.Callable
-    :param auth_generator:
-        Function used to generate new auth credentials for the session.
-    :type auth_generator: collections.Callable
-    :param int num_process:
-        Number of threads to create.
-    :param session:
-    :type session: requests.Session
-    """
-
-    def __init__(self, job_queue, initializer=None, auth_generator=None,
-                 num_processes=None, session=requests.Session):
-        if num_processes is None:
-            num_processes = multiprocessing.cpu_count() or 1
-
-        if num_processes < 1:
-            raise ValueError("Number of processes should at least be 1.")
-
-        self._job_queue = job_queue
-        self._response_queue = queue.Queue()
-        self._exc_queue = queue.Queue()
-        self._processes = num_processes
-        self._initializer = initializer or _identity
-        self._auth = auth_generator or _identity
-        self._session = session
-        self._pool = [
-            thread.SessionThread(self._new_session(), self._job_queue,
-                                 self._response_queue, self._exc_queue)
-            for _ in range(self._processes)
-        ]
-
-    def _new_session(self):
-        return self._auth(self._initializer(self._session()))
-
-    @classmethod
-    def from_exceptions(cls, exceptions, **kwargs):
-        r"""Create a :class:`~Pool` from an :class:`~ThreadException`\ s.
-
-        Provided an iterable that provides :class:`~ThreadException` objects,
-        this classmethod will generate a new pool to retry the requests that
-        caused the exceptions.
-
-        :param exceptions:
-            Iterable that returns :class:`~ThreadException`
-        :type exceptions: iterable
-        :param kwargs:
-            Keyword arguments passed to the :class:`~Pool` initializer.
-        :returns: An initialized :class:`~Pool` object.
-        :rtype: :class:`~Pool`
-        """
-        job_queue = queue.Queue()
-        for exc in exceptions:
-            job_queue.put(exc.request_kwargs)
-
-        return cls(job_queue=job_queue, **kwargs)
-
-    @classmethod
-    def from_urls(cls, urls, request_kwargs=None, **kwargs):
-        """Create a :class:`~Pool` from an iterable of URLs.
-
-        :param urls:
-            Iterable that returns URLs with which we create a pool.
-        :type urls: iterable
-        :param dict request_kwargs:
-            Dictionary of other keyword arguments to provide to the request
-            method.
-        :param kwargs:
-            Keyword arguments passed to the :class:`~Pool` initializer.
-        :returns: An initialized :class:`~Pool` object.
-        :rtype: :class:`~Pool`
-        """
-        request_dict = {'method': 'GET'}
-        request_dict.update(request_kwargs or {})
-        job_queue = queue.Queue()
-        for url in urls:
-            job = request_dict.copy()
-            job.update({'url': url})
-            job_queue.put(job)
-
-        return cls(job_queue=job_queue, **kwargs)
-
-    def exceptions(self):
-        """Iterate over all the exceptions in the pool.
-
-        :returns: Generator of :class:`~ThreadException`
-        """
-        while True:
-            exc = self.get_exception()
-            if exc is None:
-                break
-            yield exc
-
-    def get_exception(self):
-        """Get an exception from the pool.
-
-        :rtype: :class:`~ThreadException`
-        """
-        try:
-            (request, exc) = self._exc_queue.get_nowait()
-        except queue.Empty:
-            return None
-        else:
-            return ThreadException(request, exc)
-
-    def get_response(self):
-        """Get a response from the pool.
-
-        :rtype: :class:`~ThreadResponse`
-        """
-        try:
-            (request, response) = self._response_queue.get_nowait()
-        except queue.Empty:
-            return None
-        else:
-            return ThreadResponse(request, response)
-
-    def responses(self):
-        """Iterate over all the responses in the pool.
-
-        :returns: Generator of :class:`~ThreadResponse`
-        """
-        while True:
-            resp = self.get_response()
-            if resp is None:
-                break
-            yield resp
-
-    def join_all(self):
-        """Join all the threads to the master thread."""
-        for session_thread in self._pool:
-            session_thread.join()
-
-
-class ThreadProxy(object):
-    proxied_attr = None
-
-    def __getattr__(self, attr):
-        """Proxy attribute accesses to the proxied object."""
-        get = object.__getattribute__
-        if attr not in self.attrs:
-            response = get(self, self.proxied_attr)
-            return getattr(response, attr)
-        else:
-            return get(self, attr)
-
-
-class ThreadResponse(ThreadProxy):
-    """A wrapper around a requests Response object.
-
-    This will proxy most attribute access actions to the Response object. For
-    example, if you wanted the parsed JSON from the response, you might do:
-
-    .. code-block:: python
-
-        thread_response = pool.get_response()
-        json = thread_response.json()
-
-    """
-    proxied_attr = 'response'
-    attrs = frozenset(['request_kwargs', 'response'])
-
-    def __init__(self, request_kwargs, response):
-        #: The original keyword arguments provided to the queue
-        self.request_kwargs = request_kwargs
-        #: The wrapped response
-        self.response = response
-
-
-class ThreadException(ThreadProxy):
-    """A wrapper around an exception raised during a request.
-
-    This will proxy most attribute access actions to the exception object. For
-    example, if you wanted the message from the exception, you might do:
-
-    .. code-block:: python
-
-        thread_exc = pool.get_exception()
-        msg = thread_exc.message
-
-    """
-    proxied_attr = 'exception'
-    attrs = frozenset(['request_kwargs', 'exception'])
-
-    def __init__(self, request_kwargs, exception):
-        #: The original keyword arguments provided to the queue
-        self.request_kwargs = request_kwargs
-        #: The captured and wrapped exception
-        self.exception = exception
-
-
-def _identity(session_obj):
-    return session_obj
-
-
-__all__ = ['ThreadException', 'ThreadResponse', 'Pool']

package/venv/lib/python3.10/site-packages/requests_toolbelt/threaded/thread.py

@@ -1,53 +0,0 @@
-"""Module containing the SessionThread class."""
-import threading
-import uuid
-
-import requests.exceptions as exc
-
-from .._compat import queue
-
-
-class SessionThread(object):
-    def __init__(self, initialized_session, job_queue, response_queue,
-                 exception_queue):
-        self._session = initialized_session
-        self._jobs = job_queue
-        self._create_worker()
-        self._responses = response_queue
-        self._exceptions = exception_queue
-
-    def _create_worker(self):
-        self._worker = threading.Thread(
-            target=self._make_request,
-            name=uuid.uuid4(),
-        )
-        self._worker.daemon = True
-        self._worker._state = 0
-        self._worker.start()
-
-    def _handle_request(self, kwargs):
-        try:
-            response = self._session.request(**kwargs)
-        except exc.RequestException as e:
-            self._exceptions.put((kwargs, e))
-        else:
-            self._responses.put((kwargs, response))
-        finally:
-            self._jobs.task_done()
-
-    def _make_request(self):
-        while True:
-            try:
-                kwargs = self._jobs.get_nowait()
-            except queue.Empty:
-                break
-
-            self._handle_request(kwargs)
-
-    def is_alive(self):
-        """Proxy to the thread's ``is_alive`` method."""
-        return self._worker.is_alive()
-
-    def join(self):
-        """Join this thread to the master thread."""
-        self._worker.join()

package/venv/lib/python3.10/site-packages/requests_toolbelt/utils/deprecated.py

@@ -1,91 +0,0 @@
-# -*- coding: utf-8 -*-
-"""A collection of functions deprecated in requests.utils."""
-import re
-import sys
-
-from requests import utils
-
-find_charset = re.compile(
-    br'<meta.*?charset=["\']*(.+?)["\'>]', flags=re.I
-).findall
-
-find_pragma = re.compile(
-    br'<meta.*?content=["\']*;?charset=(.+?)["\'>]', flags=re.I
-).findall
-
-find_xml = re.compile(
-    br'^<\?xml.*?encoding=["\']*(.+?)["\'>]'
-).findall
-
-
-def get_encodings_from_content(content):
-    """Return encodings from given content string.
-
-    .. code-block:: python
-
-        import requests
-        from requests_toolbelt.utils import deprecated
-
-        r = requests.get(url)
-        encodings = deprecated.get_encodings_from_content(r)
-
-    :param content: bytestring to extract encodings from
-    :type content: bytes
-    :return: encodings detected in the provided content
-    :rtype: list(str)
-    """
-    encodings = (find_charset(content) + find_pragma(content)
-                 + find_xml(content))
-    if (3, 0) <= sys.version_info < (4, 0):
-        encodings = [encoding.decode('utf8') for encoding in encodings]
-    return encodings
-
-
-def get_unicode_from_response(response):
-    """Return the requested content back in unicode.
-
-    This will first attempt to retrieve the encoding from the response
-    headers. If that fails, it will use
-    :func:`requests_toolbelt.utils.deprecated.get_encodings_from_content`
-    to determine encodings from HTML elements.
-
-    .. code-block:: python
-
-        import requests
-        from requests_toolbelt.utils import deprecated
-
-        r = requests.get(url)
-        text = deprecated.get_unicode_from_response(r)
-
-    :param response: Response object to get unicode content from.
-    :type response: requests.models.Response
-    """
-    tried_encodings = set()
-
-    # Try charset from content-type
-    encoding = utils.get_encoding_from_headers(response.headers)
-
-    if encoding:
-        try:
-            return str(response.content, encoding)
-        except UnicodeError:
-            tried_encodings.add(encoding.lower())
-
-    encodings = get_encodings_from_content(response.content)
-
-    for _encoding in encodings:
-        _encoding = _encoding.lower()
-        if _encoding in tried_encodings:
-            continue
-        try:
-            return str(response.content, _encoding)
-        except UnicodeError:
-            tried_encodings.add(_encoding)
-
-    # Fall back:
-    if encoding:
-        try:
-            return str(response.content, encoding, errors='replace')
-        except TypeError:
-            pass
-    return response.text