Add files using upload-large-folder tool

.gitattributes

@@ -496,3 +496,5 @@ material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:
 material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pillow.libs/libxcb-55eab65a.so.1.1.0 filter=lfs diff=lfs merge=lfs -text
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908304_m.tif filter=lfs diff=lfs merge=lfs -text
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected_4Classes/1908276_cm.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/h5py.libs/libaec-7e9d22b8.so.0.1.3 filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected_4Classes/1908318_cm.tif filter=lfs diff=lfs merge=lfs -text

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/h5py.libs/libaec-7e9d22b8.so.0.1.3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0788adca6f4440b7f72f1520c90a9bf19fb3c0a28202a6a3fbeda3fe525dd9d8
+size 135913

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

@@ -0,0 +1,47 @@
+from functools import wraps
+
+
+class _PluginManager:
+    def __init__(self):
+        self._registered_plugins = []
+        self._cached_base_callbacks = {}
+        self._built_functions = {}
+
+    def register(self, *plugins):
+        """
+        Makes it possible to register your plugin.
+        """
+        self._registered_plugins.extend(plugins)
+        self._build_functions()
+
+    def decorate(self, name=None):
+        def decorator(callback):
+            @wraps(callback)
+            def wrapper(*args, **kwargs):
+                return built_functions[public_name](*args, **kwargs)
+
+            public_name = name or callback.__name__
+
+            assert public_name not in self._built_functions
+            built_functions = self._built_functions
+            built_functions[public_name] = callback
+            self._cached_base_callbacks[public_name] = callback
+
+            return wrapper
+
+        return decorator
+
+    def _build_functions(self):
+        for name, callback in self._cached_base_callbacks.items():
+            for plugin in reversed(self._registered_plugins):
+                # Need to reverse so the first plugin is run first.
+                try:
+                    func = getattr(plugin, name)
+                except AttributeError:
+                    pass
+                else:
+                    callback = func(callback)
+            self._built_functions[name] = callback
+
+
+plugin_manager = _PluginManager()

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

@@ -0,0 +1,296 @@
+"""
+Module is used to infer Django model fields.
+"""
+from inspect import Parameter
+
+from jedi import debug
+from jedi.inference.cache import inference_state_function_cache
+from jedi.inference.base_value import ValueSet, iterator_to_value_set, ValueWrapper
+from jedi.inference.filters import DictFilter, AttributeOverwrite
+from jedi.inference.names import NameWrapper, BaseTreeParamName
+from jedi.inference.compiled.value import EmptyCompiledName
+from jedi.inference.value.instance import TreeInstance
+from jedi.inference.value.klass import ClassMixin
+from jedi.inference.gradual.base import GenericClass
+from jedi.inference.gradual.generics import TupleGenericManager
+from jedi.inference.signature import AbstractSignature
+
+
+mapping = {
+    'IntegerField': (None, 'int'),
+    'BigIntegerField': (None, 'int'),
+    'PositiveIntegerField': (None, 'int'),
+    'SmallIntegerField': (None, 'int'),
+    'CharField': (None, 'str'),
+    'TextField': (None, 'str'),
+    'EmailField': (None, 'str'),
+    'GenericIPAddressField': (None, 'str'),
+    'URLField': (None, 'str'),
+    'FloatField': (None, 'float'),
+    'BinaryField': (None, 'bytes'),
+    'BooleanField': (None, 'bool'),
+    'DecimalField': ('decimal', 'Decimal'),
+    'TimeField': ('datetime', 'time'),
+    'DurationField': ('datetime', 'timedelta'),
+    'DateField': ('datetime', 'date'),
+    'DateTimeField': ('datetime', 'datetime'),
+    'UUIDField': ('uuid', 'UUID'),
+}
+
+_FILTER_LIKE_METHODS = ('create', 'filter', 'exclude', 'update', 'get',
+                        'get_or_create', 'update_or_create')
+
+
+@inference_state_function_cache()
+def _get_deferred_attributes(inference_state):
+    return inference_state.import_module(
+        ('django', 'db', 'models', 'query_utils')
+    ).py__getattribute__('DeferredAttribute').execute_annotation()
+
+
+def _infer_scalar_field(inference_state, field_name, field_tree_instance, is_instance):
+    try:
+        module_name, attribute_name = mapping[field_tree_instance.py__name__()]
+    except KeyError:
+        return None
+
+    if not is_instance:
+        return _get_deferred_attributes(inference_state)
+
+    if module_name is None:
+        module = inference_state.builtins_module
+    else:
+        module = inference_state.import_module((module_name,))
+
+    for attribute in module.py__getattribute__(attribute_name):
+        return attribute.execute_with_values()
+
+
+@iterator_to_value_set
+def _get_foreign_key_values(cls, field_tree_instance):
+    if isinstance(field_tree_instance, TreeInstance):
+        # TODO private access..
+        argument_iterator = field_tree_instance._arguments.unpack()
+        key, lazy_values = next(argument_iterator, (None, None))
+        if key is None and lazy_values is not None:
+            for value in lazy_values.infer():
+                if value.py__name__() == 'str':
+                    foreign_key_class_name = value.get_safe_value()
+                    module = cls.get_root_context()
+                    for v in module.py__getattribute__(foreign_key_class_name):
+                        if v.is_class():
+                            yield v
+                elif value.is_class():
+                    yield value
+
+
+def _infer_field(cls, field_name, is_instance):
+    inference_state = cls.inference_state
+    result = field_name.infer()
+    for field_tree_instance in result:
+        scalar_field = _infer_scalar_field(
+            inference_state, field_name, field_tree_instance, is_instance)
+        if scalar_field is not None:
+            return scalar_field
+
+        name = field_tree_instance.py__name__()
+        is_many_to_many = name == 'ManyToManyField'
+        if name in ('ForeignKey', 'OneToOneField') or is_many_to_many:
+            if not is_instance:
+                return _get_deferred_attributes(inference_state)
+
+            values = _get_foreign_key_values(cls, field_tree_instance)
+            if is_many_to_many:
+                return ValueSet(filter(None, [
+                    _create_manager_for(v, 'RelatedManager') for v in values
+                ]))
+            else:
+                return values.execute_with_values()
+
+    debug.dbg('django plugin: fail to infer `%s` from class `%s`',
+              field_name.string_name, cls.py__name__())
+    return result
+
+
+class DjangoModelName(NameWrapper):
+    def __init__(self, cls, name, is_instance):
+        super().__init__(name)
+        self._cls = cls
+        self._is_instance = is_instance
+
+    def infer(self):
+        return _infer_field(self._cls, self._wrapped_name, self._is_instance)
+
+
+def _create_manager_for(cls, manager_cls='BaseManager'):
+    managers = cls.inference_state.import_module(
+        ('django', 'db', 'models', 'manager')
+    ).py__getattribute__(manager_cls)
+    for m in managers:
+        if m.is_class_mixin():
+            generics_manager = TupleGenericManager((ValueSet([cls]),))
+            for c in GenericClass(m, generics_manager).execute_annotation():
+                return c
+    return None
+
+
+def _new_dict_filter(cls, is_instance):
+    filters = list(cls.get_filters(
+        is_instance=is_instance,
+        include_metaclasses=False,
+        include_type_when_class=False)
+    )
+    dct = {
+        name.string_name: DjangoModelName(cls, name, is_instance)
+        for filter_ in reversed(filters)
+        for name in filter_.values()
+    }
+    if is_instance:
+        # Replace the objects with a name that amounts to nothing when accessed
+        # in an instance. This is not perfect and still completes "objects" in
+        # that case, but it at least not inferes stuff like `.objects.filter`.
+        # It would be nicer to do that in a better way, so that it also doesn't
+        # show up in completions, but it's probably just not worth doing that
+        # for the extra amount of work.
+        dct['objects'] = EmptyCompiledName(cls.inference_state, 'objects')
+
+    return DictFilter(dct)
+
+
+def is_django_model_base(value):
+    return value.py__name__() == 'ModelBase' \
+        and value.get_root_context().py__name__() == 'django.db.models.base'
+
+
+def get_metaclass_filters(func):
+    def wrapper(cls, metaclasses, is_instance):
+        for metaclass in metaclasses:
+            if is_django_model_base(metaclass):
+                return [_new_dict_filter(cls, is_instance)]
+
+        return func(cls, metaclasses, is_instance)
+    return wrapper
+
+
+def tree_name_to_values(func):
+    def wrapper(inference_state, context, tree_name):
+        result = func(inference_state, context, tree_name)
+        if tree_name.value in _FILTER_LIKE_METHODS:
+            # Here we try to overwrite stuff like User.objects.filter. We need
+            # this to make sure that keyword param completion works on these
+            # kind of methods.
+            for v in result:
+                if v.get_qualified_names() == ('_BaseQuerySet', tree_name.value) \
+                        and v.parent_context.is_module() \
+                        and v.parent_context.py__name__() == 'django.db.models.query':
+                    qs = context.get_value()
+                    generics = qs.get_generics()
+                    if len(generics) >= 1:
+                        return ValueSet(QuerySetMethodWrapper(v, model)
+                                        for model in generics[0])
+
+        elif tree_name.value == 'BaseManager' and context.is_module() \
+                and context.py__name__() == 'django.db.models.manager':
+            return ValueSet(ManagerWrapper(r) for r in result)
+
+        elif tree_name.value == 'Field' and context.is_module() \
+                and context.py__name__() == 'django.db.models.fields':
+            return ValueSet(FieldWrapper(r) for r in result)
+        return result
+    return wrapper
+
+
+def _find_fields(cls):
+    for name in _new_dict_filter(cls, is_instance=False).values():
+        for value in name.infer():
+            if value.name.get_qualified_names(include_module_names=True) \
+                    == ('django', 'db', 'models', 'query_utils', 'DeferredAttribute'):
+                yield name
+
+
+def _get_signatures(cls):
+    return [DjangoModelSignature(cls, field_names=list(_find_fields(cls)))]
+
+
+def get_metaclass_signatures(func):
+    def wrapper(cls, metaclasses):
+        for metaclass in metaclasses:
+            if is_django_model_base(metaclass):
+                return _get_signatures(cls)
+        return func(cls, metaclass)
+    return wrapper
+
+
+class ManagerWrapper(ValueWrapper):
+    def py__getitem__(self, index_value_set, contextualized_node):
+        return ValueSet(
+            GenericManagerWrapper(generic)
+            for generic in self._wrapped_value.py__getitem__(
+                index_value_set, contextualized_node)
+        )
+
+
+class GenericManagerWrapper(AttributeOverwrite, ClassMixin):
+    def py__get__on_class(self, calling_instance, instance, class_value):
+        return calling_instance.class_value.with_generics(
+            (ValueSet({class_value}),)
+        ).py__call__(calling_instance._arguments)
+
+    def with_generics(self, generics_tuple):
+        return self._wrapped_value.with_generics(generics_tuple)
+
+
+class FieldWrapper(ValueWrapper):
+    def py__getitem__(self, index_value_set, contextualized_node):
+        return ValueSet(
+            GenericFieldWrapper(generic)
+            for generic in self._wrapped_value.py__getitem__(
+                index_value_set, contextualized_node)
+        )
+
+
+class GenericFieldWrapper(AttributeOverwrite, ClassMixin):
+    def py__get__on_class(self, calling_instance, instance, class_value):
+        # This is mostly an optimization to avoid Jedi aborting inference,
+        # because of too many function executions of Field.__get__.
+        return ValueSet({calling_instance})
+
+
+class DjangoModelSignature(AbstractSignature):
+    def __init__(self, value, field_names):
+        super().__init__(value)
+        self._field_names = field_names
+
+    def get_param_names(self, resolve_stars=False):
+        return [DjangoParamName(name) for name in self._field_names]
+
+
+class DjangoParamName(BaseTreeParamName):
+    def __init__(self, field_name):
+        super().__init__(field_name.parent_context, field_name.tree_name)
+        self._field_name = field_name
+
+    def get_kind(self):
+        return Parameter.KEYWORD_ONLY
+
+    def infer(self):
+        return self._field_name.infer()
+
+
+class QuerySetMethodWrapper(ValueWrapper):
+    def __init__(self, method, model_cls):
+        super().__init__(method)
+        self._model_cls = model_cls
+
+    def py__get__(self, instance, class_value):
+        return ValueSet({QuerySetBoundMethodWrapper(v, self._model_cls)
+                         for v in self._wrapped_value.py__get__(instance, class_value)})
+
+
+class QuerySetBoundMethodWrapper(ValueWrapper):
+    def __init__(self, method, model_cls):
+        super().__init__(method)
+        self._model_cls = model_cls
+
+    def get_signatures(self):
+        return _get_signatures(self._model_cls)

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

