@scrypted/arlo 0.11.26 → 0.11.28

package/venv/lib/python3.10/site-packages/cloudscraper-1.2.71.dist-info/RECORD

@@ -1,48 +0,0 @@
-cloudscraper-1.2.71.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-cloudscraper-1.2.71.dist-info/LICENSE,sha256=luC9NJPEX0JAQUKWkzWlAOaaE69fNKnW1uIuDKmWERc,1091
-cloudscraper-1.2.71.dist-info/METADATA,sha256=XvCa6LxivvSR9Svobbm2vyib1ZqrS-UhtECsX3Gsaf0,19962
-cloudscraper-1.2.71.dist-info/RECORD,,
-cloudscraper-1.2.71.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cloudscraper-1.2.71.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
-cloudscraper-1.2.71.dist-info/top_level.txt,sha256=OFEsobVl62sa2NzpgNtfHZkIw_qZr_wljhjmlP9oGiM,13
-cloudscraper/__init__.py,sha256=Eg8AqKak2yYcraKqt7O3LJLNmppC2uL7dvAANiyxh5w,15960
-cloudscraper/__pycache__/__init__.cpython-310.pyc,,
-cloudscraper/__pycache__/cloudflare.cpython-310.pyc,,
-cloudscraper/__pycache__/exceptions.cpython-310.pyc,,
-cloudscraper/__pycache__/help.cpython-310.pyc,,
-cloudscraper/captcha/2captcha.py,sha256=yyDWvL6HVK4pM69aRpOV9mwzbtPC0yGz_mWkQ7-mkmI,10643
-cloudscraper/captcha/9kw.py,sha256=5EAUyO_vBEuLKsr4sXYa25MSVOm3BXVAdcenF6ZPsgI,7701
-cloudscraper/captcha/__init__.py,sha256=VORxm32xqLrEE-zxFWgEhSbtqfigjCfwodChg1VlQ6c,1511
-cloudscraper/captcha/__pycache__/2captcha.cpython-310.pyc,,
-cloudscraper/captcha/__pycache__/9kw.cpython-310.pyc,,
-cloudscraper/captcha/__pycache__/__init__.cpython-310.pyc,,
-cloudscraper/captcha/__pycache__/anticaptcha.cpython-310.pyc,,
-cloudscraper/captcha/__pycache__/capmonster.cpython-310.pyc,,
-cloudscraper/captcha/__pycache__/capsolver.cpython-310.pyc,,
-cloudscraper/captcha/__pycache__/deathbycaptcha.cpython-310.pyc,,
-cloudscraper/captcha/anticaptcha.py,sha256=YUsLviq3ZtbjTUnAPq6zVEieHmeSgnmiXKcqXZeO5qA,6152
-cloudscraper/captcha/capmonster.py,sha256=_9AUr6vHG4c5XLc5XqvnnMqgcvuKnzz1ckJpSySjgKQ,6143
-cloudscraper/captcha/capsolver.py,sha256=x38fO0m_k2W8nO3IppXADZsfCYl0iyvRgajZ5s5iTSU,6060
-cloudscraper/captcha/deathbycaptcha.py,sha256=asUX_quUsjAyWVRc7_8o_ryHZFotN-NP60mQiuN-c1U,8673
-cloudscraper/cloudflare.py,sha256=i1jyJcY-aRy3IQ-7YUly8qGUovO4Nx99M_FKfz4eivQ,19993
-cloudscraper/exceptions.py,sha256=WSMgI8PRvU3g4KDFrjU-42p83lSAVOw8tN2NSqqIUfw,2397
-cloudscraper/help.py,sha256=fNYNGFQjiCL1d-gCpDoulBk4iHOuzNhLBudi7NrOHSg,2100
-cloudscraper/interpreters/__init__.py,sha256=mWY8LuzDRYWGGnKz5vYSdrOnoVaeWlixmAtZN8Pq6bY,1734
-cloudscraper/interpreters/__pycache__/__init__.cpython-310.pyc,,
-cloudscraper/interpreters/__pycache__/chakracore.cpython-310.pyc,,
-cloudscraper/interpreters/__pycache__/encapsulated.cpython-310.pyc,,
-cloudscraper/interpreters/__pycache__/js2py.cpython-310.pyc,,
-cloudscraper/interpreters/__pycache__/jsunfuck.cpython-310.pyc,,
-cloudscraper/interpreters/__pycache__/native.cpython-310.pyc,,
-cloudscraper/interpreters/__pycache__/nodejs.cpython-310.pyc,,
-cloudscraper/interpreters/__pycache__/v8.cpython-310.pyc,,
-cloudscraper/interpreters/chakracore.py,sha256=IgbZsjxb-3YeDOF7uQOjVmiVTYxQV2pH4GSsne7SuIM,3355
-cloudscraper/interpreters/encapsulated.py,sha256=h-e1I_XZDs50Xnn4ZZQ7K1-tr3z3eCSvlXF0Yt4ajOY,1934
-cloudscraper/interpreters/js2py.py,sha256=MQkQj-Orp-atsyQnezX8SOc3L3B1lAEU15ym5_UiehU,1356
-cloudscraper/interpreters/jsunfuck.py,sha256=jahQuhe61HKtZVMjKO2mSaFod8BolGF4PmZ0v4g3BJM,3603
-cloudscraper/interpreters/native.py,sha256=lTZSxDOPMM1IoRnBIK-vS-tzvbZLcCDR7dBYRk_UYdI,8626
-cloudscraper/interpreters/nodejs.py,sha256=Hx649ILqCndcPkRCCbYx2cMeH5cc87NeEb52826QJhw,2084
-cloudscraper/interpreters/v8.py,sha256=hcXur1O__6jCc8s6VjNTynOmPqARvFI-4dSutZcYNbA,1005
-cloudscraper/user_agent/__init__.py,sha256=TMfWkMsRz9jgiZAL08dG2wjE0bjytBeOyclhIo2l22M,5409
-cloudscraper/user_agent/__pycache__/__init__.cpython-310.pyc,,
-cloudscraper/user_agent/browsers.json,sha256=oYv6V-X9y4tHXGxzsTsCeK7FlYRogt34EQ0yyr4_ZTc,1206600

