@scrypted/arlo 0.11.26 → 0.11.28

package/venv/lib/python3.10/site-packages/async_timeout-5.0.1.dist-info/LICENSE

@@ -1,13 +0,0 @@
-Copyright 2016-2020 aio-libs collaboration.
-
-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.

package/venv/lib/python3.10/site-packages/async_timeout-5.0.1.dist-info/METADATA

@@ -1,163 +0,0 @@
-Metadata-Version: 2.1
-Name: async-timeout
-Version: 5.0.1
-Summary: Timeout context manager for asyncio programs
-Home-page: https://github.com/aio-libs/async-timeout
-Author: Andrew Svetlov <andrew.svetlov@gmail.com>
-Author-email: andrew.svetlov@gmail.com
-License: Apache 2
-Project-URL: Chat: Gitter, https://gitter.im/aio-libs/Lobby
-Project-URL: CI: GitHub Actions, https://github.com/aio-libs/async-timeout/actions
-Project-URL: Coverage: codecov, https://codecov.io/github/aio-libs/async-timeout
-Project-URL: GitHub: issues, https://github.com/aio-libs/async-timeout/issues
-Project-URL: GitHub: repo, https://github.com/aio-libs/async-timeout
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Framework :: AsyncIO
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.8
-Description-Content-Type: text/x-rst
-License-File: LICENSE
-
-async-timeout
-=============
-.. image:: https://travis-ci.com/aio-libs/async-timeout.svg?branch=master
-    :target: https://travis-ci.com/aio-libs/async-timeout
-.. image:: https://codecov.io/gh/aio-libs/async-timeout/branch/master/graph/badge.svg
-    :target: https://codecov.io/gh/aio-libs/async-timeout
-.. image:: https://img.shields.io/pypi/v/async-timeout.svg
-    :target: https://pypi.python.org/pypi/async-timeout
-.. image:: https://badges.gitter.im/Join%20Chat.svg
-    :target: https://gitter.im/aio-libs/Lobby
-    :alt: Chat on Gitter
-
-asyncio-compatible timeout context manager.
-
-
-
-DEPRECATED
-----------
-
-This library has effectively been upstreamed into Python 3.11+.
-
-Therefore this library is considered deprecated and no longer actively supported.
-
-Version 5.0+ provides dual-mode when executed on Python 3.11+:
-``asyncio_timeout.Timeout`` is fully compatible with ``asyncio.Timeout`` *and* old
-versions of the library.
-
-Anyway, using upstream is highly recommended. ``asyncio_timeout`` exists only for the
-sake of backward compatibility, easy supporting both old and new Python by the same
-code, and easy misgration.
-
-If rescheduling API is not important and only ``async with timeout(...): ...`` functionality is required,
-a user could apply conditional import::
-
-    if sys.version_info >= (3, 11):
-        from asyncio import timeout, timeout_at
-    else:
-        from async_timeout import timeout, timeout_at
-
-
-Usage example
--------------
-
-
-The context manager is useful in cases when you want to apply timeout
-logic around block of code or in cases when ``asyncio.wait_for()`` is
-not suitable. Also it's much faster than ``asyncio.wait_for()``
-because ``timeout`` doesn't create a new task.
-
-The ``timeout(delay, *, loop=None)`` call returns a context manager
-that cancels a block on *timeout* expiring::
-
-   from async_timeout import timeout
-   async with timeout(1.5):
-       await inner()
-
-1. If ``inner()`` is executed faster than in ``1.5`` seconds nothing
-   happens.
-2. Otherwise ``inner()`` is cancelled internally by sending
-   ``asyncio.CancelledError`` into but ``asyncio.TimeoutError`` is
-   raised outside of context manager scope.
-
-*timeout* parameter could be ``None`` for skipping timeout functionality.
-
-
-Alternatively, ``timeout_at(when)`` can be used for scheduling
-at the absolute time::
-
-   loop = asyncio.get_event_loop()
-   now = loop.time()
-
-   async with timeout_at(now + 1.5):
-       await inner()
-
-
-Please note: it is not POSIX time but a time with
-undefined starting base, e.g. the time of the system power on.
-
-
-Context manager has ``.expired()`` / ``.expired`` for check if timeout happens
-exactly in context manager::
-
-   async with timeout(1.5) as cm:
-       await inner()
-   print(cm.expired())  # recommended api
-   print(cm.expired)    # compatible api
-
-The property is ``True`` if ``inner()`` execution is cancelled by
-timeout context manager.
-
-If ``inner()`` call explicitly raises ``TimeoutError`` ``cm.expired``
-is ``False``.
-
-The scheduled deadline time is available as ``.when()`` / ``.deadline``::
-
-   async with timeout(1.5) as cm:
-       cm.when()    # recommended api
-       cm.deadline  # compatible api
-
-Not finished yet timeout can be rescheduled by ``shift()``
-or ``update()`` methods::
-
-   async with timeout(1.5) as cm:
-       # recommended api
-       cm.reschedule(cm.when() + 1)  # add another second on waiting
-       # compatible api
-       cm.shift(1)  # add another second on waiting
-       cm.update(loop.time() + 5)  # reschedule to now+5 seconds
-
-Rescheduling is forbidden if the timeout is expired or after exit from ``async with``
-code block.
-
-
-Disable scheduled timeout::
-
-   async with timeout(1.5) as cm:
-       cm.reschedule(None)  # recommended api
-       cm.reject()          # compatible api
-
-
-
-Installation
-------------
-
-::
-
-   $ pip install async-timeout
-
-The library is Python 3 only!
-
-
-
-Authors and License
--------------------
-
-The module is written by Andrew Svetlov.
-
-It's *Apache 2* licensed and freely available.

