Add files using upload-large-folder tool

.gitattributes

@@ -456,3 +456,6 @@ material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:
 material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/matplotlib/axes/__pycache__/_base.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Output/1908274/1908275.tif filter=lfs diff=lfs merge=lfs -text
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Input/1908306/1908307.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/matplotlib/axes/__pycache__/_axes.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-Oblique.ttf filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908256_m.tif filter=lfs diff=lfs merge=lfs -text

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/debug.py

@@ -0,0 +1,132 @@
+import os
+import time
+from contextlib import contextmanager
+from typing import Callable, Optional
+
+_inited = False
+
+
+def _lazy_colorama_init():
+    """
+    Lazily init colorama if necessary, not to screw up stdout if debugging is
+    not enabled.
+
+    This version of the function does nothing.
+    """
+
+
+try:
+    if os.name == 'nt':
+        # Does not work on Windows, as pyreadline and colorama interfere
+        raise ImportError
+    else:
+        # Use colorama for nicer console output.
+        from colorama import Fore, init  # type: ignore[import]
+        from colorama import initialise
+
+        def _lazy_colorama_init():  # noqa: F811
+            """
+            Lazily init colorama if necessary, not to screw up stdout is
+            debug not enabled.
+
+            This version of the function does init colorama.
+            """
+            global _inited
+            if not _inited:
+                # pytest resets the stream at the end - causes troubles. Since
+                # after every output the stream is reset automatically we don't
+                # need this.
+                initialise.atexit_done = True
+                try:
+                    init(strip=False)
+                except Exception:
+                    # Colorama fails with initializing under vim and is buggy in
+                    # version 0.3.6.
+                    pass
+            _inited = True
+
+except ImportError:
+    class Fore:  # type: ignore[no-redef]
+        RED = ''
+        GREEN = ''
+        YELLOW = ''
+        MAGENTA = ''
+        RESET = ''
+        BLUE = ''
+
+NOTICE = object()
+WARNING = object()
+SPEED = object()
+
+enable_speed = False
+enable_warning = False
+enable_notice = False
+
+# callback, interface: level, str
+debug_function: Optional[Callable[[str, str], None]] = None
+_debug_indent = 0
+_start_time = time.time()
+
+
+def reset_time():
+    global _start_time, _debug_indent
+    _start_time = time.time()
+    _debug_indent = 0
+
+
+def increase_indent(func):
+    """Decorator for makin """
+    def wrapper(*args, **kwargs):
+        with increase_indent_cm():
+            return func(*args, **kwargs)
+    return wrapper
+
+
+@contextmanager
+def increase_indent_cm(title=None, color='MAGENTA'):
+    global _debug_indent
+    if title:
+        dbg('Start: ' + title, color=color)
+    _debug_indent += 1
+    try:
+        yield
+    finally:
+        _debug_indent -= 1
+        if title:
+            dbg('End: ' + title, color=color)
+
+
+def dbg(message, *args, color='GREEN'):
+    """ Looks at the stack, to see if a debug message should be printed. """
+    assert color
+
+    if debug_function and enable_notice:
+        i = ' ' * _debug_indent
+        _lazy_colorama_init()
+        debug_function(color, i + 'dbg: ' + message % tuple(repr(a) for a in args))
+
+
+def warning(message, *args, format=True):
+    if debug_function and enable_warning:
+        i = ' ' * _debug_indent
+        if format:
+            message = message % tuple(repr(a) for a in args)
+        debug_function('RED', i + 'warning: ' + message)
+
+
+def speed(name):
+    if debug_function and enable_speed:
+        now = time.time()
+        i = ' ' * _debug_indent
+        debug_function('YELLOW', i + 'speed: ' + '%s %s' % (name, now - _start_time))
+
+
+def print_to_stdout(color, str_out):
+    """
+    The default debug function that prints to standard out.
+
+    :param str color: A string that is an attribute of ``colorama.Fore``.
+    """
+    col = getattr(Fore, color)
+    _lazy_colorama_init()
+    print(col + str_out + Fore.RESET)

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/attr/__init__.pyi

@@ -0,0 +1,257 @@
+from typing import Any, Callable, Dict, Generic, List, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union, overload
+
+# `import X as X` is required to make these public
+from . import converters as converters, exceptions as exceptions, filters as filters, validators as validators
+from ._version_info import VersionInfo
+
+__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)
+
+_ValidatorType = Callable[[Any, Attribute[_T], _T], Any]
+_ConverterType = Callable[[Any], _T]
+_FilterType = Callable[[Attribute[_T], _T], bool]
+_ReprType = Callable[[Any], str]
+_ReprArgType = Union[bool, _ReprType]
+# FIXME: in reality, if multiple validators are passed they must be in a list or tuple,
+# but those are invariant and so would prevent subtypes of _ValidatorType from working
+# when passed in a list or tuple.
+_ValidatorArgType = Union[_ValidatorType[_T], Sequence[_ValidatorType[_T]]]
+
+# _make --
+
+NOTHING: object
+
+# 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: Union[Callable[[Any], _T], Callable[[], _T]], takes_self: bool = ...) -> _T: ...
+
+class Attribute(Generic[_T]):
+    name: str
+    default: Optional[_T]
+    validator: Optional[_ValidatorType[_T]]
+    repr: _ReprArgType
+    cmp: bool
+    eq: bool
+    order: bool
+    hash: Optional[bool]
+    init: bool
+    converter: Optional[_ConverterType[_T]]
+    metadata: Dict[Any, Any]
+    type: Optional[Type[_T]]
+    kw_only: bool
+
+# 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: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: None = ...,
+    converter: None = ...,
+    factory: None = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+) -> Any: ...
+
+# This form catches an explicit None or no default and infers the type from the other arguments.
+@overload
+def attrib(
+    default: None = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: Optional[Type[_T]] = ...,
+    converter: Optional[_ConverterType[_T]] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+) -> _T: ...
+
+# This form catches an explicit default argument.
+@overload
+def attrib(
+    default: _T,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: Optional[Type[_T]] = ...,
+    converter: Optional[_ConverterType[_T]] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+) -> _T: ...
+
+# This form covers type=non-Type: e.g. forward references (str), Any
+@overload
+def attrib(
+    default: Optional[_T] = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: object = ...,
+    converter: Optional[_ConverterType[_T]] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+) -> Any: ...
+@overload
+def attrs(
+    maybe_cls: _C,
+    these: Optional[Dict[str, Any]] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+) -> _C: ...
+@overload
+def attrs(
+    maybe_cls: None = ...,
+    these: Optional[Dict[str, Any]] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+) -> Callable[[_C], _C]: ...
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+class _Fields(Tuple[Attribute[Any], ...]):
+    def __getattr__(self, name: str) -> Attribute[Any]: ...
+
+def fields(cls: type) -> _Fields: ...
+def fields_dict(cls: type) -> Dict[str, Attribute[Any]]: ...
+def validate(inst: Any) -> None: ...
+
+# 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: Union[List[str], Tuple[str, ...], Dict[str, Any]],
+    bases: Tuple[type, ...] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[bool] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+) -> 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
+def asdict(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType[Any]] = ...,
+    dict_factory: Type[Mapping[Any, Any]] = ...,
+    retain_collection_types: bool = ...,
+) -> Dict[str, Any]: ...
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+def astuple(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType[Any]] = ...,
+    tuple_factory: Type[Sequence[Any]] = ...,
+    retain_collection_types: bool = ...,
+) -> Tuple[Any, ...]: ...
+def has(cls: type) -> bool: ...
+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) ;)

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/attr/_version_info.pyi