@@ -0,0 +1,21 @@
+def import_module(callback):
+    """
+    Handle "magic" Flask extension imports:
+    ``flask.ext.foo`` is really ``flask_foo`` or ``flaskext.foo``.
+    """
+    def wrapper(inference_state, import_names, module_context, *args, **kwargs):
+        if len(import_names) == 3 and import_names[:2] == ('flask', 'ext'):
+            # New style.
+            ipath = ('flask_' + import_names[2]),
+            value_set = callback(inference_state, ipath, None, *args, **kwargs)
+            if value_set:
+                return value_set
+            value_set = callback(inference_state, ('flaskext',), None, *args, **kwargs)
+            return callback(
+                inference_state,
+                ('flaskext', import_names[2]),
+                next(iter(value_set)),
+                *args, **kwargs
+            )
+        return callback(inference_state, import_names, module_context, *args, **kwargs)
+    return wrapper

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

@@ -0,0 +1,269 @@
+import sys
+from typing import List
+from pathlib import Path
+
+from parso.tree import search_ancestor
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.imports import goto_import, load_module_from_path
+from jedi.inference.filters import ParserTreeFilter
+from jedi.inference.base_value import NO_VALUES, ValueSet
+from jedi.inference.helpers import infer_call_of_leaf
+
+_PYTEST_FIXTURE_MODULES = [
+    ('_pytest', 'monkeypatch'),
+    ('_pytest', 'capture'),
+    ('_pytest', 'logging'),
+    ('_pytest', 'tmpdir'),
+    ('_pytest', 'pytester'),
+]
+
+
+def execute(callback):
+    def wrapper(value, arguments):
+        # This might not be necessary anymore in pytest 4/5, definitely needed
+        # for pytest 3.
+        if value.py__name__() == 'fixture' \
+                and value.parent_context.py__name__() == '_pytest.fixtures':
+            return NO_VALUES
+
+        return callback(value, arguments)
+    return wrapper
+
+
+def infer_anonymous_param(func):
+    def get_returns(value):
+        if value.tree_node.annotation is not None:
+            result = value.execute_with_values()
+            if any(v.name.get_qualified_names(include_module_names=True)
+                   == ('typing', 'Generator')
+                   for v in result):
+                return ValueSet.from_sets(
+                    v.py__getattribute__('__next__').execute_annotation()
+                    for v in result
+                )
+            return result
+
+        # In pytest we need to differentiate between generators and normal
+        # returns.
+        # Parameters still need to be anonymous, .as_context() ensures that.
+        function_context = value.as_context()
+        if function_context.is_generator():
+            return function_context.merge_yield_values()
+        else:
+            return function_context.get_return_values()
+
+    def wrapper(param_name):
+        # parameters with an annotation do not need special handling
+        if param_name.annotation_node:
+            return func(param_name)
+        is_pytest_param, param_name_is_function_name = \
+            _is_a_pytest_param_and_inherited(param_name)
+        if is_pytest_param:
+            module = param_name.get_root_context()
+            fixtures = _goto_pytest_fixture(
+                module,
+                param_name.string_name,
+                # This skips the current module, because we are basically
+                # inheriting a fixture from somewhere else.
+                skip_own_module=param_name_is_function_name,
+            )
+            if fixtures:
+                return ValueSet.from_sets(
+                    get_returns(value)
+                    for fixture in fixtures
+                    for value in fixture.infer()
+                )
+        return func(param_name)
+    return wrapper
+
+
+def goto_anonymous_param(func):
+    def wrapper(param_name):
+        is_pytest_param, param_name_is_function_name = \
+            _is_a_pytest_param_and_inherited(param_name)
+        if is_pytest_param:
+            names = _goto_pytest_fixture(
+                param_name.get_root_context(),
+                param_name.string_name,
+                skip_own_module=param_name_is_function_name,
+            )
+            if names:
+                return names
+        return func(param_name)
+    return wrapper
+
+
+def complete_param_names(func):
+    def wrapper(context, func_name, decorator_nodes):
+        module_context = context.get_root_context()
+        if _is_pytest_func(func_name, decorator_nodes):
+            names = []
+            for module_context in _iter_pytest_modules(module_context):
+                names += FixtureFilter(module_context).values()
+            if names:
+                return names
+        return func(context, func_name, decorator_nodes)
+    return wrapper
+
+
+def _goto_pytest_fixture(module_context, name, skip_own_module):
+    for module_context in _iter_pytest_modules(module_context, skip_own_module=skip_own_module):
+        names = FixtureFilter(module_context).get(name)
+        if names:
+            return names
+
+
+def _is_a_pytest_param_and_inherited(param_name):
+    """
+    Pytest params are either in a `test_*` function or have a pytest fixture
+    with the decorator @pytest.fixture.
+
+    This is a heuristic and will work in most cases.
+    """
+    funcdef = search_ancestor(param_name.tree_name, 'funcdef')
+    if funcdef is None:  # A lambda
+        return False, False
+    decorators = funcdef.get_decorators()
+    return _is_pytest_func(funcdef.name.value, decorators), \
+        funcdef.name.value == param_name.string_name
+
+
+def _is_pytest_func(func_name, decorator_nodes):
+    return func_name.startswith('test') \
+        or any('fixture' in n.get_code() for n in decorator_nodes)
+
+
+def _find_pytest_plugin_modules() -> List[List[str]]:
+    """
+    Finds pytest plugin modules hooked by setuptools entry points
+
+    See https://docs.pytest.org/en/stable/how-to/writing_plugins.html#setuptools-entry-points
+    """
+    if sys.version_info >= (3, 8):
+        from importlib.metadata import entry_points
+
+        if sys.version_info >= (3, 10):
+            pytest_entry_points = entry_points(group="pytest11")
+        else:
+            pytest_entry_points = entry_points().get("pytest11", ())
+
+        if sys.version_info >= (3, 9):
+            return [ep.module.split(".") for ep in pytest_entry_points]
+        else:
+            # Python 3.8 doesn't have `EntryPoint.module`. Implement equivalent
+            # to what Python 3.9 does (with additional None check to placate `mypy`)
+            matches = [
+                ep.pattern.match(ep.value)
+                for ep in pytest_entry_points
+            ]
+            return [x.group('module').split(".") for x in matches if x]
+
+    else:
+        from pkg_resources import iter_entry_points
+        return [ep.module_name.split(".") for ep in iter_entry_points(group="pytest11")]
+
+
+@inference_state_method_cache()
+def _iter_pytest_modules(module_context, skip_own_module=False):
+    if not skip_own_module:
+        yield module_context
+
+    file_io = module_context.get_value().file_io
+    if file_io is not None:
+        folder = file_io.get_parent_folder()
+        sys_path = module_context.inference_state.get_sys_path()
+
+        # prevent an infinite loop when reaching the root of the current drive
+        last_folder = None
+
+        while any(folder.path.startswith(p) for p in sys_path):
+            file_io = folder.get_file_io('conftest.py')
+            if Path(file_io.path) != module_context.py__file__():
+                try:
+                    m = load_module_from_path(module_context.inference_state, file_io)
+                    conftest_module = m.as_context()
+                    yield conftest_module
+
+                    plugins_list = m.tree_node.get_used_names().get("pytest_plugins")
+                    if plugins_list:
+                        name = conftest_module.create_name(plugins_list[0])
+                        yield from _load_pytest_plugins(module_context, name)
+                except FileNotFoundError:
+                    pass
+            folder = folder.get_parent_folder()
+
+            # prevent an infinite for loop if the same parent folder is return twice
+            if last_folder is not None and folder.path == last_folder.path:
+                break
+            last_folder = folder  # keep track of the last found parent name
+
+    for names in _PYTEST_FIXTURE_MODULES + _find_pytest_plugin_modules():
+        for module_value in module_context.inference_state.import_module(names):
+            yield module_value.as_context()
+
+
+def _load_pytest_plugins(module_context, name):
+    from jedi.inference.helpers import get_str_or_none
+
+    for inferred in name.infer():
+        for seq_value in inferred.py__iter__():
+            for value in seq_value.infer():
+                fq_name = get_str_or_none(value)
+                if fq_name:
+                    names = fq_name.split(".")
+                    for module_value in module_context.inference_state.import_module(names):
+                        yield module_value.as_context()
+
+
+class FixtureFilter(ParserTreeFilter):
+    def _filter(self, names):
+        for name in super()._filter(names):
+            # look for fixture definitions of imported names
+            if name.parent.type == "import_from":
+                imported_names = goto_import(self.parent_context, name)
+                if any(
+                    self._is_fixture(iname.parent_context, iname.tree_name)
+                    for iname in imported_names
+                    # discard imports of whole modules, that have no tree_name
+                    if iname.tree_name
+                ):
+                    yield name
+
+            elif self._is_fixture(self.parent_context, name):
+                yield name
+
+    def _is_fixture(self, context, name):
+        funcdef = name.parent
+        # Class fixtures are not supported
+        if funcdef.type != "funcdef":
+            return False
+        decorated = funcdef.parent
+        if decorated.type != "decorated":
+            return False
+        decorators = decorated.children[0]
+        if decorators.type == 'decorators':
+            decorators = decorators.children
+        else:
+            decorators = [decorators]
+        for decorator in decorators:
+            dotted_name = decorator.children[1]
+            # A heuristic, this makes it faster.
+            if 'fixture' in dotted_name.get_code():
+                if dotted_name.type == 'atom_expr':
+                    # Since Python3.9 a decorator does not have dotted names
+                    # anymore.
+                    last_trailer = dotted_name.children[-1]
+                    last_leaf = last_trailer.get_last_leaf()
+                    if last_leaf == ')':
+                        values = infer_call_of_leaf(
+                            context, last_leaf, cut_own_trailer=True
+                        )
+                    else:
+                        values = context.infer_node(dotted_name)
+                else:
+                    values = context.infer_node(dotted_name)
+                for value in values:
+                    if value.name.get_qualified_names(include_module_names=True) \
+                            == ('_pytest', 'fixtures', 'fixture'):
+                        return True
+        return False

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

@@ -0,0 +1,12 @@
+"""
+This is not a plugin, this is just the place were plugins are registered.
+"""
+
+from jedi.plugins import stdlib
+from jedi.plugins import flask
+from jedi.plugins import pytest
+from jedi.plugins import django
+from jedi.plugins import plugin_manager
+
+
+plugin_manager.register(stdlib, flask, pytest, django)

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