package/venv/lib/python3.10/site-packages/async_timeout-5.0.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-async_timeout-5.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-async_timeout-5.0.1.dist-info/LICENSE,sha256=4Y17uPUT4sRrtYXJS1hb0wcg3TzLId2weG9y0WZY-Sw,568
-async_timeout-5.0.1.dist-info/METADATA,sha256=RVDNEIPYIBJKPsjThJDaKRX1h79-4QYQNuBLSXPItU8,5131
-async_timeout-5.0.1.dist-info/RECORD,,
-async_timeout-5.0.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-async_timeout-5.0.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-async_timeout-5.0.1.dist-info/top_level.txt,sha256=9oM4e7Twq8iD_7_Q3Mz0E6GPIB6vJvRFo-UBwUQtBDU,14
-async_timeout-5.0.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-async_timeout/__init__.py,sha256=QF0zpfX1vGmxib7kAqNPm9YehPV0oBVozxJ--Mxq9dI,9186
-async_timeout/__pycache__/__init__.cpython-310.pyc,,
-async_timeout/py.typed,sha256=tyozzRT1fziXETDxokmuyt6jhOmtjUbnVNJdZcG7ik0,12

package/venv/lib/python3.10/site-packages/async_timeout-5.0.1.dist-info/WHEEL

@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
-Root-Is-Purelib: true
-Tag: py3-none-any
-

package/venv/lib/python3.10/site-packages/async_timeout-5.0.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-async_timeout

package/venv/lib/python3.10/site-packages/async_timeout-5.0.1.dist-info/zip-safe

@@ -1 +0,0 @@
-

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