@@ -0,0 +1,9 @@
+class VersionInfo:
+    @property
+    def year(self) -> int: ...
+    @property
+    def minor(self) -> int: ...
+    @property
+    def micro(self) -> int: ...
+    @property
+    def releaselevel(self) -> str: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/attr/converters.pyi

@@ -0,0 +1,11 @@
+from typing import Callable, Optional, TypeVar, overload
+
+from . import _ConverterType
+
+_T = TypeVar("_T")
+
+def optional(converter: _ConverterType[_T]) -> _ConverterType[Optional[_T]]: ...
+@overload
+def default_if_none(default: _T) -> _ConverterType[_T]: ...
+@overload
+def default_if_none(*, factory: Callable[[], _T]) -> _ConverterType[_T]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/attr/exceptions.pyi

@@ -0,0 +1,15 @@
+from typing import Any
+
+class FrozenInstanceError(AttributeError):
+    msg: str = ...
+
+class AttrsAttributeNotFoundError(ValueError): ...
+class NotAnAttrsClassError(ValueError): ...
+class DefaultAlreadySetError(RuntimeError): ...
+class UnannotatedAttributeError(RuntimeError): ...
+class PythonTooOldError(RuntimeError): ...
+
+class NotCallableError(TypeError):
+    msg: str = ...
+    value: Any = ...
+    def __init__(self, msg: str, value: Any) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/attr/filters.pyi