@@ -0,0 +1,879 @@
+"""
+Implementations of standard library functions, because it's not possible to
+understand them with Jedi.
+
+To add a new implementation, create a function and add it to the
+``_implemented`` dict at the bottom of this module.
+
+Note that this module exists only to implement very specific functionality in
+the standard library. The usual way to understand the standard library is the
+compiled module that returns the types for C-builtins.
+"""
+import parso
+import os
+from inspect import Parameter
+
+from jedi import debug
+from jedi.inference.utils import safe_property
+from jedi.inference.helpers import get_str_or_none
+from jedi.inference.arguments import iterate_argument_clinic, ParamIssue, \
+    repack_with_argument_clinic, AbstractArguments, TreeArgumentsWrapper
+from jedi.inference import analysis
+from jedi.inference import compiled
+from jedi.inference.value.instance import \
+    AnonymousMethodExecutionContext, MethodExecutionContext
+from jedi.inference.base_value import ContextualizedNode, \
+    NO_VALUES, ValueSet, ValueWrapper, LazyValueWrapper
+from jedi.inference.value import ClassValue, ModuleValue
+from jedi.inference.value.klass import ClassMixin
+from jedi.inference.value.function import FunctionMixin
+from jedi.inference.value import iterable
+from jedi.inference.lazy_value import LazyTreeValue, LazyKnownValue, \
+    LazyKnownValues
+from jedi.inference.names import ValueName, BaseTreeParamName
+from jedi.inference.filters import AttributeOverwrite, publish_method, \
+    ParserTreeFilter, DictFilter
+from jedi.inference.signature import AbstractSignature, SignatureWrapper
+
+
+# Copied from Python 3.6's stdlib.
+_NAMEDTUPLE_CLASS_TEMPLATE = """\
+_property = property
+_tuple = tuple
+from operator import itemgetter as _itemgetter
+from collections import OrderedDict
+
+class {typename}(tuple):
+    __slots__ = ()
+
+    _fields = {field_names!r}
+
+    def __new__(_cls, {arg_list}):
+        'Create new instance of {typename}({arg_list})'
+        return _tuple.__new__(_cls, ({arg_list}))
+
+    @classmethod
+    def _make(cls, iterable, new=tuple.__new__, len=len):
+        'Make a new {typename} object from a sequence or iterable'
+        result = new(cls, iterable)
+        if len(result) != {num_fields:d}:
+            raise TypeError('Expected {num_fields:d} arguments, got %d' % len(result))
+        return result
+
+    def _replace(_self, **kwds):
+        'Return a new {typename} object replacing specified fields with new values'
+        result = _self._make(map(kwds.pop, {field_names!r}, _self))
+        if kwds:
+            raise ValueError('Got unexpected field names: %r' % list(kwds))
+        return result
+
+    def __repr__(self):
+        'Return a nicely formatted representation string'
+        return self.__class__.__name__ + '({repr_fmt})' % self
+
+    def _asdict(self):
+        'Return a new OrderedDict which maps field names to their values.'
+        return OrderedDict(zip(self._fields, self))
+
+    def __getnewargs__(self):
+        'Return self as a plain tuple.  Used by copy and pickle.'
+        return tuple(self)
+
+    # These methods were added by Jedi.
+    # __new__ doesn't really work with Jedi. So adding this to nametuples seems
+    # like the easiest way.
+    def __init__(self, {arg_list}):
+        'A helper function for namedtuple.'
+        self.__iterable = ({arg_list})
+
+    def __iter__(self):
+        for i in self.__iterable:
+            yield i
+
+    def __getitem__(self, y):
+        return self.__iterable[y]
+
+{field_defs}
+"""
+
+_NAMEDTUPLE_FIELD_TEMPLATE = '''\
+    {name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}')
+'''
+
+
+def execute(callback):
+    def wrapper(value, arguments):
+        def call():
+            return callback(value, arguments=arguments)
+
+        try:
+            obj_name = value.name.string_name
+        except AttributeError:
+            pass
+        else:
+            p = value.parent_context
+            if p is not None and p.is_builtins_module():
+                module_name = 'builtins'
+            elif p is not None and p.is_module():
+                module_name = p.py__name__()
+            else:
+                return call()
+
+            if value.is_bound_method() or value.is_instance():
+                # value can be an instance for example if it is a partial
+                # object.
+                return call()
+
+            # for now we just support builtin functions.
+            try:
+                func = _implemented[module_name][obj_name]
+            except KeyError:
+                pass
+            else:
+                return func(value, arguments=arguments, callback=call)
+        return call()
+
+    return wrapper
+
+
+def _follow_param(inference_state, arguments, index):
+    try:
+        key, lazy_value = list(arguments.unpack())[index]
+    except IndexError:
+        return NO_VALUES
+    else:
+        return lazy_value.infer()
+
+
+def argument_clinic(clinic_string, want_value=False, want_context=False,
+                    want_arguments=False, want_inference_state=False,
+                    want_callback=False):
+    """
+    Works like Argument Clinic (PEP 436), to validate function params.
+    """
+
+    def f(func):
+        def wrapper(value, arguments, callback):
+            try:
+                args = tuple(iterate_argument_clinic(
+                    value.inference_state, arguments, clinic_string))
+            except ParamIssue:
+                return NO_VALUES
+
+            debug.dbg('builtin start %s' % value, color='MAGENTA')
+            kwargs = {}
+            if want_context:
+                kwargs['context'] = arguments.context
+            if want_value:
+                kwargs['value'] = value
+            if want_inference_state:
+                kwargs['inference_state'] = value.inference_state
+            if want_arguments:
+                kwargs['arguments'] = arguments
+            if want_callback:
+                kwargs['callback'] = callback
+            result = func(*args, **kwargs)
+            debug.dbg('builtin end: %s', result, color='MAGENTA')
+            return result
+
+        return wrapper
+    return f
+
+
+@argument_clinic('iterator[, default], /', want_inference_state=True)
+def builtins_next(iterators, defaults, inference_state):
+    # TODO theoretically we have to check here if something is an iterator.
+    # That is probably done by checking if it's not a class.
+    return defaults | iterators.py__getattribute__('__next__').execute_with_values()
+
+
+@argument_clinic('iterator[, default], /')
+def builtins_iter(iterators_or_callables, defaults):
+    # TODO implement this if it's a callable.
+    return iterators_or_callables.py__getattribute__('__iter__').execute_with_values()
+
+
+@argument_clinic('object, name[, default], /')
+def builtins_getattr(objects, names, defaults=None):
+    # follow the first param
+    for value in objects:
+        for name in names:
+            string = get_str_or_none(name)
+            if string is None:
+                debug.warning('getattr called without str')
+                continue
+            else:
+                return value.py__getattribute__(string)
+    return NO_VALUES
+
+
+@argument_clinic('object[, bases, dict], /')
+def builtins_type(objects, bases, dicts):
+    if bases or dicts:
+        # It's a type creation... maybe someday...
+        return NO_VALUES
+    else:
+        return objects.py__class__()
+
+
+class SuperInstance(LazyValueWrapper):
+    """To be used like the object ``super`` returns."""
+    def __init__(self, inference_state, instance):
+        self.inference_state = inference_state
+        self._instance = instance  # Corresponds to super().__self__
+
+    def _get_bases(self):
+        return self._instance.py__class__().py__bases__()
+
+    def _get_wrapped_value(self):
+        objs = self._get_bases()[0].infer().execute_with_values()
+        if not objs:
+            # This is just a fallback and will only be used, if it's not
+            # possible to find a class
+            return self._instance
+        return next(iter(objs))
+
+    def get_filters(self, origin_scope=None):
+        for b in self._get_bases():
+            for value in b.infer().execute_with_values():
+                for f in value.get_filters():
+                    yield f
+
+
+@argument_clinic('[type[, value]], /', want_context=True)
+def builtins_super(types, objects, context):
+    instance = None
+    if isinstance(context, AnonymousMethodExecutionContext):
+        instance = context.instance
+    elif isinstance(context, MethodExecutionContext):
+        instance = context.instance
+    if instance is None:
+        return NO_VALUES
+    return ValueSet({SuperInstance(instance.inference_state, instance)})
+
+
+class ReversedObject(AttributeOverwrite):
+    def __init__(self, reversed_obj, iter_list):
+        super().__init__(reversed_obj)
+        self._iter_list = iter_list
+
+    def py__iter__(self, contextualized_node=None):
+        return self._iter_list
+
+    @publish_method('__next__')
+    def _next(self, arguments):
+        return ValueSet.from_sets(
+            lazy_value.infer() for lazy_value in self._iter_list
+        )
+
+
+@argument_clinic('sequence, /', want_value=True, want_arguments=True)
+def builtins_reversed(sequences, value, arguments):
+    # While we could do without this variable (just by using sequences), we
+    # want static analysis to work well. Therefore we need to generated the
+    # values again.
+    key, lazy_value = next(arguments.unpack())
+    cn = None
+    if isinstance(lazy_value, LazyTreeValue):
+        cn = ContextualizedNode(lazy_value.context, lazy_value.data)
+    ordered = list(sequences.iterate(cn))
+
+    # Repack iterator values and then run it the normal way. This is
+    # necessary, because `reversed` is a function and autocompletion
+    # would fail in certain cases like `reversed(x).__iter__` if we
+    # just returned the result directly.
+    seq, = value.inference_state.typing_module.py__getattribute__('Iterator').execute_with_values()
+    return ValueSet([ReversedObject(seq, list(reversed(ordered)))])
+
+
+@argument_clinic('value, type, /', want_arguments=True, want_inference_state=True)
+def builtins_isinstance(objects, types, arguments, inference_state):
+    bool_results = set()
+    for o in objects:
+        cls = o.py__class__()
+        try:
+            cls.py__bases__
+        except AttributeError:
+            # This is temporary. Everything should have a class attribute in
+            # Python?! Maybe we'll leave it here, because some numpy objects or
+            # whatever might not.
+            bool_results = set([True, False])
+            break
+
+        mro = list(cls.py__mro__())
+
+        for cls_or_tup in types:
+            if cls_or_tup.is_class():
+                bool_results.add(cls_or_tup in mro)
+            elif cls_or_tup.name.string_name == 'tuple' \
+                    and cls_or_tup.get_root_context().is_builtins_module():
+                # Check for tuples.
+                classes = ValueSet.from_sets(
+                    lazy_value.infer()
+                    for lazy_value in cls_or_tup.iterate()
+                )
+                bool_results.add(any(cls in mro for cls in classes))
+            else:
+                _, lazy_value = list(arguments.unpack())[1]
+                if isinstance(lazy_value, LazyTreeValue):
+                    node = lazy_value.data
+                    message = 'TypeError: isinstance() arg 2 must be a ' \
+                              'class, type, or tuple of classes and types, ' \
+                              'not %s.' % cls_or_tup
+                    analysis.add(lazy_value.context, 'type-error-isinstance', node, message)
+
+    return ValueSet(
+        compiled.builtin_from_name(inference_state, str(b))
+        for b in bool_results
+    )
+
+
+class StaticMethodObject(ValueWrapper):
+    def py__get__(self, instance, class_value):
+        return ValueSet([self._wrapped_value])
+
+
+@argument_clinic('sequence, /')
+def builtins_staticmethod(functions):
+    return ValueSet(StaticMethodObject(f) for f in functions)
+
+
+class ClassMethodObject(ValueWrapper):
+    def __init__(self, class_method_obj, function):
+        super().__init__(class_method_obj)
+        self._function = function
+
+    def py__get__(self, instance, class_value):
+        return ValueSet([
+            ClassMethodGet(__get__, class_value, self._function)
+            for __get__ in self._wrapped_value.py__getattribute__('__get__')
+        ])
+
+
+class ClassMethodGet(ValueWrapper):
+    def __init__(self, get_method, klass, function):
+        super().__init__(get_method)
+        self._class = klass
+        self._function = function
+
+    def get_signatures(self):
+        return [sig.bind(self._function) for sig in self._function.get_signatures()]
+
+    def py__call__(self, arguments):
+        return self._function.execute(ClassMethodArguments(self._class, arguments))
+
+
+class ClassMethodArguments(TreeArgumentsWrapper):
+    def __init__(self, klass, arguments):
+        super().__init__(arguments)
+        self._class = klass
+
+    def unpack(self, func=None):
+        yield None, LazyKnownValue(self._class)
+        for values in self._wrapped_arguments.unpack(func):
+            yield values
+
+
+@argument_clinic('sequence, /', want_value=True, want_arguments=True)
+def builtins_classmethod(functions, value, arguments):
+    return ValueSet(
+        ClassMethodObject(class_method_object, function)
+        for class_method_object in value.py__call__(arguments=arguments)
+        for function in functions
+    )
+
+
+class PropertyObject(AttributeOverwrite, ValueWrapper):
+    api_type = 'property'
+
+    def __init__(self, property_obj, function):
+        super().__init__(property_obj)
+        self._function = function
+
+    def py__get__(self, instance, class_value):
+        if instance is None:
+            return ValueSet([self])
+        return self._function.execute_with_values(instance)
+
+    @publish_method('deleter')
+    @publish_method('getter')
+    @publish_method('setter')
+    def _return_self(self, arguments):
+        return ValueSet({self})
+
+
+@argument_clinic('func, /', want_callback=True)
+def builtins_property(functions, callback):
+    return ValueSet(
+        PropertyObject(property_value, function)
+        for property_value in callback()
+        for function in functions
+    )
+
+
+def collections_namedtuple(value, arguments, callback):
+    """
+    Implementation of the namedtuple function.
+
+    This has to be done by processing the namedtuple class template and
+    inferring the result.
+
+    """
+    inference_state = value.inference_state
+
+    # Process arguments
+    name = 'jedi_unknown_namedtuple'
+    for c in _follow_param(inference_state, arguments, 0):
+        x = get_str_or_none(c)
+        if x is not None:
+            name = x
+            break
+
+    # TODO here we only use one of the types, we should use all.
+    param_values = _follow_param(inference_state, arguments, 1)
+    if not param_values:
+        return NO_VALUES
+    _fields = list(param_values)[0]
+    string = get_str_or_none(_fields)
+    if string is not None:
+        fields = string.replace(',', ' ').split()
+    elif isinstance(_fields, iterable.Sequence):
+        fields = [
+            get_str_or_none(v)
+            for lazy_value in _fields.py__iter__()
+            for v in lazy_value.infer()
+        ]
+        fields = [f for f in fields if f is not None]
+    else:
+        return NO_VALUES
+
+    # Build source code
+    code = _NAMEDTUPLE_CLASS_TEMPLATE.format(
+        typename=name,
+        field_names=tuple(fields),
+        num_fields=len(fields),
+        arg_list=repr(tuple(fields)).replace("'", "")[1:-1],
+        repr_fmt='',
+        field_defs='\n'.join(_NAMEDTUPLE_FIELD_TEMPLATE.format(index=index, name=name)
+                             for index, name in enumerate(fields))
+    )
+
+    # Parse source code
+    module = inference_state.grammar.parse(code)
+    generated_class = next(module.iter_classdefs())
+    parent_context = ModuleValue(
+        inference_state, module,
+        code_lines=parso.split_lines(code, keepends=True),
+    ).as_context()
+
+    return ValueSet([ClassValue(inference_state, parent_context, generated_class)])
+
+
+class PartialObject(ValueWrapper):
+    def __init__(self, actual_value, arguments, instance=None):
+        super().__init__(actual_value)
+        self._arguments = arguments
+        self._instance = instance
+
+    def _get_functions(self, unpacked_arguments):
+        key, lazy_value = next(unpacked_arguments, (None, None))
+        if key is not None or lazy_value is None:
+            debug.warning("Partial should have a proper function %s", self._arguments)
+            return None
+        return lazy_value.infer()
+
+    def get_signatures(self):
+        unpacked_arguments = self._arguments.unpack()
+        funcs = self._get_functions(unpacked_arguments)
+        if funcs is None:
+            return []
+
+        arg_count = 0
+        if self._instance is not None:
+            arg_count = 1
+        keys = set()
+        for key, _ in unpacked_arguments:
+            if key is None:
+                arg_count += 1
+            else:
+                keys.add(key)
+        return [PartialSignature(s, arg_count, keys) for s in funcs.get_signatures()]
+
+    def py__call__(self, arguments):
+        funcs = self._get_functions(self._arguments.unpack())
+        if funcs is None:
+            return NO_VALUES
+
+        return funcs.execute(
+            MergedPartialArguments(self._arguments, arguments, self._instance)
+        )
+
+    def py__doc__(self):
+        """
+        In CPython partial does not replace the docstring. However we are still
+        imitating it here, because we want this docstring to be worth something
+        for the user.
+        """
+        callables = self._get_functions(self._arguments.unpack())
+        if callables is None:
+            return ''
+        for callable_ in callables:
+            return callable_.py__doc__()
+        return ''
+
+    def py__get__(self, instance, class_value):
+        return ValueSet([self])
+
+
+class PartialMethodObject(PartialObject):
+    def py__get__(self, instance, class_value):
+        if instance is None:
+            return ValueSet([self])
+        return ValueSet([PartialObject(self._wrapped_value, self._arguments, instance)])
+
+
+class PartialSignature(SignatureWrapper):
+    def __init__(self, wrapped_signature, skipped_arg_count, skipped_arg_set):
+        super().__init__(wrapped_signature)
+        self._skipped_arg_count = skipped_arg_count
+        self._skipped_arg_set = skipped_arg_set
+
+    def get_param_names(self, resolve_stars=False):
+        names = self._wrapped_signature.get_param_names()[self._skipped_arg_count:]
+        return [n for n in names if n.string_name not in self._skipped_arg_set]
+
+
+class MergedPartialArguments(AbstractArguments):
+    def __init__(self, partial_arguments, call_arguments, instance=None):
+        self._partial_arguments = partial_arguments
+        self._call_arguments = call_arguments
+        self._instance = instance
+
+    def unpack(self, funcdef=None):
+        unpacked = self._partial_arguments.unpack(funcdef)
+        # Ignore this one, it's the function. It was checked before that it's
+        # there.
+        next(unpacked, None)
+        if self._instance is not None:
+            yield None, LazyKnownValue(self._instance)
+        for key_lazy_value in unpacked:
+            yield key_lazy_value
+        for key_lazy_value in self._call_arguments.unpack(funcdef):
+            yield key_lazy_value
+
+
+def functools_partial(value, arguments, callback):
+    return ValueSet(
+        PartialObject(instance, arguments)
+        for instance in value.py__call__(arguments)
+    )
+
+
+def functools_partialmethod(value, arguments, callback):
+    return ValueSet(
+        PartialMethodObject(instance, arguments)
+        for instance in value.py__call__(arguments)
+    )
+
+
+@argument_clinic('first, /')
+def _return_first_param(firsts):
+    return firsts
+
+
+@argument_clinic('seq')
+def _random_choice(sequences):
+    return ValueSet.from_sets(
+        lazy_value.infer()
+        for sequence in sequences
+        for lazy_value in sequence.py__iter__()
+    )
+
+
+def _dataclass(value, arguments, callback):
+    for c in _follow_param(value.inference_state, arguments, 0):
+        if c.is_class():
+            return ValueSet([DataclassWrapper(c)])
+        else:
+            return ValueSet([value])
+    return NO_VALUES
+
+
+class DataclassWrapper(ValueWrapper, ClassMixin):
+    def get_signatures(self):
+        param_names = []
+        for cls in reversed(list(self.py__mro__())):
+            if isinstance(cls, DataclassWrapper):
+                filter_ = cls.as_context().get_global_filter()
+                # .values ordering is not guaranteed, at least not in
+                # Python < 3.6, when dicts where not ordered, which is an
+                # implementation detail anyway.
+                for name in sorted(filter_.values(), key=lambda name: name.start_pos):
+                    d = name.tree_name.get_definition()
+                    annassign = d.children[1]
+                    if d.type == 'expr_stmt' and annassign.type == 'annassign':
+                        if len(annassign.children) < 4:
+                            default = None
+                        else:
+                            default = annassign.children[3]
+                        param_names.append(DataclassParamName(
+                            parent_context=cls.parent_context,
+                            tree_name=name.tree_name,
+                            annotation_node=annassign.children[1],
+                            default_node=default,
+                        ))
+        return [DataclassSignature(cls, param_names)]
+
+
+class DataclassSignature(AbstractSignature):
+    def __init__(self, value, param_names):
+        super().__init__(value)
+        self._param_names = param_names
+
+    def get_param_names(self, resolve_stars=False):
+        return self._param_names
+
+
+class DataclassParamName(BaseTreeParamName):
+    def __init__(self, parent_context, tree_name, annotation_node, default_node):
+        super().__init__(parent_context, tree_name)
+        self.annotation_node = annotation_node
+        self.default_node = default_node
+
+    def get_kind(self):
+        return Parameter.POSITIONAL_OR_KEYWORD
+
+    def infer(self):
+        if self.annotation_node is None:
+            return NO_VALUES
+        else:
+            return self.parent_context.infer_node(self.annotation_node)
+
+
+class ItemGetterCallable(ValueWrapper):
+    def __init__(self, instance, args_value_set):
+        super().__init__(instance)
+        self._args_value_set = args_value_set
+
+    @repack_with_argument_clinic('item, /')
+    def py__call__(self, item_value_set):
+        value_set = NO_VALUES
+        for args_value in self._args_value_set:
+            lazy_values = list(args_value.py__iter__())
+            if len(lazy_values) == 1:
+                # TODO we need to add the contextualized value.
+                value_set |= item_value_set.get_item(lazy_values[0].infer(), None)
+            else:
+                value_set |= ValueSet([iterable.FakeList(
+                    self._wrapped_value.inference_state,
+                    [
+                        LazyKnownValues(item_value_set.get_item(lazy_value.infer(), None))
+                        for lazy_value in lazy_values
+                    ],
+                )])
+        return value_set
+
+
+@argument_clinic('func, /')
+def _functools_wraps(funcs):
+    return ValueSet(WrapsCallable(func) for func in funcs)
+
+
+class WrapsCallable(ValueWrapper):
+    # XXX this is not the correct wrapped value, it should be a weird
+    #     partials object, but it doesn't matter, because it's always used as a
+    #     decorator anyway.
+    @repack_with_argument_clinic('func, /')
+    def py__call__(self, funcs):
+        return ValueSet({Wrapped(func, self._wrapped_value) for func in funcs})
+
+
+class Wrapped(ValueWrapper, FunctionMixin):
+    def __init__(self, func, original_function):
+        super().__init__(func)
+        self._original_function = original_function
+
+    @property
+    def name(self):
+        return self._original_function.name
+
+    def get_signature_functions(self):
+        return [self]
+
+
+@argument_clinic('*args, /', want_value=True, want_arguments=True)
+def _operator_itemgetter(args_value_set, value, arguments):
+    return ValueSet([
+        ItemGetterCallable(instance, args_value_set)
+        for instance in value.py__call__(arguments)
+    ])
+
+
+def _create_string_input_function(func):
+    @argument_clinic('string, /', want_value=True, want_arguments=True)
+    def wrapper(strings, value, arguments):
+        def iterate():
+            for value in strings:
+                s = get_str_or_none(value)
+                if s is not None:
+                    s = func(s)
+                    yield compiled.create_simple_object(value.inference_state, s)
+        values = ValueSet(iterate())
+        if values:
+            return values
+        return value.py__call__(arguments)
+    return wrapper
+
+
+@argument_clinic('*args, /', want_callback=True)
+def _os_path_join(args_set, callback):
+    if len(args_set) == 1:
+        string = ''
+        sequence, = args_set
+        is_first = True
+        for lazy_value in sequence.py__iter__():
+            string_values = lazy_value.infer()
+            if len(string_values) != 1:
+                break
+            s = get_str_or_none(next(iter(string_values)))
+            if s is None:
+                break
+            if not is_first:
+                string += os.path.sep
+            string += s
+            is_first = False
+        else:
+            return ValueSet([compiled.create_simple_object(sequence.inference_state, string)])
+    return callback()
+
+
+_implemented = {
+    'builtins': {
+        'getattr': builtins_getattr,
+        'type': builtins_type,
+        'super': builtins_super,
+        'reversed': builtins_reversed,
+        'isinstance': builtins_isinstance,
+        'next': builtins_next,
+        'iter': builtins_iter,
+        'staticmethod': builtins_staticmethod,
+        'classmethod': builtins_classmethod,
+        'property': builtins_property,
+    },
+    'copy': {
+        'copy': _return_first_param,
+        'deepcopy': _return_first_param,
+    },
+    'json': {
+        'load': lambda value, arguments, callback: NO_VALUES,
+        'loads': lambda value, arguments, callback: NO_VALUES,
+    },
+    'collections': {
+        'namedtuple': collections_namedtuple,
+    },
+    'functools': {
+        'partial': functools_partial,
+        'partialmethod': functools_partialmethod,
+        'wraps': _functools_wraps,
+    },
+    '_weakref': {
+        'proxy': _return_first_param,
+    },
+    'random': {
+        'choice': _random_choice,
+    },
+    'operator': {
+        'itemgetter': _operator_itemgetter,
+    },
+    'abc': {
+        # Not sure if this is necessary, but it's used a lot in typeshed and
+        # it's for now easier to just pass the function.
+        'abstractmethod': _return_first_param,
+    },
+    'typing': {
+        # The _alias function just leads to some annoying type inference.
+        # Therefore, just make it return nothing, which leads to the stubs
+        # being used instead. This only matters for 3.7+.
+        '_alias': lambda value, arguments, callback: NO_VALUES,
+        # runtime_checkable doesn't really change anything and is just
+        # adding logs for infering stuff, so we can safely ignore it.
+        'runtime_checkable': lambda value, arguments, callback: NO_VALUES,
+    },
+    'dataclasses': {
+        # For now this works at least better than Jedi trying to understand it.
+        'dataclass': _dataclass
+    },
+    # attrs exposes declaration interface roughly compatible with dataclasses
+    # via attrs.define, attrs.frozen and attrs.mutable
+    # https://www.attrs.org/en/stable/names.html
+    'attr': {
+        'define': _dataclass,
+        'frozen': _dataclass,
+    },
+    'attrs': {
+        'define': _dataclass,
+        'frozen': _dataclass,
+    },
+    'os.path': {
+        'dirname': _create_string_input_function(os.path.dirname),
+        'abspath': _create_string_input_function(os.path.abspath),
+        'relpath': _create_string_input_function(os.path.relpath),
+        'join': _os_path_join,
+    }
+}
+
+
+def get_metaclass_filters(func):
+    def wrapper(cls, metaclasses, is_instance):
+        for metaclass in metaclasses:
+            if metaclass.py__name__() == 'EnumMeta' \
+                    and metaclass.get_root_context().py__name__() == 'enum':
+                filter_ = ParserTreeFilter(parent_context=cls.as_context())
+                return [DictFilter({
+                    name.string_name: EnumInstance(cls, name).name
+                    for name in filter_.values()
+                })]
+        return func(cls, metaclasses, is_instance)
+    return wrapper
+
+
+class EnumInstance(LazyValueWrapper):
+    def __init__(self, cls, name):
+        self.inference_state = cls.inference_state
+        self._cls = cls  # Corresponds to super().__self__
+        self._name = name
+        self.tree_node = self._name.tree_name
+
+    @safe_property
+    def name(self):
+        return ValueName(self, self._name.tree_name)
+
+    def _get_wrapped_value(self):
+        n = self._name.string_name
+        if n.startswith('__') and n.endswith('__') or self._name.api_type == 'function':
+            inferred = self._name.infer()
+            if inferred:
+                return next(iter(inferred))
+            o, = self.inference_state.builtins_module.py__getattribute__('object')
+            return o
+
+        value, = self._cls.execute_with_values()
+        return value
+
+    def get_filters(self, origin_scope=None):
+        yield DictFilter(dict(
+            name=compiled.create_simple_object(self.inference_state, self._name.string_name).name,
+            value=self._name,
+        ))
+        for f in self._get_wrapped_value().get_filters():
+            yield f
+
+
+def tree_name_to_values(func):
+    def wrapper(inference_state, context, tree_name):
+        if tree_name.value == 'sep' and context.is_module() and context.py__name__() == 'os.path':
+            return ValueSet({
+                compiled.create_simple_object(inference_state, os.path.sep),
+            })
+        return func(inference_state, context, tree_name)
+    return wrapper

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/backends/base/base.pyi