@@ -1,104 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Classes Without Boilerplate
-"""
-
-from functools import partial
-from typing import Callable, Literal, Protocol
-
-from . import converters, exceptions, filters, setters, validators
-from ._cmp import cmp_using
-from ._config import get_run_validators, set_run_validators
-from ._funcs import asdict, assoc, astuple, has, resolve_types
-from ._make import (
-    NOTHING,
-    Attribute,
-    Converter,
-    Factory,
-    _Nothing,
-    attrib,
-    attrs,
-    evolve,
-    fields,
-    fields_dict,
-    make_class,
-    validate,
-)
-from ._next_gen import define, field, frozen, mutable
-from ._version_info import VersionInfo
-
-
-s = attributes = attrs
-ib = attr = attrib
-dataclass = partial(attrs, auto_attribs=True)  # happy Easter ;)
-
-
-class AttrsInstance(Protocol):
-    pass
-
-
-NothingType = Literal[_Nothing.NOTHING]
-
-__all__ = [
-    "NOTHING",
-    "Attribute",
-    "AttrsInstance",
-    "Converter",
-    "Factory",
-    "NothingType",
-    "asdict",
-    "assoc",
-    "astuple",
-    "attr",
-    "attrib",
-    "attributes",
-    "attrs",
-    "cmp_using",
-    "converters",
-    "define",
-    "evolve",
-    "exceptions",
-    "field",
-    "fields",
-    "fields_dict",
-    "filters",
-    "frozen",
-    "get_run_validators",
-    "has",
-    "ib",
-    "make_class",
-    "mutable",
-    "resolve_types",
-    "s",
-    "set_run_validators",
-    "setters",
-    "validate",
-    "validators",
-]
-
-
-def _make_getattr(mod_name: str) -> Callable:
-    """
-    Create a metadata proxy for packaging information that uses *mod_name* in
-    its warnings and errors.
-    """
-
-    def __getattr__(name: str) -> str:
-        if name not in ("__version__", "__version_info__"):
-            msg = f"module {mod_name} has no attribute {name}"
-            raise AttributeError(msg)
-
-        from importlib.metadata import metadata
-
-        meta = metadata("attrs")
-
-        if name == "__version_info__":
-            return VersionInfo._from_version_string(meta["version"])
-
-        return meta["version"]
-
-    return __getattr__
-
-
-__getattr__ = _make_getattr(__name__)

package/venv/lib/python3.10/site-packages/attr/__init__.pyi

@@ -1,389 +0,0 @@
-import enum
-import sys
-
-from typing import (
-    Any,
-    Callable,
-    Generic,
-    Literal,
-    Mapping,
-    Protocol,
-    Sequence,
-    TypeVar,
-    overload,
-)
-
-# `import X as X` is required to make these public
-from . import converters as converters
-from . import exceptions as exceptions
-from . import filters as filters
-from . import setters as setters
-from . import validators as validators
-from ._cmp import cmp_using as cmp_using
-from ._typing_compat import AttrsInstance_
-from ._version_info import VersionInfo
-from attrs import (
-    define as define,
-    field as field,
-    mutable as mutable,
-    frozen as frozen,
-    _EqOrderType,
-    _ValidatorType,
-    _ConverterType,
-    _ReprArgType,
-    _OnSetAttrType,
-    _OnSetAttrArgType,
-    _FieldTransformer,
-    _ValidatorArgType,
-)
-
-if sys.version_info >= (3, 10):
-    from typing import TypeGuard, TypeAlias
-else:
-    from typing_extensions import TypeGuard, TypeAlias
-
-if sys.version_info >= (3, 11):
-    from typing import dataclass_transform
-else:
-    from typing_extensions import dataclass_transform
-
-__version__: str
-__version_info__: VersionInfo
-__title__: str
-__description__: str
-__url__: str
-__uri__: str
-__author__: str
-__email__: str
-__license__: str
-__copyright__: str
-
-_T = TypeVar("_T")
-_C = TypeVar("_C", bound=type)
-
-_FilterType = Callable[["Attribute[_T]", _T], bool]
-
-# We subclass this here to keep the protocol's qualified name clean.
-class AttrsInstance(AttrsInstance_, Protocol):
-    pass
-
-_A = TypeVar("_A", bound=type[AttrsInstance])
-
-class _Nothing(enum.Enum):
-    NOTHING = enum.auto()
-
-NOTHING = _Nothing.NOTHING
-NothingType: TypeAlias = Literal[_Nothing.NOTHING]
-
-# NOTE: Factory lies about its return type to make this possible:
-# `x: List[int] # = Factory(list)`
-# Work around mypy issue #4554 in the common case by using an overload.
-
-@overload
-def Factory(factory: Callable[[], _T]) -> _T: ...
-@overload
-def Factory(
-    factory: Callable[[Any], _T],
-    takes_self: Literal[True],
-) -> _T: ...
-@overload
-def Factory(
-    factory: Callable[[], _T],
-    takes_self: Literal[False],
-) -> _T: ...
-
-In = TypeVar("In")
-Out = TypeVar("Out")
-
-class Converter(Generic[In, Out]):
-    @overload
-    def __init__(self, converter: Callable[[In], Out]) -> None: ...
-    @overload
-    def __init__(
-        self,
-        converter: Callable[[In, AttrsInstance, Attribute], Out],
-        *,
-        takes_self: Literal[True],
-        takes_field: Literal[True],
-    ) -> None: ...
-    @overload
-    def __init__(
-        self,
-        converter: Callable[[In, Attribute], Out],
-        *,
-        takes_field: Literal[True],
-    ) -> None: ...
-    @overload
-    def __init__(
-        self,
-        converter: Callable[[In, AttrsInstance], Out],
-        *,
-        takes_self: Literal[True],
-    ) -> None: ...
-
-class Attribute(Generic[_T]):
-    name: str
-    default: _T | None
-    validator: _ValidatorType[_T] | None
-    repr: _ReprArgType
-    cmp: _EqOrderType
-    eq: _EqOrderType
-    order: _EqOrderType
-    hash: bool | None
-    init: bool
-    converter: Converter | None
-    metadata: dict[Any, Any]
-    type: type[_T] | None
-    kw_only: bool
-    on_setattr: _OnSetAttrType
-    alias: str | None
-
-    def evolve(self, **changes: Any) -> "Attribute[Any]": ...
-
-# NOTE: We had several choices for the annotation to use for type arg:
-# 1) Type[_T]
-#   - Pros: Handles simple cases correctly
-#   - Cons: Might produce less informative errors in the case of conflicting
-#     TypeVars e.g. `attr.ib(default='bad', type=int)`
-# 2) Callable[..., _T]
-#   - Pros: Better error messages than #1 for conflicting TypeVars
-#   - Cons: Terrible error messages for validator checks.
-#   e.g. attr.ib(type=int, validator=validate_str)
-#        -> error: Cannot infer function type argument
-# 3) type (and do all of the work in the mypy plugin)
-#   - Pros: Simple here, and we could customize the plugin with our own errors.
-#   - Cons: Would need to write mypy plugin code to handle all the cases.
-# We chose option #1.
-
-# `attr` lies about its return type to make the following possible:
-#     attr()    -> Any
-#     attr(8)   -> int
-#     attr(validator=<some callable>)  -> Whatever the callable expects.
-# This makes this type of assignments possible:
-#     x: int = attr(8)
-#
-# This form catches explicit None or no default but with no other arguments
-# returns Any.
-@overload
-def attrib(
-    default: None = ...,
-    validator: None = ...,
-    repr: _ReprArgType = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    type: None = ...,
-    converter: None = ...,
-    factory: None = ...,
-    kw_only: bool = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-) -> Any: ...
-
-# This form catches an explicit None or no default and infers the type from the
-# other arguments.
-@overload
-def attrib(
-    default: None = ...,
-    validator: _ValidatorArgType[_T] | None = ...,
-    repr: _ReprArgType = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    type: type[_T] | None = ...,
-    converter: _ConverterType
-    | list[_ConverterType]
-    | tuple[_ConverterType]
-    | None = ...,
-    factory: Callable[[], _T] | None = ...,
-    kw_only: bool = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-) -> _T: ...
-
-# This form catches an explicit default argument.
-@overload
-def attrib(
-    default: _T,
-    validator: _ValidatorArgType[_T] | None = ...,
-    repr: _ReprArgType = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    type: type[_T] | None = ...,
-    converter: _ConverterType
-    | list[_ConverterType]
-    | tuple[_ConverterType]
-    | None = ...,
-    factory: Callable[[], _T] | None = ...,
-    kw_only: bool = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-) -> _T: ...
-
-# This form covers type=non-Type: e.g. forward references (str), Any
-@overload
-def attrib(
-    default: _T | None = ...,
-    validator: _ValidatorArgType[_T] | None = ...,
-    repr: _ReprArgType = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    type: object = ...,
-    converter: _ConverterType
-    | list[_ConverterType]
-    | tuple[_ConverterType]
-    | None = ...,
-    factory: Callable[[], _T] | None = ...,
-    kw_only: bool = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-) -> Any: ...
-@overload
-@dataclass_transform(order_default=True, field_specifiers=(attrib, field))
-def attrs(
-    maybe_cls: _C,
-    these: dict[str, Any] | None = ...,
-    repr_ns: str | None = ...,
-    repr: bool = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    auto_detect: bool = ...,
-    collect_by_mro: bool = ...,
-    getstate_setstate: bool | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: _FieldTransformer | None = ...,
-    match_args: bool = ...,
-    unsafe_hash: bool | None = ...,
-) -> _C: ...
-@overload
-@dataclass_transform(order_default=True, field_specifiers=(attrib, field))
-def attrs(
-    maybe_cls: None = ...,
-    these: dict[str, Any] | None = ...,
-    repr_ns: str | None = ...,
-    repr: bool = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    auto_detect: bool = ...,
-    collect_by_mro: bool = ...,
-    getstate_setstate: bool | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: _FieldTransformer | None = ...,
-    match_args: bool = ...,
-    unsafe_hash: bool | None = ...,
-) -> Callable[[_C], _C]: ...
-def fields(cls: type[AttrsInstance]) -> Any: ...
-def fields_dict(cls: type[AttrsInstance]) -> dict[str, Attribute[Any]]: ...
-def validate(inst: AttrsInstance) -> None: ...
-def resolve_types(
-    cls: _A,
-    globalns: dict[str, Any] | None = ...,
-    localns: dict[str, Any] | None = ...,
-    attribs: list[Attribute[Any]] | None = ...,
-    include_extras: bool = ...,
-) -> _A: ...
-
-# TODO: add support for returning a proper attrs class from the mypy plugin
-# we use Any instead of _CountingAttr so that e.g. `make_class('Foo',
-# [attr.ib()])` is valid
-def make_class(
-    name: str,
-    attrs: list[str] | tuple[str, ...] | dict[str, Any],
-    bases: tuple[type, ...] = ...,
-    class_body: dict[str, Any] | None = ...,
-    repr_ns: str | None = ...,
-    repr: bool = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    collect_by_mro: bool = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: _FieldTransformer | None = ...,
-) -> type: ...
-
-# _funcs --
-
-# TODO: add support for returning TypedDict from the mypy plugin
-# FIXME: asdict/astuple do not honor their factory args. Waiting on one of
-# these:
-# https://github.com/python/mypy/issues/4236
-# https://github.com/python/typing/issues/253
-# XXX: remember to fix attrs.asdict/astuple too!
-def asdict(
-    inst: AttrsInstance,
-    recurse: bool = ...,
-    filter: _FilterType[Any] | None = ...,
-    dict_factory: type[Mapping[Any, Any]] = ...,
-    retain_collection_types: bool = ...,
-    value_serializer: Callable[[type, Attribute[Any], Any], Any] | None = ...,
-    tuple_keys: bool | None = ...,
-) -> dict[str, Any]: ...
-
-# TODO: add support for returning NamedTuple from the mypy plugin
-def astuple(
-    inst: AttrsInstance,
-    recurse: bool = ...,
-    filter: _FilterType[Any] | None = ...,
-    tuple_factory: type[Sequence[Any]] = ...,
-    retain_collection_types: bool = ...,
-) -> tuple[Any, ...]: ...
-def has(cls: type) -> TypeGuard[type[AttrsInstance]]: ...
-def assoc(inst: _T, **changes: Any) -> _T: ...
-def evolve(inst: _T, **changes: Any) -> _T: ...
-
-# _config --
-
-def set_run_validators(run: bool) -> None: ...
-def get_run_validators() -> bool: ...
-
-# aliases --
-
-s = attributes = attrs
-ib = attr = attrib
-dataclass = attrs  # Technically, partial(attrs, auto_attribs=True) ;)