@@ -0,0 +1,6 @@
+from typing import Any, Union
+
+from . import Attribute, _FilterType
+
+def include(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...
+def exclude(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/attr/validators.pyi

@@ -0,0 +1,54 @@
+from typing import (
+    Any,
+    AnyStr,
+    Callable,
+    Container,
+    Iterable,
+    List,
+    Mapping,
+    Match,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from . import _ValidatorType
+
+_T = TypeVar("_T")
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_T3 = TypeVar("_T3")
+_I = TypeVar("_I", bound=Iterable)
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+_M = TypeVar("_M", bound=Mapping)
+
+# To be more precise on instance_of use some overloads.
+# If there are more than 3 items in the tuple then we fall back to Any
+@overload
+def instance_of(type: Type[_T]) -> _ValidatorType[_T]: ...
+@overload
+def instance_of(type: Tuple[Type[_T]]) -> _ValidatorType[_T]: ...
+@overload
+def instance_of(type: Tuple[Type[_T1], Type[_T2]]) -> _ValidatorType[Union[_T1, _T2]]: ...
+@overload
+def instance_of(type: Tuple[Type[_T1], Type[_T2], Type[_T3]]) -> _ValidatorType[Union[_T1, _T2, _T3]]: ...
+@overload
+def instance_of(type: Tuple[type, ...]) -> _ValidatorType[Any]: ...
+def provides(interface: Any) -> _ValidatorType[Any]: ...
+def optional(validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]]) -> _ValidatorType[Optional[_T]]: ...
+def in_(options: Container[_T]) -> _ValidatorType[_T]: ...
+def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ...
+def matches_re(
+    regex: AnyStr, flags: int = ..., func: Optional[Callable[[AnyStr, AnyStr, int], Optional[Match[AnyStr]]]] = ...
+) -> _ValidatorType[AnyStr]: ...
+def deep_iterable(
+    member_validator: _ValidatorType[_T], iterable_validator: Optional[_ValidatorType[_I]] = ...
+) -> _ValidatorType[_I]: ...
+def deep_mapping(
+    key_validator: _ValidatorType[_K], value_validator: _ValidatorType[_V], mapping_validator: Optional[_ValidatorType[_M]] = ...
+) -> _ValidatorType[_M]: ...
+def is_callable() -> _ValidatorType[_T]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cachetools/abc.pyi

@@ -0,0 +1,7 @@
+from abc import ABCMeta
+from typing import MutableMapping, TypeVar
+
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+
+class DefaultMapping(MutableMapping[_KT, _VT], metaclass=ABCMeta): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cachetools/func.pyi

@@ -0,0 +1,11 @@
+from typing import Any, Callable, Optional, Sequence, TypeVar
+
+_T = TypeVar("_T")
+
+_F = TypeVar("_F", bound=Callable[..., Any])
+_RET = Callable[[_F], _F]
+
+def lfu_cache(maxsize: int = ..., typed: bool = ...) -> _RET: ...
+def lru_cache(maxsize: int = ..., typed: bool = ...) -> _RET: ...
+def rr_cache(maxsize: int = ..., choice: Optional[Callable[[Sequence[_T]], _T]] = ..., typed: bool = ...) -> _RET: ...
+def ttl_cache(maxsize: int = ..., ttl: float = ..., timer: float = ..., typed: bool = ...) -> _RET: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cachetools/rr.pyi

@@ -0,0 +1,21 @@
+from typing import Callable, Iterator, Optional, Sequence, TypeVar
+
+from .cache import Cache as Cache
+
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+
+class RRCache(Cache[_KT, _VT]):
+    def __init__(
+        self,
+        maxsize: int,
+        choice: Optional[Callable[[Sequence[_KT]], _KT]] = ...,
+        getsizeof: Optional[Callable[[_VT], int]] = ...,
+    ) -> None: ...
+    def __getitem__(self, key: _KT) -> _VT: ...
+    def __setitem__(self, key: _KT, value: _VT) -> None: ...
+    def __delitem__(self, key: _KT) -> None: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def __len__(self) -> int: ...
+    @property
+    def choice(self) -> Callable[[Sequence[_KT]], _KT]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cachetools/ttl.pyi

@@ -0,0 +1,23 @@
+from typing import Callable, Iterator, Optional, TypeVar
+
+from .cache import Cache
+
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+
+class TTLCache(Cache[_KT, _VT]):
+    def __init__(
+        self, maxsize: int, ttl: float, timer: Callable[[], float] = ..., getsizeof: Optional[Callable[[_VT], int]] = ...
+    ) -> None: ...
+    def __getitem__(self, key: _KT, cache_getitem: Callable[[_KT], _VT] = ...) -> _VT: ...
+    def __setitem__(self, key: _KT, value: _VT, cache_setitem: Callable[[_KT, _VT], None] = ...) -> None: ...
+    def __delitem__(self, key: _KT, cache_delitem: Callable[[_KT], None] = ...) -> None: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def __len__(self) -> int: ...
+    @property
+    def currsize(self) -> int: ...
+    @property
+    def timer(self) -> Callable[[], float]: ...
+    @property
+    def ttl(self) -> float: ...
+    def expire(self, time: Optional[Callable[[], float]] = ...) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/chardet/langgreekmodel.pyi

@@ -0,0 +1,9 @@
+from typing import Tuple
+
+from . import _LangModelType
+
+Latin7_char_to_order_map: Tuple[int, ...]
+win1253_char_to_order_map: Tuple[int, ...]
+GreekLangModel: Tuple[int, ...]
+Latin7GreekModel: _LangModelType
+Win1253GreekModel: _LangModelType

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/chardet/langturkishmodel.pyi

@@ -0,0 +1,7 @@
+from typing import Tuple
+
+from . import _LangModelType
+
+Latin5_TurkishCharToOrderMap: Tuple[int, ...]
+TurkishLangModel: Tuple[int, ...]
+Latin5TurkishModel: _LangModelType

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/chardet/version.pyi

@@ -0,0 +1,4 @@
+from typing import List
+
+__version__: str
+VERSION: List[str]

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/exceptions.pyi

@@ -0,0 +1,7 @@
+class AlreadyFinalized(Exception): ...
+class AlreadyUpdated(Exception): ...
+class InvalidKey(Exception): ...
+class InvalidSignature(Exception): ...
+class InvalidTag(Exception): ...
+class NotYetFinalized(Exception): ...
+class UnsupportedAlgorithm(Exception): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/fernet.pyi

@@ -0,0 +1,25 @@
+from typing import List, Optional, Text, Union
+
+class InvalidToken(Exception): ...
+
+class Fernet(object):
+    def __init__(self, key: Union[bytes, Text]) -> None: ...
+    def decrypt(self, token: bytes, ttl: Optional[int] = ...) -> bytes: ...
+    # decrypt_at_time accepts None ttl at runtime but it's an implementtion detail and it doesn't really
+    # make sense for the client code to use it like that, so the parameter is typed as int as opposed to
+    # Optional[int].
+    def decrypt_at_time(self, token: bytes, ttl: int, current_time: int) -> bytes: ...
+    def encrypt(self, data: bytes) -> bytes: ...
+    def encrypt_at_time(self, data: bytes, current_time: int) -> bytes: ...
+    def extract_timestamp(self, token: bytes) -> int: ...
+    @classmethod
+    def generate_key(cls) -> bytes: ...
+
+class MultiFernet(object):
+    def __init__(self, fernets: List[Fernet]) -> None: ...
+    def decrypt(self, token: bytes, ttl: Optional[int] = ...) -> bytes: ...
+    # See a note above on the typing of the ttl parameter.
+    def decrypt_at_time(self, token: bytes, ttl: int, current_time: int) -> bytes: ...
+    def encrypt(self, data: bytes) -> bytes: ...
+    def encrypt_at_time(self, data: bytes, current_time: int) -> bytes: ...
+    def rotate(self, msg: bytes) -> bytes: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/__init__.pyi

@@ -0,0 +1,3 @@
+from typing import Any
+
+def __getattr__(name: str) -> Any: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/__init__.pyi

@@ -0,0 +1,3 @@
+from typing import Any
+
+def __getattr__(name: str) -> Any: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/__init__.pyi

@@ -0,0 +1,3 @@
+from typing import Any
+
+def __getattr__(name: str) -> Any: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/dh.pyi

@@ -0,0 +1,79 @@
+from abc import ABCMeta, abstractmethod
+from typing import Optional
+
+from cryptography.hazmat.backends.interfaces import DHBackend
+from cryptography.hazmat.primitives.serialization import (
+    Encoding,
+    KeySerializationEncryption,
+    ParameterFormat,
+    PrivateFormat,
+    PublicFormat,
+)
+
+class DHParameters(metaclass=ABCMeta):
+    @abstractmethod
+    def generate_private_key(self) -> DHPrivateKey: ...
+    @abstractmethod
+    def parameter_bytes(self, encoding: Encoding, format: ParameterFormat) -> bytes: ...
+    @abstractmethod
+    def parameter_numbers(self) -> DHParameterNumbers: ...
+
+DHParametersWithSerialization = DHParameters
+
+class DHParameterNumbers(object):
+    @property
+    def p(self) -> int: ...
+    @property
+    def g(self) -> int: ...
+    @property
+    def q(self) -> int: ...
+    def __init__(self, p: int, g: int, q: Optional[int]) -> None: ...
+    def parameters(self, backend: Optional[DHBackend] = ...) -> DHParameters: ...
+
+class DHPrivateKey(metaclass=ABCMeta):
+    key_size: int
+    @abstractmethod
+    def exchange(self, peer_public_key: DHPublicKey) -> bytes: ...
+    @abstractmethod
+    def parameters(self) -> DHParameters: ...
+    @abstractmethod
+    def public_key(self) -> DHPublicKey: ...
+
+class DHPrivateKeyWithSerialization(DHPrivateKey):
+    @abstractmethod
+    def private_bytes(
+        self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption
+    ) -> bytes: ...
+    @abstractmethod
+    def private_numbers(self) -> DHPrivateNumbers: ...
+
+class DHPrivateNumbers(object):
+    @property
+    def public_numbers(self) -> DHPublicNumbers: ...
+    @property
+    def x(self) -> int: ...
+    def __init__(self, x: int, public_numbers: DHPublicNumbers) -> None: ...
+    def private_key(self, backend: Optional[DHBackend] = ...) -> DHPrivateKey: ...
+
+class DHPublicKey(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def key_size(self) -> int: ...
+    @abstractmethod
+    def parameters(self) -> DHParameters: ...
+    @abstractmethod
+    def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ...
+    @abstractmethod
+    def public_numbers(self) -> DHPublicNumbers: ...
+
+DHPublicKeyWithSerialization = DHPublicKey
+
+class DHPublicNumbers(object):
+    @property
+    def parameter_numbers(self) -> DHParameterNumbers: ...
+    @property
+    def y(self) -> int: ...
+    def __init__(self, y: int, parameter_numbers: DHParameterNumbers) -> None: ...
+    def public_key(self, backend: Optional[DHBackend] = ...) -> DHPublicKey: ...
+
+def generate_parameters(generator: int, key_size: int, backend: Optional[DHBackend] = ...) -> DHParameters: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/dsa.pyi

@@ -0,0 +1,79 @@
+from abc import ABCMeta, abstractmethod
+from typing import Optional, Union
+
+from cryptography.hazmat.backends.interfaces import DSABackend
+from cryptography.hazmat.primitives.asymmetric import AsymmetricVerificationContext
+from cryptography.hazmat.primitives.asymmetric.utils import Prehashed
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat
+
+class DSAParameters(metaclass=ABCMeta):
+    @abstractmethod
+    def generate_private_key(self) -> DSAPrivateKey: ...
+
+class DSAParametersWithNumbers(DSAParameters):
+    @abstractmethod
+    def parameter_numbers(self) -> DSAParameterNumbers: ...
+
+class DSAParameterNumbers(object):
+    @property
+    def p(self) -> int: ...
+    @property
+    def q(self) -> int: ...
+    @property
+    def g(self) -> int: ...
+    def __init__(self, p: int, q: int, g: int) -> None: ...
+    def parameters(self, backend: Optional[DSABackend] = ...) -> DSAParameters: ...
+
+class DSAPrivateKey(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def key_size(self) -> int: ...
+    @abstractmethod
+    def parameters(self) -> DSAParameters: ...
+    @abstractmethod
+    def public_key(self) -> DSAPublicKey: ...
+    @abstractmethod
+    def sign(self, data: bytes, algorithm: Union[HashAlgorithm, Prehashed]) -> bytes: ...
+
+class DSAPrivateKeyWithSerialization(DSAPrivateKey):
+    @abstractmethod
+    def private_bytes(
+        self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption
+    ) -> bytes: ...
+    @abstractmethod
+    def private_numbers(self) -> DSAPrivateNumbers: ...
+
+class DSAPrivateNumbers(object):
+    @property
+    def x(self) -> int: ...
+    @property
+    def public_numbers(self) -> DSAPublicNumbers: ...
+    def __init__(self, x: int, public_numbers: DSAPublicNumbers) -> None: ...
+
+class DSAPublicKey(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def key_size(self) -> int: ...
+    @abstractmethod
+    def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ...
+    @abstractmethod
+    def public_numbers(self) -> DSAPublicNumbers: ...
+    @abstractmethod
+    def verifier(
+        self, signature: bytes, signature_algorithm: Union[HashAlgorithm, Prehashed]
+    ) -> AsymmetricVerificationContext: ...
+    @abstractmethod
+    def verify(self, signature: bytes, data: bytes, algorithm: Union[HashAlgorithm, Prehashed]) -> None: ...
+
+DSAPublicKeyWithSerialization = DSAPublicKey
+
+class DSAPublicNumbers(object):
+    @property
+    def y(self) -> int: ...
+    @property
+    def parameter_numbers(self) -> DSAParameterNumbers: ...
+    def __init__(self, y: int, parameter_numbers: DSAParameterNumbers) -> None: ...
+
+def generate_parameters(key_size: int, backend: Optional[DSABackend] = ...) -> DSAParameters: ...
+def generate_private_key(key_size: int, backend: Optional[DSABackend] = ...) -> DSAPrivateKey: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ec.pyi

@@ -0,0 +1,196 @@
+from abc import ABCMeta, abstractmethod
+from typing import ClassVar, Optional, Union
+
+from cryptography.hazmat.backends.interfaces import EllipticCurveBackend
+from cryptography.hazmat.primitives.asymmetric import AsymmetricVerificationContext
+from cryptography.hazmat.primitives.asymmetric.utils import Prehashed
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat
+from cryptography.x509 import ObjectIdentifier
+
+class EllipticCurve(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def key_size(self) -> int: ...
+    @property
+    @abstractmethod
+    def name(self) -> str: ...
+
+class BrainpoolP256R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class BrainpoolP384R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class BrainpoolP512R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECP192R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECP224R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECP256K1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECP256R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECP384R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECP521R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECT163K1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECT163R2(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECT233K1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECT233R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECT283K1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECT283R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECT409K1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECT409R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECT571K1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class SECT571R1(EllipticCurve):
+    key_size: int = ...
+    name: str = ...
+
+class EllipticCurveOID(object):
+    SECP192R1: ClassVar[ObjectIdentifier]
+    SECP224R1: ClassVar[ObjectIdentifier]
+    SECP256K1: ClassVar[ObjectIdentifier]
+    SECP256R1: ClassVar[ObjectIdentifier]
+    SECP384R1: ClassVar[ObjectIdentifier]
+    SECP521R1: ClassVar[ObjectIdentifier]
+    BRAINPOOLP256R1: ClassVar[ObjectIdentifier]
+    BRAINPOOLP384R1: ClassVar[ObjectIdentifier]
+    BRAINPOOLP512R1: ClassVar[ObjectIdentifier]
+    SECT163K1: ClassVar[ObjectIdentifier]
+    SECT163R2: ClassVar[ObjectIdentifier]
+    SECT233K1: ClassVar[ObjectIdentifier]
+    SECT233R1: ClassVar[ObjectIdentifier]
+    SECT283K1: ClassVar[ObjectIdentifier]
+    SECT283R1: ClassVar[ObjectIdentifier]
+    SECT409K1: ClassVar[ObjectIdentifier]
+    SECT409R1: ClassVar[ObjectIdentifier]
+    SECT571K1: ClassVar[ObjectIdentifier]
+    SECT571R1: ClassVar[ObjectIdentifier]
+
+class EllipticCurvePrivateKey(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def curve(self) -> EllipticCurve: ...
+    @property
+    @abstractmethod
+    def key_size(self) -> int: ...
+    @abstractmethod
+    def exchange(self, algorithm: ECDH, peer_public_key: EllipticCurvePublicKey) -> bytes: ...
+    @abstractmethod
+    def public_key(self) -> EllipticCurvePublicKey: ...
+    @abstractmethod
+    def sign(self, data: bytes, signature_algorithm: EllipticCurveSignatureAlgorithm) -> bytes: ...
+
+class EllipticCurvePrivateKeyWithSerialization(EllipticCurvePrivateKey):
+    @abstractmethod
+    def private_bytes(
+        self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption
+    ) -> bytes: ...
+    @abstractmethod
+    def private_numbers(self) -> EllipticCurvePrivateNumbers: ...
+
+class EllipticCurvePrivateNumbers(object):
+    @property
+    def private_value(self) -> int: ...
+    @property
+    def public_numbers(self) -> EllipticCurvePublicNumbers: ...
+    def __init__(self, private_value: int, public_numbers: EllipticCurvePublicNumbers) -> None: ...
+    def private_key(self, backend: Optional[EllipticCurveBackend] = ...) -> EllipticCurvePrivateKey: ...
+
+class EllipticCurvePublicKey(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def curve(self) -> EllipticCurve: ...
+    @property
+    @abstractmethod
+    def key_size(self) -> int: ...
+    @classmethod
+    def from_encoded_point(cls, curve: EllipticCurve, data: bytes) -> EllipticCurvePublicKey: ...
+    @abstractmethod
+    def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ...
+    @abstractmethod
+    def public_numbers(self) -> EllipticCurvePublicNumbers: ...
+    @abstractmethod
+    def verifier(
+        self, signature: bytes, signature_algorithm: EllipticCurveSignatureAlgorithm
+    ) -> AsymmetricVerificationContext: ...
+    @abstractmethod
+    def verify(self, signature: bytes, data: bytes, signature_algorithm: EllipticCurveSignatureAlgorithm) -> None: ...
+
+EllipticCurvePublicKeyWithSerialization = EllipticCurvePublicKey
+
+class EllipticCurvePublicNumbers(object):
+    @property
+    def curve(self) -> EllipticCurve: ...
+    @property
+    def x(self) -> int: ...
+    @property
+    def y(self) -> int: ...
+    def __init__(self, x: int, y: int, curve: EllipticCurve) -> None: ...
+    @classmethod
+    def from_encoded_point(cls, curve: EllipticCurve, data: bytes) -> EllipticCurvePublicNumbers: ...
+    def public_key(self, backend: Optional[EllipticCurveBackend] = ...) -> EllipticCurvePublicKey: ...
+
+class EllipticCurveSignatureAlgorithm(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def algorithm(self) -> Union[HashAlgorithm, Prehashed]: ...
+
+class ECDH(object): ...
+
+class ECDSA(EllipticCurveSignatureAlgorithm):
+    def __init__(self, algorithm: Union[HashAlgorithm, Prehashed]): ...
+    @property
+    def algorithm(self) -> Union[HashAlgorithm, Prehashed]: ...
+
+def derive_private_key(
+    private_value: int, curve: EllipticCurve, backend: Optional[EllipticCurveBackend] = ...
+) -> EllipticCurvePrivateKey: ...
+def generate_private_key(curve: EllipticCurve, backend: Optional[EllipticCurveBackend] = ...) -> EllipticCurvePrivateKey: ...
+def get_curve_for_oid(oid: ObjectIdentifier) -> EllipticCurve: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ed25519.pyi

@@ -0,0 +1,25 @@
+from abc import ABCMeta, abstractmethod
+
+from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat
+
+class Ed25519PrivateKey(metaclass=ABCMeta):
+    @classmethod
+    def generate(cls) -> Ed25519PrivateKey: ...
+    @classmethod
+    def from_private_bytes(cls, data: bytes) -> Ed25519PrivateKey: ...
+    @abstractmethod
+    def private_bytes(
+        self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption
+    ) -> bytes: ...
+    @abstractmethod
+    def public_key(self) -> Ed25519PublicKey: ...
+    @abstractmethod
+    def sign(self, data: bytes) -> bytes: ...
+
+class Ed25519PublicKey(metaclass=ABCMeta):
+    @classmethod
+    def from_public_bytes(cls, data: bytes) -> Ed25519PublicKey: ...
+    @abstractmethod
+    def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ...
+    @abstractmethod
+    def verify(self, signature: bytes, data: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ed448.pyi

@@ -0,0 +1,25 @@
+from abc import ABCMeta, abstractmethod
+
+from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat
+
+class Ed448PrivateKey(metaclass=ABCMeta):
+    @classmethod
+    def generate(cls) -> Ed448PrivateKey: ...
+    @classmethod
+    def from_private_bytes(cls, data: bytes) -> Ed448PrivateKey: ...
+    @abstractmethod
+    def private_bytes(
+        self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption
+    ) -> bytes: ...
+    @abstractmethod
+    def public_key(self) -> Ed448PublicKey: ...
+    @abstractmethod
+    def sign(self, data: bytes) -> bytes: ...
+
+class Ed448PublicKey(metaclass=ABCMeta):
+    @classmethod
+    def from_public_bytes(cls, data: bytes) -> Ed448PublicKey: ...
+    @abstractmethod
+    def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ...
+    @abstractmethod
+    def verify(self, signature: bytes, data: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/padding.pyi

@@ -0,0 +1,27 @@
+from abc import ABCMeta, abstractmethod
+from typing import ClassVar, Optional, Union
+
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+
+class AsymmetricPadding(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def name(self) -> str: ...
+
+class MGF1(object):
+    def __init__(self, algorithm: HashAlgorithm) -> None: ...
+
+class OAEP(AsymmetricPadding):
+    def __init__(self, mgf: MGF1, algorithm: HashAlgorithm, label: Optional[bytes]) -> None: ...
+    @property
+    def name(self) -> str: ...
+
+class PKCS1v15(AsymmetricPadding):
+    @property
+    def name(self) -> str: ...
+
+class PSS(AsymmetricPadding):
+    MAX_LENGTH: ClassVar[object]
+    def __init__(self, mgf: MGF1, salt_length: Union[int, object]) -> None: ...
+    @property
+    def name(self) -> str: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/rsa.pyi

@@ -0,0 +1,83 @@
+from abc import ABCMeta, abstractmethod
+from typing import Optional, Tuple, Union
+
+from cryptography.hazmat.backends.interfaces import RSABackend
+from cryptography.hazmat.primitives.asymmetric import AsymmetricVerificationContext
+from cryptography.hazmat.primitives.asymmetric.padding import AsymmetricPadding
+from cryptography.hazmat.primitives.asymmetric.utils import Prehashed
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat
+
+class RSAPrivateKey(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def key_size(self) -> int: ...
+    @abstractmethod
+    def decrypt(self, ciphertext: bytes, padding: AsymmetricPadding) -> bytes: ...
+    @abstractmethod
+    def public_key(self) -> RSAPublicKey: ...
+    @abstractmethod
+    def sign(self, data: bytes, padding: AsymmetricPadding, algorithm: Union[HashAlgorithm, Prehashed]) -> bytes: ...
+
+class RSAPrivateKeyWithSerialization(RSAPrivateKey):
+    @abstractmethod
+    def private_bytes(
+        self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption
+    ) -> bytes: ...
+    @abstractmethod
+    def private_numbers(self) -> RSAPrivateNumbers: ...
+
+class RSAPublicKey(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def key_size(self) -> int: ...
+    @abstractmethod
+    def encrypt(self, plaintext: bytes, padding: AsymmetricPadding) -> bytes: ...
+    @abstractmethod
+    def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ...
+    @abstractmethod
+    def public_numbers(self) -> RSAPublicNumbers: ...
+    @abstractmethod
+    def verifier(
+        self, signature: bytes, padding: AsymmetricPadding, algorithm: Union[HashAlgorithm, Prehashed]
+    ) -> AsymmetricVerificationContext: ...
+    @abstractmethod
+    def verify(
+        self, signature: bytes, data: bytes, padding: AsymmetricPadding, algorithm: Union[HashAlgorithm, Prehashed]
+    ) -> None: ...
+
+RSAPublicKeyWithSerialization = RSAPublicKey
+
+def generate_private_key(
+    public_exponent: int, key_size: int, backend: Optional[RSABackend] = ...
+) -> RSAPrivateKeyWithSerialization: ...
+def rsa_crt_iqmp(p: int, q: int) -> int: ...
+def rsa_crt_dmp1(private_exponent: int, p: int) -> int: ...
+def rsa_crt_dmq1(private_exponent: int, q: int) -> int: ...
+def rsa_recover_prime_factors(n: int, e: int, d: int) -> Tuple[int, int]: ...
+
+class RSAPrivateNumbers(object):
+    def __init__(self, p: int, q: int, d: int, dmp1: int, dmq1: int, iqmp: int, public_numbers: RSAPublicNumbers) -> None: ...
+    @property
+    def p(self) -> int: ...
+    @property
+    def q(self) -> int: ...
+    @property
+    def d(self) -> int: ...
+    @property
+    def dmp1(self) -> int: ...
+    @property
+    def dmq1(self) -> int: ...
+    @property
+    def iqmp(self) -> int: ...
+    @property
+    def public_numbers(self) -> RSAPublicNumbers: ...
+    def private_key(self, backend: Optional[RSABackend] = ...) -> RSAPrivateKey: ...
+
+class RSAPublicNumbers(object):
+    def __init__(self, e: int, n: int) -> None: ...
+    @property
+    def e(self) -> int: ...
+    @property
+    def n(self) -> int: ...
+    def public_key(self, backend: Optional[RSABackend] = ...) -> RSAPublicKey: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/utils.pyi

@@ -0,0 +1,12 @@
+from typing import Tuple
+
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+
+def decode_dss_signature(signature: bytes) -> Tuple[int, int]: ...
+def encode_dss_signature(r: int, s: int) -> bytes: ...
+
+class Prehashed(object):
+    _algorithm: HashAlgorithm  # undocumented
+    _digest_size: int  # undocumented
+    def __init__(self, algorithm: HashAlgorithm) -> None: ...
+    digest_size: int

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/x25519.pyi

@@ -0,0 +1,23 @@
+from abc import ABCMeta, abstractmethod
+
+from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat
+
+class X25519PrivateKey(metaclass=ABCMeta):
+    @classmethod
+    def from_private_bytes(cls, data: bytes) -> X25519PrivateKey: ...
+    @classmethod
+    def generate(cls) -> X25519PrivateKey: ...
+    @abstractmethod
+    def exchange(self, peer_public_key: X25519PublicKey) -> bytes: ...
+    @abstractmethod
+    def private_bytes(
+        self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption
+    ) -> bytes: ...
+    @abstractmethod
+    def public_key(self) -> X25519PublicKey: ...
+
+class X25519PublicKey(metaclass=ABCMeta):
+    @classmethod
+    def from_public_bytes(cls, data: bytes) -> X25519PublicKey: ...
+    @abstractmethod
+    def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/x448.pyi

@@ -0,0 +1,23 @@
+from abc import ABCMeta, abstractmethod
+
+from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat
+
+class X448PrivateKey(metaclass=ABCMeta):
+    @classmethod
+    def from_private_bytes(cls, data: bytes) -> X448PrivateKey: ...
+    @classmethod
+    def generate(cls) -> X448PrivateKey: ...
+    @abstractmethod
+    def exchange(self, peer_public_key: X448PublicKey) -> bytes: ...
+    @abstractmethod
+    def private_bytes(
+        self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption
+    ) -> bytes: ...
+    @abstractmethod
+    def public_key(self) -> X448PublicKey: ...
+
+class X448PublicKey(metaclass=ABCMeta):
+    @classmethod
+    def from_public_bytes(cls, data: bytes) -> X448PublicKey: ...
+    @abstractmethod
+    def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/aead.pyi

@@ -0,0 +1,22 @@
+from typing import Optional
+
+class AESCCM(object):
+    def __init__(self, key: bytes, tag_length: Optional[int]) -> None: ...
+    def decrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ...
+    def encrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ...
+    @classmethod
+    def generate_key(cls, bit_length: int) -> bytes: ...
+
+class AESGCM(object):
+    def __init__(self, key: bytes) -> None: ...
+    def decrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ...
+    def encrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ...
+    @classmethod
+    def generate_key(cls, bit_length: int) -> bytes: ...
+
+class ChaCha20Poly1305(object):
+    def __init__(self, key: bytes) -> None: ...
+    def decrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ...
+    def encrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ...
+    @classmethod
+    def generate_key(cls) -> bytes: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/cmac.pyi

@@ -0,0 +1,11 @@
+from typing import Optional
+
+from cryptography.hazmat.backends.interfaces import CMACBackend
+from cryptography.hazmat.primitives.ciphers import BlockCipherAlgorithm
+
+class CMAC(object):
+    def __init__(self, algorithm: BlockCipherAlgorithm, backend: Optional[CMACBackend] = ...) -> None: ...
+    def copy(self) -> CMAC: ...
+    def finalize(self) -> bytes: ...
+    def update(self, data: bytes) -> None: ...
+    def verify(self, signature: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/constant_time.pyi

@@ -0,0 +1 @@
+def bytes_eq(a: bytes, b: bytes) -> bool: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/hashes.pyi

@@ -0,0 +1,44 @@
+from abc import ABCMeta, abstractmethod
+from typing import Optional
+
+from cryptography.hazmat.backends.interfaces import HashBackend
+
+class HashAlgorithm(metaclass=ABCMeta):
+    digest_size: int
+    name: str
+
+class HashContext(metaclass=ABCMeta):
+    algorithm: HashAlgorithm
+    @abstractmethod
+    def copy(self) -> HashContext: ...
+    @abstractmethod
+    def finalize(self) -> bytes: ...
+    @abstractmethod
+    def update(self, data: bytes) -> None: ...
+
+class BLAKE2b(HashAlgorithm): ...
+class BLAKE2s(HashAlgorithm): ...
+class MD5(HashAlgorithm): ...
+class SHA1(HashAlgorithm): ...
+class SHA224(HashAlgorithm): ...
+class SHA256(HashAlgorithm): ...
+class SHA384(HashAlgorithm): ...
+class SHA3_224(HashAlgorithm): ...
+class SHA3_256(HashAlgorithm): ...
+class SHA3_384(HashAlgorithm): ...
+class SHA3_512(HashAlgorithm): ...
+class SHA512(HashAlgorithm): ...
+class SHA512_224(HashAlgorithm): ...
+class SHA512_256(HashAlgorithm): ...
+
+class SHAKE128(HashAlgorithm):
+    def __init__(self, digest_size: int) -> None: ...
+
+class SHAKE256(HashAlgorithm):
+    def __init__(self, digest_size: int) -> None: ...
+
+class Hash(HashContext):
+    def __init__(self, algorithm: HashAlgorithm, backend: Optional[HashBackend] = ...): ...
+    def copy(self) -> Hash: ...
+    def finalize(self) -> bytes: ...
+    def update(self, data: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/hmac.pyi

@@ -0,0 +1,11 @@
+from typing import Optional
+
+from cryptography.hazmat.backends.interfaces import HMACBackend
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+
+class HMAC(object):
+    def __init__(self, key: bytes, algorithm: HashAlgorithm, backend: Optional[HMACBackend] = ...) -> None: ...
+    def copy(self) -> HMAC: ...
+    def finalize(self) -> bytes: ...
+    def update(self, msg: bytes) -> None: ...
+    def verify(self, signature: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/__init__.pyi

@@ -0,0 +1,7 @@
+from abc import ABCMeta, abstractmethod
+
+class KeyDerivationFunction(metaclass=ABCMeta):
+    @abstractmethod
+    def derive(self, key_material: bytes) -> bytes: ...
+    @abstractmethod
+    def verify(self, key_material: bytes, expected_key: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/concatkdf.pyi

@@ -0,0 +1,24 @@
+from typing import Optional
+
+from cryptography.hazmat.backends.interfaces import HashBackend, HMACBackend
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+class ConcatKDFHash(KeyDerivationFunction):
+    def __init__(
+        self, algorithm: HashAlgorithm, length: int, otherinfo: Optional[bytes], backend: Optional[HashBackend] = ...
+    ): ...
+    def derive(self, key_material: bytes) -> bytes: ...
+    def verify(self, key_material: bytes, expected_key: bytes) -> None: ...
+
+class ConcatKDFHMAC(KeyDerivationFunction):
+    def __init__(
+        self,
+        algorithm: HashAlgorithm,
+        length: int,
+        salt: Optional[bytes],
+        otherinfo: Optional[bytes],
+        backend: Optional[HMACBackend] = ...,
+    ): ...
+    def derive(self, key_material: bytes) -> bytes: ...
+    def verify(self, key_material: bytes, expected_key: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/hkdf.pyi

@@ -0,0 +1,22 @@
+from typing import Optional
+
+from cryptography.hazmat.backends.interfaces import HMACBackend
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+class HKDF(KeyDerivationFunction):
+    def __init__(
+        self,
+        algorithm: HashAlgorithm,
+        length: int,
+        salt: Optional[bytes],
+        info: Optional[bytes],
+        backend: Optional[HMACBackend] = ...,
+    ): ...
+    def derive(self, key_material: bytes) -> bytes: ...
+    def verify(self, key_material: bytes, expected_key: bytes) -> None: ...
+
+class HKDFExpand(KeyDerivationFunction):
+    def __init__(self, algorithm: HashAlgorithm, length: int, info: Optional[bytes], backend: Optional[HMACBackend] = ...): ...
+    def derive(self, key_material: bytes) -> bytes: ...
+    def verify(self, key_material: bytes, expected_key: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/kbkdf.pyi

@@ -0,0 +1,30 @@
+from enum import Enum
+from typing import Optional
+
+from cryptography.hazmat.backends.interfaces import HMACBackend
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+class Mode(Enum):
+    CounterMode: str
+
+class CounterLocation(Enum):
+    BeforeFixed: str
+    AfterFixed: str
+
+class KBKDFHMAC(KeyDerivationFunction):
+    def __init__(
+        self,
+        algorithm: HashAlgorithm,
+        mode: Mode,
+        length: int,
+        rlen: int,
+        llen: int,
+        location: CounterLocation,
+        label: Optional[bytes],
+        context: Optional[bytes],
+        fixed: Optional[bytes],
+        backend: Optional[HMACBackend] = ...,
+    ): ...
+    def derive(self, key_material: bytes) -> bytes: ...
+    def verify(self, key_material: bytes, expected_key: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/pbkdf2.pyi

@@ -0,0 +1,12 @@
+from typing import Optional
+
+from cryptography.hazmat.backends.interfaces import PBKDF2HMACBackend
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+class PBKDF2HMAC(KeyDerivationFunction):
+    def __init__(
+        self, algorithm: HashAlgorithm, length: int, salt: bytes, iterations: int, backend: Optional[PBKDF2HMACBackend] = ...
+    ): ...
+    def derive(self, key_material: bytes) -> bytes: ...
+    def verify(self, key_material: bytes, expected_key: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/scrypt.pyi

@@ -0,0 +1,9 @@
+from typing import Optional
+
+from cryptography.hazmat.backends.interfaces import ScryptBackend
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+class Scrypt(KeyDerivationFunction):
+    def __init__(self, salt: bytes, length: int, n: int, r: int, p: int, backend: Optional[ScryptBackend] = ...): ...
+    def derive(self, key_material: bytes) -> bytes: ...
+    def verify(self, key_material: bytes, expected_key: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/x963kdf.pyi

@@ -0,0 +1,12 @@
+from typing import Optional
+
+from cryptography.hazmat.backends.interfaces import HashBackend
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+from cryptography.hazmat.primitives.kdf import KeyDerivationFunction
+
+class X963KDF(KeyDerivationFunction):
+    def __init__(
+        self, algorithm: HashAlgorithm, length: int, sharedinfo: Optional[bytes], backend: Optional[HashBackend] = ...
+    ): ...
+    def derive(self, key_material: bytes) -> bytes: ...
+    def verify(self, key_material: bytes, expected_key: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/keywrap.pyi

@@ -0,0 +1,10 @@
+from typing import Optional
+
+from cryptography.hazmat.backends.interfaces import CipherBackend
+
+def aes_key_wrap(wrapping_key: bytes, key_to_wrap: bytes, backend: Optional[CipherBackend] = ...) -> bytes: ...
+def aes_key_wrap_with_padding(wrapping_key: bytes, key_to_wrap: bytes, backend: Optional[CipherBackend] = ...) -> bytes: ...
+def aes_key_unwrap(wrapping_key: bytes, wrapped_key: bytes, backend: Optional[CipherBackend] = ...) -> bytes: ...
+def aes_key_unwrap_with_padding(wrapping_key: bytes, wrapped_key: bytes, backend: Optional[CipherBackend] = ...) -> bytes: ...
+
+class InvalidUnwrap(Exception): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/padding.pyi

@@ -0,0 +1,17 @@
+from abc import ABCMeta, abstractmethod
+
+class PaddingContext(metaclass=ABCMeta):
+    @abstractmethod
+    def finalize(self) -> bytes: ...
+    @abstractmethod
+    def update(self, data: bytes) -> bytes: ...
+
+class ANSIX923(object):
+    def __init__(self, block_size: int) -> None: ...
+    def padder(self) -> PaddingContext: ...
+    def unpadder(self) -> PaddingContext: ...
+
+class PKCS7(object):
+    def __init__(self, block_size: int) -> None: ...
+    def padder(self) -> PaddingContext: ...
+    def unpadder(self) -> PaddingContext: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/poly1305.pyi

@@ -0,0 +1,9 @@
+class Poly1305(object):
+    def __init__(self, key: bytes) -> None: ...
+    def finalize(self) -> bytes: ...
+    @classmethod
+    def generate_tag(cls, key: bytes, data: bytes) -> bytes: ...
+    def update(self, data: bytes) -> None: ...
+    def verify(self, tag: bytes) -> None: ...
+    @classmethod
+    def verify_tag(cls, key: bytes, data: bytes, tag: bytes) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/serialization/__init__.pyi

@@ -0,0 +1,63 @@
+from abc import ABCMeta
+from enum import Enum
+from typing import Any, Optional, Union
+
+from cryptography.hazmat.backends.interfaces import (
+    DERSerializationBackend,
+    DSABackend,
+    EllipticCurveBackend,
+    PEMSerializationBackend,
+    RSABackend,
+)
+from cryptography.hazmat.primitives.asymmetric.dh import DHPrivateKey, DHPublicKey
+from cryptography.hazmat.primitives.asymmetric.dsa import DSAPrivateKey, DSAPublicKey
+from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePrivateKey, EllipticCurvePublicKey
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey, RSAPublicKey
+
+def load_pem_private_key(
+    data: bytes, password: Optional[bytes], backend: Optional[PEMSerializationBackend] = ...
+) -> Any: ...  # actually Union[RSAPrivateKey, DSAPrivateKey, DHPrivateKey, EllipticCurvePrivateKey]
+def load_pem_public_key(
+    data: bytes, backend: Optional[PEMSerializationBackend] = ...
+) -> Any: ...  # actually Union[RSAPublicKey, DSAPublicKey, DHPublicKey, EllipticCurvePublicKey]
+def load_der_private_key(
+    data: bytes, password: Optional[bytes], backend: Optional[DERSerializationBackend] = ...
+) -> Any: ...  # actually Union[RSAPrivateKey, DSAPrivateKey, DHPrivateKey, EllipticCurvePrivateKey]
+def load_der_public_key(
+    data: bytes, backend: Optional[DERSerializationBackend] = ...
+) -> Any: ...  # actually Union[RSAPublicKey, DSAPublicKey, DHPublicKey, EllipticCurvePublicKey]
+def load_ssh_public_key(
+    data: bytes, backend: Union[RSABackend, DSABackend, EllipticCurveBackend, None]
+) -> Any: ...  # actually Union[RSAPublicKey, DSAPublicKey, DHPublicKey, EllipticCurvePublicKey, Ed25519PublicKey]
+
+class Encoding(Enum):
+    PEM: str
+    DER: str
+    OpenSSH: str
+    Raw: str
+    X962: str
+
+class PrivateFormat(Enum):
+    PKCS8: str
+    TraditionalOpenSSL: str
+    Raw: str
+
+class PublicFormat(Enum):
+    SubjectPublicKeyInfo: str
+    PKCS1: str
+    OpenSSH: str
+    Raw: str
+    CompressedPoint: str
+    UncompressedPoint: str
+
+class ParameterFormat(Enum):
+    PKCS3: str
+
+class KeySerializationEncryption(metaclass=ABCMeta): ...
+
+class BestAvailableEncryption(KeySerializationEncryption):
+    password: bytes
+    def __init__(self, password: bytes) -> None: ...
+
+class NoEncryption(KeySerializationEncryption): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/serialization/pkcs12.pyi

@@ -0,0 +1,18 @@
+from typing import Any, List, Optional, Tuple, Union
+
+from cryptography.hazmat.primitives.asymmetric.dsa import DSAPrivateKeyWithSerialization
+from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePrivateKeyWithSerialization
+from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKeyWithSerialization
+from cryptography.hazmat.primitives.serialization import KeySerializationEncryption
+from cryptography.x509 import Certificate
+
+def load_key_and_certificates(
+    data: bytes, password: Optional[bytes], backend: Optional[Any] = ...
+) -> Tuple[Optional[Any], Optional[Certificate], List[Certificate]]: ...
+def serialize_key_and_certificates(
+    name: bytes,
+    key: Union[RSAPrivateKeyWithSerialization, EllipticCurvePrivateKeyWithSerialization, DSAPrivateKeyWithSerialization],
+    cert: Optional[Certificate],
+    cas: Optional[List[Certificate]],
+    enc: KeySerializationEncryption,
+) -> bytes: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/twofactor/__init__.pyi

@@ -0,0 +1 @@
+class InvalidToken(Exception): ...