@@ -0,0 +1,102 @@
+from typing import Any, Callable, Dict, Iterator, List, Optional
+
+from django.db.backends.base.client import BaseDatabaseClient
+from django.db.backends.base.creation import BaseDatabaseCreation
+from django.db.backends.base.validation import BaseDatabaseValidation
+from django.db.backends.utils import CursorDebugWrapper, CursorWrapper
+
+from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+
+from django.db.backends.base.features import BaseDatabaseFeatures
+
+from django.db.backends.base.introspection import BaseDatabaseIntrospection
+
+NO_DB_ALIAS: str
+
+class BaseDatabaseWrapper:
+    data_types: Any = ...
+    data_types_suffix: Any = ...
+    data_type_check_constraints: Any = ...
+    ops: Any = ...
+    vendor: str = ...
+    display_name: str = ...
+    SchemaEditorClass: Optional[BaseDatabaseSchemaEditor] = ...
+    client_class: Any = ...
+    creation_class: Any = ...
+    features_class: Any = ...
+    introspection_class: Any = ...
+    ops_class: Any = ...
+    validation_class: Any = ...
+    queries_limit: int = ...
+    connection: Any = ...
+    settings_dict: Any = ...
+    alias: str = ...
+    queries_log: Any = ...
+    force_debug_cursor: bool = ...
+    autocommit: bool = ...
+    in_atomic_block: bool = ...
+    savepoint_state: int = ...
+    savepoint_ids: Any = ...
+    commit_on_exit: bool = ...
+    needs_rollback: bool = ...
+    close_at: Optional[Any] = ...
+    closed_in_transaction: bool = ...
+    errors_occurred: bool = ...
+    allow_thread_sharing: bool = ...
+    run_on_commit: List[Any] = ...
+    run_commit_hooks_on_set_autocommit_on: bool = ...
+    execute_wrappers: List[Any] = ...
+    client: BaseDatabaseClient = ...
+    creation: BaseDatabaseCreation = ...
+    features: BaseDatabaseFeatures = ...
+    introspection: BaseDatabaseIntrospection = ...
+    validation: BaseDatabaseValidation = ...
+    def __init__(
+        self, settings_dict: Dict[str, Dict[str, str]], alias: str = ..., allow_thread_sharing: bool = ...
+    ) -> None: ...
+    def ensure_timezone(self) -> bool: ...
+    def timezone(self): ...
+    def timezone_name(self): ...
+    @property
+    def queries_logged(self) -> bool: ...
+    @property
+    def queries(self) -> List[Dict[str, str]]: ...
+    def get_connection_params(self) -> None: ...
+    def get_new_connection(self, conn_params: Any) -> None: ...
+    def init_connection_state(self) -> None: ...
+    def create_cursor(self, name: Optional[Any] = ...) -> None: ...
+    def connect(self) -> None: ...
+    def check_settings(self) -> None: ...
+    def ensure_connection(self) -> None: ...
+    def cursor(self) -> CursorWrapper: ...
+    def commit(self) -> None: ...
+    def rollback(self) -> None: ...
+    def close(self) -> None: ...
+    def savepoint(self) -> str: ...
+    def savepoint_rollback(self, sid: str) -> None: ...
+    def savepoint_commit(self, sid: str) -> None: ...
+    def clean_savepoints(self) -> None: ...
+    def get_autocommit(self) -> bool: ...
+    def set_autocommit(self, autocommit: bool, force_begin_transaction_with_broken_autocommit: bool = ...) -> None: ...
+    def get_rollback(self) -> bool: ...
+    def set_rollback(self, rollback: bool) -> None: ...
+    def validate_no_atomic_block(self) -> None: ...
+    def validate_no_broken_transaction(self) -> None: ...
+    def constraint_checks_disabled(self) -> Iterator[None]: ...
+    def disable_constraint_checking(self): ...
+    def enable_constraint_checking(self) -> None: ...
+    def check_constraints(self, table_names: Optional[Any] = ...) -> None: ...
+    def is_usable(self) -> None: ...
+    def close_if_unusable_or_obsolete(self) -> None: ...
+    def validate_thread_sharing(self) -> None: ...
+    def prepare_database(self) -> None: ...
+    def wrap_database_errors(self) -> Any: ...
+    def chunked_cursor(self) -> CursorWrapper: ...
+    def make_debug_cursor(self, cursor: CursorWrapper) -> CursorDebugWrapper: ...
+    def make_cursor(self, cursor: CursorWrapper) -> CursorWrapper: ...
+    def temporary_connection(self) -> None: ...
+    def schema_editor(self, *args: Any, **kwargs: Any) -> BaseDatabaseSchemaEditor: ...
+    def on_commit(self, func: Callable) -> None: ...
+    def run_and_clear_commit_hooks(self) -> None: ...
+    def execute_wrapper(self, wrapper: Callable) -> Iterator[None]: ...
+    def copy(self, alias: None = ..., allow_thread_sharing: None = ...) -> Any: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/backends/base/client.pyi