package/venv/lib/python3.10/site-packages/cloudscraper-1.2.71.dist-info/WHEEL

@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-

package/venv/lib/python3.10/site-packages/cloudscraper-1.2.71.dist-info/top_level.txt

@@ -1 +0,0 @@
-cloudscraper

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

@@ -1,37 +0,0 @@
-__all__ = [
-    "Curl",
-    "AsyncCurl",
-    "CurlMime",
-    "CurlError",
-    "CurlInfo",
-    "CurlOpt",
-    "CurlMOpt",
-    "CurlECode",
-    "CurlHttpVersion",
-    "CurlSslVersion",
-    "CurlWsFlag",
-    "config_warnings",
-    "ffi",
-    "lib",
-]
-
-import _cffi_backend  # noqa: F401  # required by _wrapper
-
-from .__version__ import __curl_version__, __description__, __title__, __version__  # noqa: F401
-
-# This line includes _wrapper.so into the wheel
-from ._wrapper import ffi, lib
-from .aio import AsyncCurl
-from .const import (
-    CurlECode,
-    CurlHttpVersion,
-    CurlInfo,
-    CurlMOpt,
-    CurlOpt,
-    CurlSslVersion,
-    CurlWsFlag,
-)
-from .curl import Curl, CurlError, CurlMime
-from .utils import config_warnings
-
-config_warnings(on=False)

package/venv/lib/python3.10/site-packages/curl_cffi/__version__.py

@@ -1,8 +0,0 @@
-from importlib import metadata
-
-from .curl import Curl
-
-__title__ = "curl_cffi"
-__description__ = metadata.metadata("curl_cffi")["Summary"]
-__version__ = metadata.version("curl_cffi")
-__curl_version__ = Curl().version().decode()