@@ -0,0 +1,9 @@
+from typing import Any
+
+from django.db.backends.base.base import BaseDatabaseWrapper
+
+class BaseDatabaseClient:
+    executable_name: Any = ...
+    connection: Any = ...
+    def __init__(self, connection: BaseDatabaseWrapper) -> None: ...
+    def runshell(self) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/backends/base/creation.pyi

@@ -0,0 +1,24 @@
+from typing import Any, Dict, Optional, Tuple, Union
+
+from django.db.backends.base.base import BaseDatabaseWrapper
+
+TEST_DATABASE_PREFIX: str
+
+class BaseDatabaseCreation:
+    connection: Any = ...
+    def __init__(self, connection: BaseDatabaseWrapper) -> None: ...
+    def create_test_db(
+        self, verbosity: int = ..., autoclobber: bool = ..., serialize: bool = ..., keepdb: bool = ...
+    ) -> str: ...
+    def set_as_test_mirror(
+        self, primary_settings_dict: Dict[str, Optional[Union[Dict[str, None], int, str]]]
+    ) -> None: ...
+    def serialize_db_to_string(self) -> str: ...
+    def deserialize_db_from_string(self, data: str) -> None: ...
+    def clone_test_db(self, suffix: Any, verbosity: int = ..., autoclobber: bool = ..., keepdb: bool = ...) -> None: ...
+    def get_test_db_clone_settings(self, suffix: Any): ...
+    def destroy_test_db(
+        self, old_database_name: str = ..., verbosity: int = ..., keepdb: bool = ..., suffix: None = ...
+    ) -> None: ...
+    def sql_table_creation_suffix(self): ...
+    def test_db_signature(self) -> Tuple[str, str, str, str]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/backends/base/introspection.pyi

@@ -0,0 +1,27 @@
+from collections import namedtuple
+from typing import Any, Dict, List, Optional, Set, Type
+
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.db.backends.utils import CursorWrapper
+from django.db.models.base import Model
+
+TableInfo = namedtuple("TableInfo", ["name", "type"])
+
+FieldInfo = namedtuple("FieldInfo", "name type_code display_size internal_size precision scale null_ok default")
+
+class BaseDatabaseIntrospection:
+    data_types_reverse: Any = ...
+    connection: Any = ...
+    def __init__(self, connection: BaseDatabaseWrapper) -> None: ...
+    def get_field_type(self, data_type: str, description: FieldInfo) -> str: ...
+    def table_name_converter(self, name: str) -> str: ...
+    def column_name_converter(self, name: str) -> str: ...
+    def table_names(self, cursor: Optional[CursorWrapper] = ..., include_views: bool = ...) -> List[str]: ...
+    def get_table_list(self, cursor: Any) -> None: ...
+    def django_table_names(self, only_existing: bool = ..., include_views: bool = ...) -> List[str]: ...
+    def installed_models(self, tables: List[str]) -> Set[Type[Model]]: ...
+    def sequence_list(self) -> List[Dict[str, str]]: ...
+    def get_sequences(self, cursor: Any, table_name: Any, table_fields: Any = ...) -> None: ...
+    def get_key_columns(self, cursor: Any, table_name: Any) -> None: ...
+    def get_primary_key_column(self, cursor: Any, table_name: Any): ...
+    def get_constraints(self, cursor: Any, table_name: Any) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/backends/base/operations.pyi

@@ -0,0 +1,104 @@
+from datetime import date, datetime, timedelta, time
+from decimal import Decimal
+from typing import Any, List, Optional, Sequence, Tuple, Type, Union
+
+from django.core.management.color import Style
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.db.backends.utils import CursorWrapper
+from django.db.models.base import Model
+from django.db.models.expressions import Case, Expression
+from django.db.models.sql.compiler import SQLCompiler
+
+from django.db import DefaultConnectionProxy
+from django.db.models.fields import Field
+
+_Connection = Union[DefaultConnectionProxy, BaseDatabaseWrapper]
+
+class BaseDatabaseOperations:
+    compiler_module: str = ...
+    integer_field_ranges: Any = ...
+    set_operators: Any = ...
+    cast_data_types: Any = ...
+    cast_char_field_without_max_length: Any = ...
+    PRECEDING: str = ...
+    FOLLOWING: str = ...
+    UNBOUNDED_PRECEDING: Any = ...
+    UNBOUNDED_FOLLOWING: Any = ...
+    CURRENT_ROW: str = ...
+    explain_prefix: Any = ...
+    connection: _Connection = ...
+    def __init__(self, connection: Optional[_Connection]) -> None: ...
+    def autoinc_sql(self, table: str, column: str) -> None: ...
+    def bulk_batch_size(self, fields: Any, objs: Any): ...
+    def cache_key_culling_sql(self) -> str: ...
+    def unification_cast_sql(self, output_field: Field) -> str: ...
+    def date_extract_sql(self, lookup_type: None, field_name: None) -> Any: ...
+    def date_interval_sql(self, timedelta: None) -> Any: ...
+    def date_trunc_sql(self, lookup_type: None, field_name: None) -> Any: ...
+    def datetime_cast_date_sql(self, field_name: None, tzname: None) -> Any: ...
+    def datetime_cast_time_sql(self, field_name: None, tzname: None) -> Any: ...
+    def datetime_extract_sql(self, lookup_type: None, field_name: None, tzname: None) -> Any: ...
+    def datetime_trunc_sql(self, lookup_type: None, field_name: None, tzname: None) -> Any: ...
+    def time_trunc_sql(self, lookup_type: None, field_name: None) -> Any: ...
+    def time_extract_sql(self, lookup_type: None, field_name: None) -> Any: ...
+    def deferrable_sql(self) -> str: ...
+    def distinct_sql(self, fields: List[str], params: Optional[List[Any]]) -> Tuple[List[str], List[Any]]: ...
+    def fetch_returned_insert_id(self, cursor: Any): ...
+    def field_cast_sql(self, db_type: Optional[str], internal_type: str) -> str: ...
+    def force_no_ordering(self) -> List[Any]: ...
+    def for_update_sql(self, nowait: bool = ..., skip_locked: bool = ..., of: Any = ...): ...
+    def limit_offset_sql(self, low_mark: int, high_mark: Optional[int]) -> str: ...
+    def last_executed_query(self, cursor: Any, sql: Any, params: Any): ...
+    def last_insert_id(self, cursor: CursorWrapper, table_name: str, pk_name: str) -> int: ...
+    def lookup_cast(self, lookup_type: str, internal_type: str = ...) -> str: ...
+    def max_in_list_size(self) -> None: ...
+    def max_name_length(self) -> None: ...
+    def no_limit_value(self) -> Any: ...
+    def pk_default_value(self) -> str: ...
+    def prepare_sql_script(self, sql: Any): ...
+    def process_clob(self, value: str) -> str: ...
+    def return_insert_id(self) -> None: ...
+    def compiler(self, compiler_name: str) -> Type[SQLCompiler]: ...
+    def quote_name(self, name: str) -> Any: ...
+    def random_function_sql(self): ...
+    def regex_lookup(self, lookup_type: str) -> Any: ...
+    def savepoint_create_sql(self, sid: str) -> str: ...
+    def savepoint_commit_sql(self, sid: str) -> str: ...
+    def savepoint_rollback_sql(self, sid: str) -> str: ...
+    def set_time_zone_sql(self) -> str: ...
+    def sql_flush(self, style: None, tables: None, sequences: None, allow_cascade: bool = ...) -> Any: ...
+    def execute_sql_flush(self, using: str, sql_list: List[str]) -> None: ...
+    def sequence_reset_by_name_sql(self, style: None, sequences: List[Any]) -> List[Any]: ...
+    def sequence_reset_sql(self, style: Style, model_list: Sequence[Type[Model]]) -> List[Any]: ...
+    def start_transaction_sql(self) -> str: ...
+    def end_transaction_sql(self, success: bool = ...) -> str: ...
+    def tablespace_sql(self, tablespace: Optional[str], inline: bool = ...) -> str: ...
+    def prep_for_like_query(self, x: str) -> str: ...
+    prep_for_iexact_query: Any = ...
+    def validate_autopk_value(self, value: int) -> int: ...
+    def adapt_unknown_value(self, value: Any) -> Any: ...
+    def adapt_datefield_value(self, value: Optional[date]) -> Optional[str]: ...
+    def adapt_datetimefield_value(self, value: Optional[datetime]) -> Optional[str]: ...
+    def adapt_timefield_value(self, value: Optional[Union[datetime, time]]) -> Optional[str]: ...
+    def adapt_decimalfield_value(
+        self, value: Optional[Decimal], max_digits: Optional[int] = ..., decimal_places: Optional[int] = ...
+    ) -> Optional[str]: ...
+    def adapt_ipaddressfield_value(self, value: Optional[str]) -> Optional[str]: ...
+    def year_lookup_bounds_for_date_field(self, value: int) -> List[str]: ...
+    def year_lookup_bounds_for_datetime_field(self, value: int) -> List[str]: ...
+    def get_db_converters(self, expression: Expression) -> List[Any]: ...
+    def convert_durationfield_value(
+        self, value: Optional[float], expression: Expression, connection: _Connection
+    ) -> Optional[timedelta]: ...
+    def check_expression_support(self, expression: Any) -> None: ...
+    def combine_expression(self, connector: str, sub_expressions: List[str]) -> str: ...
+    def combine_duration_expression(self, connector: Any, sub_expressions: Any): ...
+    def binary_placeholder_sql(self, value: Optional[Case]) -> str: ...
+    def modify_insert_params(self, placeholder: str, params: Any) -> Any: ...
+    def integer_field_range(self, internal_type: Any): ...
+    def subtract_temporals(self, internal_type: Any, lhs: Any, rhs: Any): ...
+    def window_frame_start(self, start: Any): ...
+    def window_frame_end(self, end: Any): ...
+    def window_frame_rows_start_end(self, start: Optional[int] = ..., end: Optional[int] = ...) -> Any: ...
+    def window_frame_range_start_end(self, start: Optional[int] = ..., end: Optional[int] = ...) -> Any: ...
+    def explain_query_prefix(self, format: Optional[str] = ..., **options: Any) -> str: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/backends/dummy/base.pyi

@@ -0,0 +1,31 @@
+from typing import Any
+
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.db.backends.base.client import BaseDatabaseClient
+from django.db.backends.base.creation import BaseDatabaseCreation
+from django.db.backends.base.introspection import BaseDatabaseIntrospection
+from django.db.backends.base.operations import BaseDatabaseOperations
+
+def complain(*args: Any, **kwargs: Any) -> Any: ...
+def ignore(*args: Any, **kwargs: Any) -> None: ...
+
+class DatabaseOperations(BaseDatabaseOperations):
+    quote_name: Any = ...
+
+class DatabaseClient(BaseDatabaseClient):
+    runshell: Any = ...
+
+class DatabaseCreation(BaseDatabaseCreation):
+    create_test_db: Any = ...
+    destroy_test_db: Any = ...
+
+class DatabaseIntrospection(BaseDatabaseIntrospection):
+    get_table_list: Any = ...
+    get_table_description: Any = ...
+    get_relations: Any = ...
+    get_indexes: Any = ...
+    get_key_columns: Any = ...
+
+class DatabaseWrapper(BaseDatabaseWrapper):
+    operators: Any = ...
+    ensure_connection: Any = ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/features.pyi

@@ -0,0 +1,3 @@
+from django.db.backends.base.features import BaseDatabaseFeatures
+
+class DatabaseFeatures(BaseDatabaseFeatures): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/operations.pyi

@@ -0,0 +1,3 @@
+from django.db.backends.base.operations import BaseDatabaseOperations
+
+class DatabaseOperations(BaseDatabaseOperations): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/asyncio/base_futures.pyi