package/venv/lib/python3.10/site-packages/curl_cffi/_asyncio_selector.py

@@ -1,344 +0,0 @@
-"""Ensure asyncio selector methods (add_reader, etc.) are available
-tornado 6.1 adds AddThreadSelectorEventLoop event loop,
-running select in a thread and defining these methods on the running event loop.
-This factors out the functionality of AddThreadSelectorEventLoop
-into a standalone SelectorThread object which can be attached to any running event loop.
-Vendored from tornado v6.4.0
-Redistributed under license Apache-2.0
-"""
-
-import asyncio
-import atexit
-import errno
-import functools
-import select
-import socket
-import threading
-import typing
-from contextlib import suppress
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Protocol,
-    Set,
-    Tuple,
-    TypeVar,
-    Union,
-)
-
-_T = TypeVar("_T")
-
-
-class _HasFileno(Protocol):
-    def fileno(self) -> int:
-        return 0
-
-
-_FileDescriptorLike = Union[int, _HasFileno]
-
-
-# Collection of selector thread event loops to shut down on exit.
-_selector_loops: Set["SelectorThread"] = set()
-
-
-def _atexit_callback() -> None:
-    for loop in _selector_loops:
-        with loop._select_cond:
-            loop._closing_selector = True
-            loop._select_cond.notify()
-        with suppress(BlockingIOError):
-            loop._waker_w.send(b"a")
-        if loop._thread is not None:
-            # If we don't join our (daemon) thread here, we may get a deadlock
-            # during interpreter shutdown. I don't really understand why. This
-            # deadlock happens every time in CI (both travis and appveyor) but
-            # I've never been able to reproduce locally.
-            loop._thread.join()
-    _selector_loops.clear()
-
-
-atexit.register(_atexit_callback)
-
-
-class SelectorThread:
-    """Define ``add_reader`` methods to be called in a background select thread.
-
-    Instances of this class start a second thread to run a selector.
-    This thread is completely hidden from the user;
-    all callbacks are run on the wrapped event loop's thread.
-
-    Typically used via ``AddThreadSelectorEventLoop``,
-    but can be attached to a running asyncio loop.
-    """
-
-    _closed = False
-
-    def __init__(self, real_loop: asyncio.AbstractEventLoop) -> None:
-        self._real_loop = real_loop
-
-        self._select_cond = threading.Condition()
-        self._select_args: Optional[Tuple[List[_FileDescriptorLike], List[_FileDescriptorLike]]] = (
-            None
-        )
-        self._closing_selector = False
-        self._thread: Optional[threading.Thread] = None
-        self._thread_manager_handle = self._thread_manager()
-
-        async def thread_manager_anext() -> None:
-            # the anext builtin wasn't added until 3.10. We just need to iterate
-            # this generator one step.
-            await self._thread_manager_handle.__anext__()
-
-        # When the loop starts, start the thread. Not too soon because we can't
-        # clean up if we get to this point but the event loop is closed without
-        # starting.
-        self._real_loop.call_soon(lambda: self._real_loop.create_task(thread_manager_anext()))
-
-        self._readers: Dict[_FileDescriptorLike, Callable] = {}
-        self._writers: Dict[_FileDescriptorLike, Callable] = {}
-
-        # Writing to _waker_w will wake up the selector thread, which
-        # watches for _waker_r to be readable.
-        self._waker_r, self._waker_w = socket.socketpair()
-        self._waker_r.setblocking(False)
-        self._waker_w.setblocking(False)
-        _selector_loops.add(self)
-        self.add_reader(self._waker_r, self._consume_waker)
-
-    def close(self) -> None:
-        if self._closed:
-            return
-        with self._select_cond:
-            self._closing_selector = True
-            self._select_cond.notify()
-        self._wake_selector()
-        if self._thread is not None:
-            self._thread.join()
-        _selector_loops.discard(self)
-        self.remove_reader(self._waker_r)
-        self._waker_r.close()
-        self._waker_w.close()
-        self._closed = True
-
-    async def _thread_manager(self) -> typing.AsyncGenerator[None, None]:
-        # Create a thread to run the select system call. We manage this thread
-        # manually so we can trigger a clean shutdown from an atexit hook. Note
-        # that due to the order of operations at shutdown, only daemon threads
-        # can be shut down in this way (non-daemon threads would require the
-        # introduction of a new hook: https://bugs.python.org/issue41962)
-        self._thread = threading.Thread(
-            name="Tornado selector",
-            daemon=True,
-            target=self._run_select,
-        )
-        self._thread.start()
-        self._start_select()
-        try:
-            # The presense of this yield statement means that this coroutine
-            # is actually an asynchronous generator, which has a special
-            # shutdown protocol. We wait at this yield point until the
-            # event loop's shutdown_asyncgens method is called, at which point
-            # we will get a GeneratorExit exception and can shut down the
-            # selector thread.
-            yield
-        except GeneratorExit:
-            self.close()
-            raise
-
-    def _wake_selector(self) -> None:
-        if self._closed:
-            return
-        with suppress(BlockingIOError):
-            self._waker_w.send(b"a")
-
-    def _consume_waker(self) -> None:
-        with suppress(BlockingIOError):
-            self._waker_r.recv(1024)
-
-    def _start_select(self) -> None:
-        # Capture reader and writer sets here in the event loop
-        # thread to avoid any problems with concurrent
-        # modification while the select loop uses them.
-        with self._select_cond:
-            assert self._select_args is None
-            self._select_args = (list(self._readers.keys()), list(self._writers.keys()))
-            self._select_cond.notify()
-
-    def _run_select(self) -> None:
-        while True:
-            with self._select_cond:
-                while self._select_args is None and not self._closing_selector:
-                    self._select_cond.wait()
-                if self._closing_selector:
-                    return
-                assert self._select_args is not None
-                to_read, to_write = self._select_args
-                self._select_args = None
-
-            # We use the simpler interface of the select module instead of
-            # the more stateful interface in the selectors module because
-            # this class is only intended for use on windows, where
-            # select.select is the only option. The selector interface
-            # does not have well-documented thread-safety semantics that
-            # we can rely on so ensuring proper synchronization would be
-            # tricky.
-            try:
-                # On windows, selecting on a socket for write will not
-                # return the socket when there is an error (but selecting
-                # for reads works). Also select for errors when selecting
-                # for writes, and merge the results.
-                #
-                # This pattern is also used in
-                # https://github.com/python/cpython/blob/v3.8.0/Lib/selectors.py#L312-L317
-                rs, ws, xs = select.select(to_read, to_write, to_write)
-                ws = ws + xs
-            except OSError as e:
-                # After remove_reader or remove_writer is called, the file
-                # descriptor may subsequently be closed on the event loop
-                # thread. It's possible that this select thread hasn't
-                # gotten into the select system call by the time that
-                # happens in which case (at least on macOS), select may
-                # raise a "bad file descriptor" error. If we get that
-                # error, check and see if we're also being woken up by
-                # polling the waker alone. If we are, just return to the
-                # event loop and we'll get the updated set of file
-                # descriptors on the next iteration. Otherwise, raise the
-                # original error.
-                if e.errno == getattr(errno, "WSAENOTSOCK", errno.EBADF):
-                    rs, _, _ = select.select([self._waker_r.fileno()], [], [], 0)
-                    if rs:
-                        ws = []
-                    else:
-                        raise
-                else:
-                    raise
-
-            try:
-                self._real_loop.call_soon_threadsafe(self._handle_select, rs, ws)
-            except RuntimeError:
-                # "Event loop is closed". Swallow the exception for
-                # consistency with PollIOLoop (and logical consistency
-                # with the fact that we can't guarantee that an
-                # add_callback that completes without error will
-                # eventually execute).
-                pass
-            except AttributeError:
-                # ProactorEventLoop may raise this instead of RuntimeError
-                # if call_soon_threadsafe races with a call to close().
-                # Swallow it too for consistency.
-                pass
-
-    def _handle_select(self, rs: List[_FileDescriptorLike], ws: List[_FileDescriptorLike]) -> None:
-        for r in rs:
-            self._handle_event(r, self._readers)
-        for w in ws:
-            self._handle_event(w, self._writers)
-        self._start_select()
-
-    def _handle_event(
-        self,
-        fd: _FileDescriptorLike,
-        cb_map: Dict[_FileDescriptorLike, Callable],
-    ) -> None:
-        try:
-            callback = cb_map[fd]
-        except KeyError:
-            return
-        callback()
-
-    def add_reader(
-        self, fd: _FileDescriptorLike, callback: Callable[..., None], *args: Any
-    ) -> None:
-        self._readers[fd] = functools.partial(callback, *args)
-        self._wake_selector()
-
-    def add_writer(
-        self, fd: _FileDescriptorLike, callback: Callable[..., None], *args: Any
-    ) -> None:
-        self._writers[fd] = functools.partial(callback, *args)
-        self._wake_selector()
-
-    def remove_reader(self, fd: _FileDescriptorLike) -> bool:
-        try:
-            del self._readers[fd]
-        except KeyError:
-            return False
-        self._wake_selector()
-        return True
-
-    def remove_writer(self, fd: _FileDescriptorLike) -> bool:
-        try:
-            del self._writers[fd]
-        except KeyError:
-            return False
-        self._wake_selector()
-        return True
-
-
-class AddThreadSelectorEventLoop(asyncio.AbstractEventLoop):
-    """Wrap an event loop to add implementations of the ``add_reader`` method family.
-
-    Instances of this class start a second thread to run a selector.
-    This thread is completely hidden from the user; all callbacks are
-    run on the wrapped event loop's thread.
-
-    This class is used automatically by Tornado; applications should not need
-    to refer to it directly.
-
-    It is safe to wrap any event loop with this class, although it only makes sense
-    for event loops that do not implement the ``add_reader`` family of methods
-    themselves (i.e. ``WindowsProactorEventLoop``)
-
-    Closing the ``AddThreadSelectorEventLoop`` also closes the wrapped event loop.
-
-    """
-
-    # This class is a __getattribute__-based proxy. All attributes other than those
-    # in this set are proxied through to the underlying loop.
-    MY_ATTRIBUTES = {
-        "_real_loop",
-        "_selector",
-        "add_reader",
-        "add_writer",
-        "close",
-        "remove_reader",
-        "remove_writer",
-    }
-
-    def __getattribute__(self, name: str) -> Any:
-        if name in AddThreadSelectorEventLoop.MY_ATTRIBUTES:
-            return super().__getattribute__(name)
-        return getattr(self._real_loop, name)
-
-    def __init__(self, real_loop: asyncio.AbstractEventLoop) -> None:
-        self._real_loop = real_loop
-        self._selector = SelectorThread(real_loop)
-
-    def close(self) -> None:
-        self._selector.close()
-        self._real_loop.close()
-
-    def add_reader(  # type: ignore
-        self,
-        fd: "_FileDescriptorLike",
-        callback: Callable[..., None],
-        *args: Any,
-    ) -> None:
-        return self._selector.add_reader(fd, callback, *args)
-
-    def add_writer(  # type: ignore
-        self,
-        fd: "_FileDescriptorLike",
-        callback: Callable[..., None],
-        *args: Any,  # type: ignore
-    ) -> None:
-        return self._selector.add_writer(fd, callback, *args)
-
-    def remove_reader(self, fd: "_FileDescriptorLike") -> bool:
-        return self._selector.remove_reader(fd)
-
-    def remove_writer(self, fd: "_FileDescriptorLike") -> bool:
-        return self._selector.remove_writer(fd)