@@ -0,0 +1,22 @@
+import sys
+from typing import Any, Callable, List, Sequence, Tuple
+from typing_extensions import Literal
+
+if sys.version_info >= (3, 7):
+    from contextvars import Context
+
+from . import futures
+
+_PENDING: Literal["PENDING"]  # undocumented
+_CANCELLED: Literal["CANCELLED"]  # undocumented
+_FINISHED: Literal["FINISHED"]  # undocumented
+
+def isfuture(obj: object) -> bool: ...
+
+if sys.version_info >= (3, 7):
+    def _format_callbacks(cb: Sequence[Tuple[Callable[[futures.Future[Any]], None], Context]]) -> str: ...  # undocumented
+
+else:
+    def _format_callbacks(cb: Sequence[Callable[[futures.Future[Any]], None]]) -> str: ...  # undocumented
+
+def _future_repr_info(future: futures.Future[Any]) -> List[str]: ...  # undocumented

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/asyncio/events.pyi

@@ -0,0 +1,502 @@
+import ssl
+import sys
+from _typeshed import FileDescriptorLike
+from abc import ABCMeta, abstractmethod
+from asyncio.futures import Future
+from asyncio.protocols import BaseProtocol
+from asyncio.tasks import Task
+from asyncio.transports import BaseTransport
+from asyncio.unix_events import AbstractChildWatcher
+from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket
+from typing import IO, Any, Awaitable, Callable, Dict, Generator, List, Optional, Sequence, Tuple, TypeVar, Union, overload
+
+if sys.version_info >= (3, 7):
+    from contextvars import Context
+
+_T = TypeVar("_T")
+_Context = Dict[str, Any]
+_ExceptionHandler = Callable[[AbstractEventLoop, _Context], Any]
+_ProtocolFactory = Callable[[], BaseProtocol]
+_SSLContext = Union[bool, None, ssl.SSLContext]
+_TransProtPair = Tuple[BaseTransport, BaseProtocol]
+
+class Handle:
+    _cancelled = False
+    _args: Sequence[Any]
+    if sys.version_info >= (3, 7):
+        def __init__(
+            self, callback: Callable[..., Any], args: Sequence[Any], loop: AbstractEventLoop, context: Optional[Context] = ...
+        ) -> None: ...
+    else:
+        def __init__(self, callback: Callable[..., Any], args: Sequence[Any], loop: AbstractEventLoop) -> None: ...
+    def __repr__(self) -> str: ...
+    def cancel(self) -> None: ...
+    def _run(self) -> None: ...
+    if sys.version_info >= (3, 7):
+        def cancelled(self) -> bool: ...
+
+class TimerHandle(Handle):
+    if sys.version_info >= (3, 7):
+        def __init__(
+            self,
+            when: float,
+            callback: Callable[..., Any],
+            args: Sequence[Any],
+            loop: AbstractEventLoop,
+            context: Optional[Context] = ...,
+        ) -> None: ...
+    else:
+        def __init__(self, when: float, callback: Callable[..., Any], args: Sequence[Any], loop: AbstractEventLoop) -> None: ...
+    def __hash__(self) -> int: ...
+    if sys.version_info >= (3, 7):
+        def when(self) -> float: ...
+
+class AbstractServer:
+    sockets: Optional[List[socket]]
+    def close(self) -> None: ...
+    if sys.version_info >= (3, 7):
+        async def __aenter__(self: _T) -> _T: ...
+        async def __aexit__(self, *exc: Any) -> None: ...
+        def get_loop(self) -> AbstractEventLoop: ...
+        def is_serving(self) -> bool: ...
+        async def start_serving(self) -> None: ...
+        async def serve_forever(self) -> None: ...
+    async def wait_closed(self) -> None: ...
+
+class AbstractEventLoop(metaclass=ABCMeta):
+    slow_callback_duration: float = ...
+    @abstractmethod
+    def run_forever(self) -> None: ...
+    # Can't use a union, see mypy issue  # 1873.
+    @overload
+    @abstractmethod
+    def run_until_complete(self, future: Generator[Any, None, _T]) -> _T: ...
+    @overload
+    @abstractmethod
+    def run_until_complete(self, future: Awaitable[_T]) -> _T: ...
+    @abstractmethod
+    def stop(self) -> None: ...
+    @abstractmethod
+    def is_running(self) -> bool: ...
+    @abstractmethod
+    def is_closed(self) -> bool: ...
+    @abstractmethod
+    def close(self) -> None: ...
+    if sys.version_info >= (3, 6):
+        @abstractmethod
+        async def shutdown_asyncgens(self) -> None: ...
+    # Methods scheduling callbacks.  All these return Handles.
+    @abstractmethod
+    def call_soon(self, callback: Callable[..., Any], *args: Any) -> Handle: ...
+    @abstractmethod
+    def call_later(self, delay: float, callback: Callable[..., Any], *args: Any) -> TimerHandle: ...
+    @abstractmethod
+    def call_at(self, when: float, callback: Callable[..., Any], *args: Any) -> TimerHandle: ...
+    @abstractmethod
+    def time(self) -> float: ...
+    # Future methods
+    @abstractmethod
+    def create_future(self) -> Future[Any]: ...
+    # Tasks methods
+    if sys.version_info >= (3, 8):
+        @abstractmethod
+        def create_task(self, coro: Union[Awaitable[_T], Generator[Any, None, _T]], *, name: Optional[str] = ...) -> Task[_T]: ...
+    else:
+        @abstractmethod
+        def create_task(self, coro: Union[Awaitable[_T], Generator[Any, None, _T]]) -> Task[_T]: ...
+    @abstractmethod
+    def set_task_factory(
+        self, factory: Optional[Callable[[AbstractEventLoop, Generator[Any, None, _T]], Future[_T]]]
+    ) -> None: ...
+    @abstractmethod
+    def get_task_factory(self) -> Optional[Callable[[AbstractEventLoop, Generator[Any, None, _T]], Future[_T]]]: ...
+    # Methods for interacting with threads
+    @abstractmethod
+    def call_soon_threadsafe(self, callback: Callable[..., Any], *args: Any) -> Handle: ...
+    @abstractmethod
+    def run_in_executor(self, executor: Any, func: Callable[..., _T], *args: Any) -> Awaitable[_T]: ...
+    @abstractmethod
+    def set_default_executor(self, executor: Any) -> None: ...
+    # Network I/O methods returning Futures.
+    @abstractmethod
+    async def getaddrinfo(
+        self,
+        host: Optional[str],
+        port: Union[str, int, None],
+        *,
+        family: int = ...,
+        type: int = ...,
+        proto: int = ...,
+        flags: int = ...,
+    ) -> List[Tuple[AddressFamily, SocketKind, int, str, Union[Tuple[str, int], Tuple[str, int, int, int]]]]: ...
+    @abstractmethod
+    async def getnameinfo(
+        self, sockaddr: Union[Tuple[str, int], Tuple[str, int, int, int]], flags: int = ...
+    ) -> Tuple[str, str]: ...
+    if sys.version_info >= (3, 8):
+        @overload
+        @abstractmethod
+        async def create_connection(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str = ...,
+            port: int = ...,
+            *,
+            ssl: _SSLContext = ...,
+            family: int = ...,
+            proto: int = ...,
+            flags: int = ...,
+            sock: None = ...,
+            local_addr: Optional[Tuple[str, int]] = ...,
+            server_hostname: Optional[str] = ...,
+            ssl_handshake_timeout: Optional[float] = ...,
+            happy_eyeballs_delay: Optional[float] = ...,
+            interleave: Optional[int] = ...,
+        ) -> _TransProtPair: ...
+        @overload
+        @abstractmethod
+        async def create_connection(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = ...,
+            port: None = ...,
+            *,
+            ssl: _SSLContext = ...,
+            family: int = ...,
+            proto: int = ...,
+            flags: int = ...,
+            sock: socket,
+            local_addr: None = ...,
+            server_hostname: Optional[str] = ...,
+            ssl_handshake_timeout: Optional[float] = ...,
+            happy_eyeballs_delay: Optional[float] = ...,
+            interleave: Optional[int] = ...,
+        ) -> _TransProtPair: ...
+    elif sys.version_info >= (3, 7):
+        @overload
+        @abstractmethod
+        async def create_connection(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str = ...,
+            port: int = ...,
+            *,
+            ssl: _SSLContext = ...,
+            family: int = ...,
+            proto: int = ...,
+            flags: int = ...,
+            sock: None = ...,
+            local_addr: Optional[Tuple[str, int]] = ...,
+            server_hostname: Optional[str] = ...,
+            ssl_handshake_timeout: Optional[float] = ...,
+        ) -> _TransProtPair: ...
+        @overload
+        @abstractmethod
+        async def create_connection(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = ...,
+            port: None = ...,
+            *,
+            ssl: _SSLContext = ...,
+            family: int = ...,
+            proto: int = ...,
+            flags: int = ...,
+            sock: socket,
+            local_addr: None = ...,
+            server_hostname: Optional[str] = ...,
+            ssl_handshake_timeout: Optional[float] = ...,
+        ) -> _TransProtPair: ...
+    else:
+        @overload
+        @abstractmethod
+        async def create_connection(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str = ...,
+            port: int = ...,
+            *,
+            ssl: _SSLContext = ...,
+            family: int = ...,
+            proto: int = ...,
+            flags: int = ...,
+            sock: None = ...,
+            local_addr: Optional[Tuple[str, int]] = ...,
+            server_hostname: Optional[str] = ...,
+        ) -> _TransProtPair: ...
+        @overload
+        @abstractmethod
+        async def create_connection(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = ...,
+            port: None = ...,
+            *,
+            ssl: _SSLContext = ...,
+            family: int = ...,
+            proto: int = ...,
+            flags: int = ...,
+            sock: socket,
+            local_addr: None = ...,
+            server_hostname: Optional[str] = ...,
+        ) -> _TransProtPair: ...
+    if sys.version_info >= (3, 7):
+        @abstractmethod
+        async def sock_sendfile(
+            self, sock: socket, file: IO[bytes], offset: int = ..., count: Optional[int] = ..., *, fallback: bool = ...
+        ) -> int: ...
+        @overload
+        @abstractmethod
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: Optional[Union[str, Sequence[str]]] = ...,
+            port: int = ...,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: None = ...,
+            backlog: int = ...,
+            ssl: _SSLContext = ...,
+            reuse_address: Optional[bool] = ...,
+            reuse_port: Optional[bool] = ...,
+            ssl_handshake_timeout: Optional[float] = ...,
+            start_serving: bool = ...,
+        ) -> AbstractServer: ...
+        @overload
+        @abstractmethod
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = ...,
+            port: None = ...,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: socket = ...,
+            backlog: int = ...,
+            ssl: _SSLContext = ...,
+            reuse_address: Optional[bool] = ...,
+            reuse_port: Optional[bool] = ...,
+            ssl_handshake_timeout: Optional[float] = ...,
+            start_serving: bool = ...,
+        ) -> AbstractServer: ...
+        async def create_unix_connection(
+            self,
+            protocol_factory: _ProtocolFactory,
+            path: Optional[str] = ...,
+            *,
+            ssl: _SSLContext = ...,
+            sock: Optional[socket] = ...,
+            server_hostname: Optional[str] = ...,
+            ssl_handshake_timeout: Optional[float] = ...,
+        ) -> _TransProtPair: ...
+        async def create_unix_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            path: Optional[str] = ...,
+            *,
+            sock: Optional[socket] = ...,
+            backlog: int = ...,
+            ssl: _SSLContext = ...,
+            ssl_handshake_timeout: Optional[float] = ...,
+            start_serving: bool = ...,
+        ) -> AbstractServer: ...
+        @abstractmethod
+        async def sendfile(
+            self,
+            transport: BaseTransport,
+            file: IO[bytes],
+            offset: int = ...,
+            count: Optional[int] = ...,
+            *,
+            fallback: bool = ...,
+        ) -> int: ...
+        @abstractmethod
+        async def start_tls(
+            self,
+            transport: BaseTransport,
+            protocol: BaseProtocol,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_side: bool = ...,
+            server_hostname: Optional[str] = ...,
+            ssl_handshake_timeout: Optional[float] = ...,
+        ) -> BaseTransport: ...
+    else:
+        @overload
+        @abstractmethod
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: Optional[Union[str, Sequence[str]]] = ...,
+            port: int = ...,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: None = ...,
+            backlog: int = ...,
+            ssl: _SSLContext = ...,
+            reuse_address: Optional[bool] = ...,
+            reuse_port: Optional[bool] = ...,
+        ) -> AbstractServer: ...
+        @overload
+        @abstractmethod
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = ...,
+            port: None = ...,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: socket,
+            backlog: int = ...,
+            ssl: _SSLContext = ...,
+            reuse_address: Optional[bool] = ...,
+            reuse_port: Optional[bool] = ...,
+        ) -> AbstractServer: ...
+        async def create_unix_connection(
+            self,
+            protocol_factory: _ProtocolFactory,
+            path: str,
+            *,
+            ssl: _SSLContext = ...,
+            sock: Optional[socket] = ...,
+            server_hostname: Optional[str] = ...,
+        ) -> _TransProtPair: ...
+        async def create_unix_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            path: str,
+            *,
+            sock: Optional[socket] = ...,
+            backlog: int = ...,
+            ssl: _SSLContext = ...,
+        ) -> AbstractServer: ...
+    @abstractmethod
+    async def create_datagram_endpoint(
+        self,
+        protocol_factory: _ProtocolFactory,
+        local_addr: Optional[Tuple[str, int]] = ...,
+        remote_addr: Optional[Tuple[str, int]] = ...,
+        *,
+        family: int = ...,
+        proto: int = ...,
+        flags: int = ...,
+        reuse_address: Optional[bool] = ...,
+        reuse_port: Optional[bool] = ...,
+        allow_broadcast: Optional[bool] = ...,
+        sock: Optional[socket] = ...,
+    ) -> _TransProtPair: ...
+    # Pipes and subprocesses.
+    @abstractmethod
+    async def connect_read_pipe(self, protocol_factory: _ProtocolFactory, pipe: Any) -> _TransProtPair: ...
+    @abstractmethod
+    async def connect_write_pipe(self, protocol_factory: _ProtocolFactory, pipe: Any) -> _TransProtPair: ...
+    @abstractmethod
+    async def subprocess_shell(
+        self,
+        protocol_factory: _ProtocolFactory,
+        cmd: Union[bytes, str],
+        *,
+        stdin: Any = ...,
+        stdout: Any = ...,
+        stderr: Any = ...,
+        **kwargs: Any,
+    ) -> _TransProtPair: ...
+    @abstractmethod
+    async def subprocess_exec(
+        self,
+        protocol_factory: _ProtocolFactory,
+        *args: Any,
+        stdin: Any = ...,
+        stdout: Any = ...,
+        stderr: Any = ...,
+        **kwargs: Any,
+    ) -> _TransProtPair: ...
+    @abstractmethod
+    def add_reader(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
+    @abstractmethod
+    def remove_reader(self, fd: FileDescriptorLike) -> None: ...
+    @abstractmethod
+    def add_writer(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
+    @abstractmethod
+    def remove_writer(self, fd: FileDescriptorLike) -> None: ...
+    # Completion based I/O methods returning Futures prior to 3.7
+    if sys.version_info >= (3, 7):
+        @abstractmethod
+        async def sock_recv(self, sock: socket, nbytes: int) -> bytes: ...
+        @abstractmethod
+        async def sock_recv_into(self, sock: socket, buf: bytearray) -> int: ...
+        @abstractmethod
+        async def sock_sendall(self, sock: socket, data: bytes) -> None: ...
+        @abstractmethod
+        async def sock_connect(self, sock: socket, address: _Address) -> None: ...
+        @abstractmethod
+        async def sock_accept(self, sock: socket) -> Tuple[socket, _RetAddress]: ...
+    else:
+        @abstractmethod
+        def sock_recv(self, sock: socket, nbytes: int) -> Future[bytes]: ...
+        @abstractmethod
+        def sock_sendall(self, sock: socket, data: bytes) -> Future[None]: ...
+        @abstractmethod
+        def sock_connect(self, sock: socket, address: _Address) -> Future[None]: ...
+        @abstractmethod
+        def sock_accept(self, sock: socket) -> Future[Tuple[socket, _RetAddress]]: ...
+    # Signal handling.
+    @abstractmethod
+    def add_signal_handler(self, sig: int, callback: Callable[..., Any], *args: Any) -> None: ...
+    @abstractmethod
+    def remove_signal_handler(self, sig: int) -> None: ...
+    # Error handlers.
+    @abstractmethod
+    def set_exception_handler(self, handler: Optional[_ExceptionHandler]) -> None: ...
+    @abstractmethod
+    def get_exception_handler(self) -> Optional[_ExceptionHandler]: ...
+    @abstractmethod
+    def default_exception_handler(self, context: _Context) -> None: ...
+    @abstractmethod
+    def call_exception_handler(self, context: _Context) -> None: ...
+    # Debug flag management.
+    @abstractmethod
+    def get_debug(self) -> bool: ...
+    @abstractmethod
+    def set_debug(self, enabled: bool) -> None: ...
+    if sys.version_info >= (3, 9):
+        @abstractmethod
+        async def shutdown_default_executor(self) -> None: ...
+
+class AbstractEventLoopPolicy(metaclass=ABCMeta):
+    @abstractmethod
+    def get_event_loop(self) -> AbstractEventLoop: ...
+    @abstractmethod
+    def set_event_loop(self, loop: Optional[AbstractEventLoop]) -> None: ...
+    @abstractmethod
+    def new_event_loop(self) -> AbstractEventLoop: ...
+    # Child processes handling (Unix only).
+    @abstractmethod
+    def get_child_watcher(self) -> AbstractChildWatcher: ...
+    @abstractmethod
+    def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
+
+class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy, metaclass=ABCMeta):
+    def __init__(self) -> None: ...
+    def get_event_loop(self) -> AbstractEventLoop: ...
+    def set_event_loop(self, loop: Optional[AbstractEventLoop]) -> None: ...
+    def new_event_loop(self) -> AbstractEventLoop: ...
+
+def get_event_loop_policy() -> AbstractEventLoopPolicy: ...
+def set_event_loop_policy(policy: Optional[AbstractEventLoopPolicy]) -> None: ...
+def get_event_loop() -> AbstractEventLoop: ...
+def set_event_loop(loop: Optional[AbstractEventLoop]) -> None: ...
+def new_event_loop() -> AbstractEventLoop: ...
+def get_child_watcher() -> AbstractChildWatcher: ...
+def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
+def _set_running_loop(__loop: Optional[AbstractEventLoop]) -> None: ...
+def _get_running_loop() -> AbstractEventLoop: ...
+
+if sys.version_info >= (3, 7):
+    def get_running_loop() -> AbstractEventLoop: ...
+    if sys.version_info < (3, 8):
+        class SendfileNotAvailableError(RuntimeError): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/asyncio/format_helpers.pyi

@@ -0,0 +1,20 @@
+import functools
+import sys
+import traceback
+from types import FrameType, FunctionType
+from typing import Any, Dict, Iterable, Optional, Tuple, Union, overload
+
+class _HasWrapper:
+    __wrapper__: Union[_HasWrapper, FunctionType]
+
+_FuncType = Union[FunctionType, _HasWrapper, functools.partial, functools.partialmethod]
+
+if sys.version_info >= (3, 7):
+    @overload
+    def _get_function_source(func: _FuncType) -> Tuple[str, int]: ...
+    @overload
+    def _get_function_source(func: object) -> Optional[Tuple[str, int]]: ...
+    def _format_callback_source(func: object, args: Iterable[Any]) -> str: ...
+    def _format_args_and_kwargs(args: Iterable[Any], kwargs: Dict[str, Any]) -> str: ...
+    def _format_callback(func: object, args: Iterable[Any], kwargs: Dict[str, Any], suffix: str = ...) -> str: ...
+    def extract_stack(f: Optional[FrameType] = ..., limit: Optional[int] = ...) -> traceback.StackSummary: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/asyncio/log.pyi

@@ -0,0 +1,3 @@
+import logging
+
+logger: logging.Logger

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/asyncio/queues.pyi

@@ -0,0 +1,36 @@
+import sys
+from asyncio.events import AbstractEventLoop
+from typing import Any, Generic, Optional, TypeVar
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+class QueueEmpty(Exception): ...
+class QueueFull(Exception): ...
+
+_T = TypeVar("_T")
+
+class Queue(Generic[_T]):
+    def __init__(self, maxsize: int = ..., *, loop: Optional[AbstractEventLoop] = ...) -> None: ...
+    def _init(self, maxsize: int) -> None: ...
+    def _get(self) -> _T: ...
+    def _put(self, item: _T) -> None: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def _format(self) -> str: ...
+    def qsize(self) -> int: ...
+    @property
+    def maxsize(self) -> int: ...
+    def empty(self) -> bool: ...
+    def full(self) -> bool: ...
+    async def put(self, item: _T) -> None: ...
+    def put_nowait(self, item: _T) -> None: ...
+    async def get(self) -> _T: ...
+    def get_nowait(self) -> _T: ...
+    async def join(self) -> None: ...
+    def task_done(self) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, type: Any) -> GenericAlias: ...
+
+class PriorityQueue(Queue[_T]): ...
+class LifoQueue(Queue[_T]): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/html/parser.pyi

@@ -0,0 +1,20 @@
+from _markupbase import ParserBase
+from typing import List, Optional, Tuple
+
+class HTMLParser(ParserBase):
+    def __init__(self, *, convert_charrefs: bool = ...) -> None: ...
+    def feed(self, feed: str) -> None: ...
+    def close(self) -> None: ...
+    def reset(self) -> None: ...
+    def getpos(self) -> Tuple[int, int]: ...
+    def get_starttag_text(self) -> Optional[str]: ...
+    def handle_starttag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None: ...
+    def handle_endtag(self, tag: str) -> None: ...
+    def handle_startendtag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None: ...
+    def handle_data(self, data: str) -> None: ...
+    def handle_entityref(self, name: str) -> None: ...
+    def handle_charref(self, name: str) -> None: ...
+    def handle_comment(self, data: str) -> None: ...
+    def handle_decl(self, decl: str) -> None: ...
+    def handle_pi(self, data: str) -> None: ...
+    def unknown_decl(self, data: str) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schemas/event-core-schema.yml

@@ -0,0 +1,27 @@
+$schema: http://json-schema.org/draft-07/schema
+$id: http://event.jupyter.org/event-schema
+version: "1"
+title: Event Schema
+description: |
+  A schema for validating any Jupyter Event.
+type: object
+properties:
+  __metadata_version__:
+    title: Metadata Version
+    type: number
+    const: 1
+  __schema_version__:
+    title: Schema Version
+    type: string
+  __schema__:
+    title: Schema ID
+    type: string
+  __timestamp__:
+    title: Event Timestamp
+    type: string
+    format: datetime
+required:
+  - __metadata_version__
+  - __schema__
+  - __schema_version__
+  - __timestamp__