Add files using upload-large-folder tool

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/apps/__init__.pyi

@@ -0,0 +1,3 @@
+from .config import AppConfig as AppConfig
+
+from .registry import apps as apps

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/apps/config.pyi

@@ -0,0 +1,23 @@
+from typing import Any, Iterator, Type, Optional, Dict
+
+from django.apps.registry import Apps
+from django.db.models.base import Model
+
+MODELS_MODULE_NAME: str
+
+class AppConfig:
+    name: str = ...
+    module: Optional[Any] = ...
+    apps: Optional[Apps] = ...
+    label: str = ...
+    verbose_name: str = ...
+    path: str = ...
+    models_module: Optional[str] = ...
+    models: Dict[str, Type[Model]] = ...
+    def __init__(self, app_name: str, app_module: Optional[Any]) -> None: ...
+    @classmethod
+    def create(cls, entry: str) -> AppConfig: ...
+    def get_model(self, model_name: str, require_ready: bool = ...) -> Type[Model]: ...
+    def get_models(self, include_auto_created: bool = ..., include_swapped: bool = ...) -> Iterator[Type[Model]]: ...
+    def import_models(self) -> None: ...
+    def ready(self) -> None: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/apps/registry.pyi

@@ -0,0 +1,40 @@
+import threading
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Type, Union
+
+from django.db.models.base import Model
+
+from .config import AppConfig
+
+class Apps:
+    all_models: Dict[str, Dict[str, Type[Model]]] = ...
+    app_configs: Dict[str, AppConfig] = ...
+    stored_app_configs: List[Any] = ...
+    apps_ready: bool = ...
+    ready_event: threading.Event = ...
+    loading: bool = ...
+    _pending_operations: Dict[Tuple[str, str], List]
+    models_ready: bool = ...
+    ready: bool = ...
+    def __init__(self, installed_apps: Optional[Iterable[Union[AppConfig, str]]] = ...) -> None: ...
+    def populate(self, installed_apps: Iterable[Union[AppConfig, str]] = ...) -> None: ...
+    def check_apps_ready(self) -> None: ...
+    def check_models_ready(self) -> None: ...
+    def get_app_configs(self) -> Iterable[AppConfig]: ...
+    def get_app_config(self, app_label: str) -> AppConfig: ...
+    # it's not possible to support it in plugin properly now
+    def get_models(self, include_auto_created: bool = ..., include_swapped: bool = ...) -> List[Type[Model]]: ...
+    def get_model(self, app_label: str, model_name: Optional[str] = ..., require_ready: bool = ...) -> Type[Any]: ...
+    def register_model(self, app_label: str, model: Type[Model]) -> None: ...
+    def is_installed(self, app_name: str) -> bool: ...
+    def get_containing_app_config(self, object_name: str) -> Optional[AppConfig]: ...
+    def get_registered_model(self, app_label: str, model_name: str) -> Type[Model]: ...
+    def get_swappable_settings_name(self, to_string: str) -> Optional[str]: ...
+    def set_available_apps(self, available: Iterable[str]) -> None: ...
+    def unset_available_apps(self) -> None: ...
+    def set_installed_apps(self, installed: Iterable[str]) -> None: ...
+    def unset_installed_apps(self) -> None: ...
+    def clear_cache(self) -> None: ...
+    def lazy_model_operation(self, function: Callable, *model_keys: Any) -> None: ...
+    def do_pending_operations(self, model: Type[Model]) -> None: ...
+
+apps: Apps

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/http/__init__.pyi

@@ -0,0 +1,26 @@
+from .request import (
+    HttpRequest as HttpRequest,
+    QueryDict as QueryDict,
+    RawPostDataException as RawPostDataException,
+    UnreadablePostError as UnreadablePostError,
+)
+
+from .response import (
+    BadHeaderError as BadHeaderError,
+    FileResponse as FileResponse,
+    Http404 as Http404,
+    HttpResponse as HttpResponse,
+    HttpResponseBadRequest as HttpResponseBadRequest,
+    HttpResponseForbidden as HttpResponseForbidden,
+    HttpResponseGone as HttpResponseGone,
+    HttpResponseNotAllowed as HttpResponseNotAllowed,
+    HttpResponseNotFound as HttpResponseNotFound,
+    HttpResponseNotModified as HttpResponseNotModified,
+    HttpResponsePermanentRedirect as HttpResponsePermanentRedirect,
+    HttpResponseRedirect as HttpResponseRedirect,
+    HttpResponseServerError as HttpResponseServerError,
+    JsonResponse as JsonResponse,
+    StreamingHttpResponse as StreamingHttpResponse,
+)
+
+from .cookie import SimpleCookie as SimpleCookie, parse_cookie as parse_cookie

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/http/cookie.pyi

@@ -0,0 +1,5 @@
+from typing import Any, Dict
+
+SimpleCookie: Any
+
+def parse_cookie(cookie: str) -> Dict[str, str]: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/http/multipartparser.pyi

@@ -0,0 +1,54 @@
+from io import BytesIO, StringIO
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
+
+from django.http.request import QueryDict
+from django.utils.datastructures import ImmutableList, MultiValueDict
+
+class MultiPartParserError(Exception): ...
+class InputStreamExhausted(Exception): ...
+
+class MultiPartParser:
+    def __init__(
+        self,
+        META: Dict[str, Any],
+        input_data: Union[StringIO, BytesIO],
+        upload_handlers: Union[List[Any], ImmutableList],
+        encoding: Optional[str] = ...,
+    ) -> None: ...
+    def parse(self) -> Tuple[QueryDict, MultiValueDict]: ...
+    def handle_file_complete(self, old_field_name: str, counters: List[int]) -> None: ...
+    def IE_sanitize(self, filename: str) -> str: ...
+
+class LazyStream:
+    length: None = ...
+    position: int = ...
+    def __init__(self, producer: Union[BoundaryIter, ChunkIter], length: None = ...) -> None: ...
+    def tell(self): ...
+    def read(self, size: Optional[int] = ...) -> bytes: ...
+    def __next__(self) -> bytes: ...
+    def close(self) -> None: ...
+    def __iter__(self) -> LazyStream: ...
+    def unget(self, bytes: bytes) -> None: ...
+
+class ChunkIter:
+    flo: BytesIO = ...
+    chunk_size: int = ...
+    def __init__(self, flo: BytesIO, chunk_size: int = ...) -> None: ...
+    def __next__(self) -> bytes: ...
+    def __iter__(self): ...
+
+class InterBoundaryIter:
+    def __init__(self, stream: LazyStream, boundary: bytes) -> None: ...
+    def __iter__(self) -> InterBoundaryIter: ...
+    def __next__(self) -> LazyStream: ...
+
+class BoundaryIter:
+    def __init__(self, stream: LazyStream, boundary: bytes) -> None: ...
+    def __iter__(self): ...
+    def __next__(self) -> bytes: ...
+
+class Parser:
+    def __init__(self, stream: LazyStream, boundary: bytes) -> None: ...
+    def __iter__(self) -> Iterator[Tuple[str, Dict[str, Tuple[str, Dict[str, Union[bytes, str]]]], LazyStream]]: ...
+
+def parse_header(line: bytes) -> Tuple[str, Dict[str, Any]]: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/http/request.pyi

@@ -0,0 +1,111 @@
+from io import BytesIO
+from typing import (
+    Any,
+    BinaryIO,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Pattern,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from django.contrib.auth.base_user import AbstractBaseUser
+from django.contrib.auth.models import AnonymousUser
+from django.contrib.sessions.backends.base import SessionBase
+from django.contrib.sites.models import Site
+from django.utils.datastructures import CaseInsensitiveMapping, ImmutableList, MultiValueDict
+
+from django.core.files import uploadedfile, uploadhandler
+from django.urls import ResolverMatch
+
+RAISE_ERROR: object = ...
+host_validation_re: Pattern = ...
+
+class UnreadablePostError(IOError): ...
+class RawPostDataException(Exception): ...
+
+UploadHandlerList = Union[List[uploadhandler.FileUploadHandler], ImmutableList[uploadhandler.FileUploadHandler]]
+
+class HttpHeaders(CaseInsensitiveMapping):
+    HTTP_PREFIX: str = ...
+    UNPREFIXED_HEADERS: Set[str] = ...
+    def __init__(self, environ: Mapping[str, Any]) -> None: ...
+    @classmethod
+    def parse_header_name(cls, header: str) -> Optional[str]: ...
+
+class HttpRequest(BytesIO):
+    GET: QueryDict = ...
+    POST: QueryDict = ...
+    COOKIES: Dict[str, str] = ...
+    META: Dict[str, Any] = ...
+    FILES: MultiValueDict[str, uploadedfile.UploadedFile] = ...
+    path: str = ...
+    path_info: str = ...
+    method: Optional[str] = ...
+    resolver_match: ResolverMatch = ...
+    content_type: Optional[str] = ...
+    content_params: Optional[Dict[str, str]] = ...
+    user: Union[AbstractBaseUser, AnonymousUser]
+    site: Site
+    session: SessionBase
+    encoding: Optional[str] = ...
+    upload_handlers: UploadHandlerList = ...
+    def __init__(self) -> None: ...
+    def get_host(self) -> str: ...
+    def get_port(self) -> str: ...
+    def get_full_path(self, force_append_slash: bool = ...) -> str: ...
+    def get_full_path_info(self, force_append_slash: bool = ...) -> str: ...
+    def get_signed_cookie(
+        self, key: str, default: Any = ..., salt: str = ..., max_age: Optional[int] = ...
+    ) -> Optional[str]: ...
+    def get_raw_uri(self) -> str: ...
+    def build_absolute_uri(self, location: Optional[str] = ...) -> str: ...
+    @property
+    def scheme(self) -> Optional[str]: ...
+    def is_secure(self) -> bool: ...
+    def is_ajax(self) -> bool: ...
+    def parse_file_upload(
+        self, META: Mapping[str, Any], post_data: BinaryIO
+    ) -> Tuple[QueryDict, MultiValueDict[str, uploadedfile.UploadedFile]]: ...
+    @property
+    def headers(self) -> HttpHeaders: ...
+    @property
+    def body(self) -> bytes: ...
+    def _load_post_and_files(self) -> None: ...
+
+_Q = TypeVar("_Q", bound="QueryDict")
+
+class QueryDict(MultiValueDict[str, str]):
+    encoding: str = ...
+    _mutable: bool = ...
+    def __init__(
+        self, query_string: Optional[Union[str, bytes]] = ..., mutable: bool = ..., encoding: Optional[str] = ...
+    ) -> None: ...
+    def setlist(self, key: str, list_: List[str]) -> None: ...
+    def setlistdefault(self, key: str, default_list: Optional[List[str]] = ...) -> List[str]: ...
+    def appendlist(self, key: str, value: str) -> None: ...
+    def urlencode(self, safe: Optional[str] = ...) -> str: ...
+    @classmethod
+    def fromkeys(
+        cls: Type[_Q],
+        iterable: Iterable[Union[bytes, str]],
+        value: Any = ...,
+        mutable: bool = ...,
+        encoding: Optional[str] = ...,
+    ) -> _Q: ...
+
+@overload
+def bytes_to_text(s: bytes, encoding: str) -> str: ...
+@overload
+def bytes_to_text(s: str, encoding: str) -> str: ...
+@overload
+def bytes_to_text(s: None, encoding: str) -> None: ...
+def split_domain_port(host: str) -> Tuple[str, str]: ...
+def validate_host(host: str, allowed_hosts: Iterable[str]) -> bool: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/http/response.pyi

@@ -0,0 +1,137 @@
+import datetime
+from io import BytesIO
+from json import JSONEncoder
+from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, Type, Union, overload
+
+from django.core.handlers.wsgi import WSGIRequest
+from django.http.cookie import SimpleCookie
+from django.test.client import Client
+
+from django.template import Context, Template
+from django.urls import ResolverMatch
+
+class BadHeaderError(ValueError): ...
+
+class HttpResponseBase(Iterable[Any]):
+    status_code: int = ...
+    cookies: SimpleCookie = ...
+    reason_phrase: str = ...
+    charset: str = ...
+    closed: bool = ...
+    def __init__(
+        self,
+        content_type: Optional[str] = ...,
+        status: Optional[int] = ...,
+        reason: Optional[str] = ...,
+        charset: Optional[str] = ...,
+    ) -> None: ...
+    def serialize_headers(self) -> bytes: ...
+    def __setitem__(self, header: Union[str, bytes], value: Union[str, bytes, int]) -> None: ...
+    def __delitem__(self, header: Union[str, bytes]) -> None: ...
+    def __getitem__(self, header: Union[str, bytes]) -> str: ...
+    def has_header(self, header: str) -> bool: ...
+    def items(self) -> Iterable[Tuple[str, str]]: ...
+    @overload
+    def get(self, header: Union[str, bytes], alternate: Optional[str]) -> str: ...
+    @overload
+    def get(self, header: Union[str, bytes]) -> Optional[str]: ...
+    def set_cookie(
+        self,
+        key: str,
+        value: str = ...,
+        max_age: Optional[int] = ...,
+        expires: Optional[Union[str, datetime.datetime]] = ...,
+        path: str = ...,
+        domain: Optional[str] = ...,
+        secure: bool = ...,
+        httponly: bool = ...,
+        samesite: str = ...,
+    ) -> None: ...
+    def setdefault(self, key: str, value: str) -> None: ...
+    def set_signed_cookie(self, key: str, value: str, salt: str = ..., **kwargs: Any) -> None: ...
+    def delete_cookie(self, key: str, path: str = ..., domain: Optional[str] = ...) -> None: ...
+    def make_bytes(self, value: object) -> bytes: ...
+    def close(self) -> None: ...
+    def write(self, content: Union[str, bytes]) -> None: ...
+    def flush(self) -> None: ...
+    def tell(self) -> int: ...
+    def readable(self) -> bool: ...
+    def seekable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def writelines(self, lines: Iterable[object]): ...
+    def __iter__(self) -> Iterator[Any]: ...
+
+class HttpResponse(HttpResponseBase):
+    content: Any
+    csrf_cookie_set: bool
+    redirect_chain: List[Tuple[str, int]]
+    sameorigin: bool
+    test_server_port: str
+    test_was_secure_request: bool
+    xframe_options_exempt: bool
+    streaming: bool = ...
+    def __init__(self, content: object = ..., *args: Any, **kwargs: Any) -> None: ...
+    def serialize(self) -> bytes: ...
+    @property
+    def url(self) -> str: ...
+    # Attributes assigned by monkey-patching in test client ClientHandler.__call__()
+    wsgi_request: WSGIRequest
+    # Attributes assigned by monkey-patching in test client Client.request()
+    client: Client
+    request: Dict[str, Any]
+    templates: List[Template]
+    context: Context
+    resolver_match: ResolverMatch
+    def json(self) -> Any: ...
+
+class StreamingHttpResponse(HttpResponseBase):
+    content: Any
+    streaming_content: Iterator[Any]
+    def __init__(self, streaming_content: Iterable[Any] = ..., *args: Any, **kwargs: Any) -> None: ...
+    def getvalue(self) -> Any: ...
+
+class FileResponse(StreamingHttpResponse):
+    client: Client
+    context: None
+    file_to_stream: Optional[BytesIO]
+    request: Dict[str, str]
+    resolver_match: ResolverMatch
+    templates: List[Any]
+    wsgi_request: WSGIRequest
+    block_size: int = ...
+    as_attachment: bool = ...
+    filename: str = ...
+    def __init__(self, *args: Any, as_attachment: bool = ..., filename: str = ..., **kwargs: Any) -> None: ...
+    def set_headers(self, filelike: BytesIO) -> None: ...
+    def json(self) -> Dict[str, Any]: ...
+
+class HttpResponseRedirectBase(HttpResponse):
+    allowed_schemes: List[str] = ...
+    def __init__(self, redirect_to: str, *args: Any, **kwargs: Any) -> None: ...
+
+class HttpResponseRedirect(HttpResponseRedirectBase): ...
+class HttpResponsePermanentRedirect(HttpResponseRedirectBase): ...
+
+class HttpResponseNotModified(HttpResponse):
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+
+class HttpResponseBadRequest(HttpResponse): ...
+class HttpResponseNotFound(HttpResponse): ...
+class HttpResponseForbidden(HttpResponse): ...
+
+class HttpResponseNotAllowed(HttpResponse):
+    def __init__(self, permitted_methods: Iterable[str], *args: Any, **kwargs: Any) -> None: ...
+
+class HttpResponseGone(HttpResponse): ...
+class HttpResponseServerError(HttpResponse): ...
+class Http404(Exception): ...
+
+class JsonResponse(HttpResponse):
+    def __init__(
+        self,
+        data: Any,
+        encoder: Type[JSONEncoder] = ...,
+        safe: bool = ...,
+        json_dumps_params: Optional[Dict[str, Any]] = ...,
+        **kwargs: Any
+    ) -> None: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/middleware/cache.pyi

@@ -0,0 +1,31 @@
+from typing import Any, Optional, Union, Callable
+
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse, HttpResponseBase
+from django.utils.deprecation import MiddlewareMixin
+
+from django.core.cache import BaseCache
+
+class UpdateCacheMiddleware(MiddlewareMixin):
+    cache_timeout: float = ...
+    key_prefix: str = ...
+    cache_alias: str = ...
+    cache: BaseCache = ...
+    def process_response(
+        self, request: HttpRequest, response: Union[HttpResponseBase, str]
+    ) -> Union[HttpResponseBase, str]: ...
+
+class FetchFromCacheMiddleware(MiddlewareMixin):
+    key_prefix: str = ...
+    cache_alias: str = ...
+    cache: BaseCache = ...
+    def process_request(self, request: HttpRequest) -> Optional[HttpResponse]: ...
+
+class CacheMiddleware(UpdateCacheMiddleware, FetchFromCacheMiddleware):
+    key_prefix: str = ...
+    cache_alias: str = ...
+    cache_timeout: float = ...
+    cache: BaseCache = ...
+    def __init__(
+        self, get_response: Optional[Callable] = ..., cache_timeout: Optional[float] = ..., **kwargs: Any
+    ) -> None: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/middleware/clickjacking.pyi

@@ -0,0 +1,7 @@
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse
+from django.utils.deprecation import MiddlewareMixin
+
+class XFrameOptionsMiddleware(MiddlewareMixin):
+    def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ...
+    def get_xframe_options_value(self, request: HttpRequest, response: HttpResponse) -> str: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/middleware/common.pyi

@@ -0,0 +1,17 @@
+from typing import Any, Optional
+
+from django.http.request import HttpRequest
+from django.http.response import HttpResponseBase, HttpResponsePermanentRedirect
+from django.utils.deprecation import MiddlewareMixin
+
+class CommonMiddleware(MiddlewareMixin):
+    response_redirect_class: Any = ...
+    def process_request(self, request: HttpRequest) -> Optional[HttpResponsePermanentRedirect]: ...
+    def should_redirect_with_slash(self, request: HttpRequest) -> bool: ...
+    def get_full_path_with_slash(self, request: HttpRequest) -> str: ...
+    def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ...
+
+class BrokenLinkEmailsMiddleware(MiddlewareMixin):
+    def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ...
+    def is_internal_request(self, domain: str, referer: str) -> bool: ...
+    def is_ignorable_request(self, request: HttpRequest, uri: str, domain: str, referer: str) -> bool: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/middleware/csrf.pyi

@@ -0,0 +1,33 @@
+from typing import Any, Callable, Dict, Optional, Tuple
+
+from django.http.request import HttpRequest
+from django.http.response import HttpResponseBase, HttpResponseForbidden
+from django.utils.deprecation import MiddlewareMixin
+
+logger: Any
+REASON_NO_REFERER: str
+REASON_BAD_REFERER: str
+REASON_NO_CSRF_COOKIE: str
+REASON_BAD_TOKEN: str
+REASON_MALFORMED_REFERER: str
+REASON_INSECURE_REFERER: str
+CSRF_SECRET_LENGTH: int
+CSRF_TOKEN_LENGTH: Any
+CSRF_ALLOWED_CHARS: Any
+CSRF_SESSION_KEY: str
+
+def get_token(request: HttpRequest) -> str: ...
+def rotate_token(request: HttpRequest) -> None: ...
+
+class CsrfViewMiddleware(MiddlewareMixin):
+    def process_request(self, request: HttpRequest) -> None: ...
+    def process_view(
+        self, request: HttpRequest, callback: Optional[Callable], callback_args: Tuple, callback_kwargs: Dict[str, Any]
+    ) -> Optional[HttpResponseForbidden]: ...
+    def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ...
+
+def _compare_salted_tokens(request_csrf_token: str, csrf_token: str) -> bool: ...
+def _get_new_csrf_string() -> str: ...
+def _salt_cipher_secret(secret: str) -> str: ...
+def _unsalt_cipher_token(token: str) -> str: ...
+def _get_new_csrf_token() -> str: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/middleware/gzip.pyi

@@ -0,0 +1,10 @@
+from typing import Any
+
+from django.http.request import HttpRequest
+from django.http.response import HttpResponseBase
+from django.utils.deprecation import MiddlewareMixin
+
+re_accepts_gzip: Any
+
+class GZipMiddleware(MiddlewareMixin):
+    def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/middleware/http.pyi

@@ -0,0 +1,7 @@
+from django.http.request import HttpRequest
+from django.http.response import HttpResponseBase
+from django.utils.deprecation import MiddlewareMixin
+
+class ConditionalGetMiddleware(MiddlewareMixin):
+    def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ...
+    def needs_etag(self, response: HttpResponseBase) -> bool: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/middleware/locale.pyi

@@ -0,0 +1,10 @@
+from typing import Any
+
+from django.http.request import HttpRequest
+from django.http.response import HttpResponseBase
+from django.utils.deprecation import MiddlewareMixin
+
+class LocaleMiddleware(MiddlewareMixin):
+    response_redirect_class: Any = ...
+    def process_request(self, request: HttpRequest) -> None: ...
+    def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/middleware/security.pyi

@@ -0,0 +1,17 @@
+from typing import Any, List, Optional
+
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse, HttpResponsePermanentRedirect
+from django.utils.deprecation import MiddlewareMixin
+
+class SecurityMiddleware(MiddlewareMixin):
+    sts_seconds: int = ...
+    sts_include_subdomains: bool = ...
+    sts_preload: bool = ...
+    content_type_nosniff: bool = ...
+    xss_filter: bool = ...
+    redirect: bool = ...
+    redirect_host: Optional[str] = ...
+    redirect_exempt: List[Any] = ...
+    def process_request(self, request: HttpRequest) -> Optional[HttpResponsePermanentRedirect]: ...
+    def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/test/__init__.pyi

@@ -0,0 +1,20 @@
+from .testcases import (
+    TestCase as TestCase,
+    TransactionTestCase as TransactionTestCase,
+    SimpleTestCase as SimpleTestCase,
+    LiveServerTestCase as LiveServerTestCase,
+    skipIfDBFeature as skipIfDBFeature,
+    skipUnlessDBFeature as skipUnlessDBFeature,
+    skipUnlessAnyDBFeature as skipUnlessAnyDBFeature,
+)
+
+from .utils import (
+    override_settings as override_settings,
+    modify_settings as modify_settings,
+    override_script_prefix as override_script_prefix,
+    override_system_checks as override_system_checks,
+    ignore_warnings as ignore_warnings,
+    tag as tag,
+)
+
+from .client import Client as Client, RequestFactory as RequestFactory

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/test/client.pyi

@@ -0,0 +1,132 @@
+from io import BytesIO
+from types import TracebackType
+from typing import Any, Dict, List, Optional, Pattern, Tuple, Type, Union
+
+from django.contrib.auth.models import AbstractUser
+from django.contrib.sessions.backends.base import SessionBase
+from django.core.handlers.base import BaseHandler
+from django.http.cookie import SimpleCookie
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse, HttpResponseBase
+
+from django.core.handlers.wsgi import WSGIRequest
+from json import JSONEncoder
+
+BOUNDARY: str = ...
+MULTIPART_CONTENT: str = ...
+CONTENT_TYPE_RE: Pattern = ...
+JSON_CONTENT_TYPE_RE: Pattern = ...
+
+class RedirectCycleError(Exception):
+    last_response: HttpResponseBase = ...
+    redirect_chain: List[Tuple[str, int]] = ...
+    def __init__(self, message: str, last_response: HttpResponseBase) -> None: ...
+
+class FakePayload:
+    read_started: bool = ...
+    def __init__(self, content: Optional[Union[bytes, str]] = ...) -> None: ...
+    def __len__(self) -> int: ...
+    def read(self, num_bytes: int = ...) -> bytes: ...
+    def write(self, content: Union[bytes, str]) -> None: ...
+
+class ClientHandler(BaseHandler):
+    enforce_csrf_checks: bool = ...
+    def __init__(self, enforce_csrf_checks: bool = ..., *args: Any, **kwargs: Any) -> None: ...
+    def __call__(self, environ: Dict[str, Any]) -> HttpResponseBase: ...
+
+def encode_multipart(boundary: str, data: Dict[str, Any]) -> bytes: ...
+def encode_file(boundary: str, key: str, file: Any) -> List[bytes]: ...
+
+class RequestFactory:
+    json_encoder: Type[JSONEncoder]
+    defaults: Dict[str, str]
+    cookies: SimpleCookie
+    errors: BytesIO
+    def __init__(self, *, json_encoder: Type[JSONEncoder] = ..., **defaults: Any) -> None: ...
+    def request(self, **request: Any) -> WSGIRequest: ...
+    def get(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> WSGIRequest: ...
+    def post(
+        self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
+    ) -> WSGIRequest: ...
+    def head(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> WSGIRequest: ...
+    def trace(self, path: str, secure: bool = ..., **extra: Any) -> WSGIRequest: ...
+    def options(
+        self,
+        path: str,
+        data: Union[Dict[str, str], str] = ...,
+        content_type: str = ...,
+        follow: bool = ...,
+        secure: bool = ...,
+        **extra: Any
+    ) -> WSGIRequest: ...
+    def put(
+        self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
+    ) -> WSGIRequest: ...
+    def patch(
+        self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
+    ) -> WSGIRequest: ...
+    def delete(
+        self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
+    ) -> WSGIRequest: ...
+    def generic(
+        self,
+        method: str,
+        path: str,
+        data: Any = ...,
+        content_type: Optional[str] = ...,
+        secure: bool = ...,
+        **extra: Any
+    ) -> WSGIRequest: ...
+
+class Client(RequestFactory):
+    handler: ClientHandler
+    raise_request_exception: bool
+    exc_info: Optional[Tuple[Type[BaseException], BaseException, TracebackType]]
+    def __init__(
+        self,
+        enforce_csrf_checks: bool = ...,
+        raise_request_exception: bool = ...,
+        *,
+        json_encoder: Type[JSONEncoder] = ...,
+        **defaults: Any
+    ) -> None: ...
+    # Silence type warnings, since this class overrides arguments and return types in an unsafe manner.
+    def request(self, **request: Any) -> HttpResponse: ...  # type: ignore
+    def get(  # type: ignore
+        self, path: str, data: Any = ..., follow: bool = ..., secure: bool = ..., **extra: Any
+    ) -> HttpResponse: ...  # type: ignore
+    def post(  # type: ignore
+        self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any
+    ) -> HttpResponse: ...  # type: ignore
+    def head(  # type: ignore
+        self, path: str, data: Any = ..., follow: bool = ..., secure: bool = ..., **extra: Any
+    ) -> HttpResponse: ...  # type: ignore
+    def trace(  # type: ignore
+        self, path: str, follow: bool = ..., secure: bool = ..., **extra: Any
+    ) -> HttpResponse: ...  # type: ignore
+    def options(  # type: ignore
+        self,
+        path: str,
+        data: Union[Dict[str, str], str] = ...,
+        content_type: str = ...,
+        follow: bool = ...,
+        secure: bool = ...,
+        **extra: Any
+    ) -> HttpResponse: ...  # type: ignore
+    def put(  # type: ignore
+        self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any
+    ) -> HttpResponse: ...  # type: ignore
+    def patch(  # type: ignore
+        self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any
+    ) -> HttpResponse: ...  # type: ignore
+    def delete(  # type: ignore
+        self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any
+    ) -> HttpResponse: ...  # type: ignore
+    def store_exc_info(self, **kwargs: Any) -> None: ...
+    @property
+    def session(self) -> SessionBase: ...
+    def login(self, **credentials: Any) -> bool: ...
+    def force_login(self, user: AbstractUser, backend: Optional[str] = ...) -> None: ...
+    def logout(self) -> None: ...
+
+def conditional_content_removal(request: HttpRequest, response: HttpResponseBase) -> HttpResponse: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/test/html.pyi

@@ -0,0 +1,38 @@
+from html.parser import HTMLParser
+from typing import Any, List, Optional, Sequence, Tuple, TypeVar, Union
+
+_Self = TypeVar("_Self")
+
+WHITESPACE: Any
+
+def normalize_whitespace(string: str) -> str: ...
+
+_ElementAttribute = Tuple[str, Optional[str]]
+
+class Element:
+    name: Optional[str] = ...
+    attributes: List[_ElementAttribute] = ...
+    children: List[Any] = ...
+    def __init__(self, name: Optional[str], attributes: Sequence[_ElementAttribute]) -> None: ...
+    def append(self, element: Union[Element, str]) -> None: ...
+    def finalize(self) -> None: ...
+    def __contains__(self, element: Union[Element, str]) -> bool: ...
+    def count(self, element: Union[Element, str]) -> int: ...
+    def __getitem__(self, key: int) -> Any: ...
+
+class RootElement(Element):
+    def __init__(self) -> None: ...
+
+class HTMLParseError(Exception): ...
+
+class Parser(HTMLParser):
+    SELF_CLOSING_TAGS: Any = ...
+    root: Any = ...
+    open_tags: Any = ...
+    element_positions: Any = ...
+    def __init__(self) -> None: ...
+    def format_position(self, position: Any = ..., element: Any = ...) -> str: ...
+    @property
+    def current(self) -> Element: ...
+
+def parse_html(html: str) -> Element: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/test/runner.pyi

@@ -0,0 +1,133 @@
+import logging
+from argparse import ArgumentParser
+from io import StringIO
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Type
+from unittest import TestCase, TestSuite, TextTestResult
+
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.test.testcases import SimpleTestCase, TestCase
+from django.utils.datastructures import OrderedSet
+
+class DebugSQLTextTestResult(TextTestResult):
+    buffer: bool
+    descriptions: bool
+    dots: bool
+    expectedFailures: List[Any]
+    failfast: bool
+    shouldStop: bool
+    showAll: bool
+    skipped: List[Any]
+    tb_locals: bool
+    testsRun: int
+    unexpectedSuccesses: List[Any]
+    logger: logging.Logger = ...
+    def __init__(self, stream: Any, descriptions: bool, verbosity: int) -> None: ...
+    debug_sql_stream: StringIO = ...
+    handler: logging.StreamHandler = ...
+    def startTest(self, test: TestCase) -> None: ...
+    def stopTest(self, test: TestCase) -> None: ...
+    def addError(self, test: Any, err: Any) -> None: ...
+    def addFailure(self, test: Any, err: Any) -> None: ...
+
+class RemoteTestResult:
+    events: List[Any] = ...
+    failfast: bool = ...
+    shouldStop: bool = ...
+    testsRun: int = ...
+    def __init__(self) -> None: ...
+    @property
+    def test_index(self): ...
+    def check_picklable(self, test: Any, err: Any) -> None: ...
+    def _confirm_picklable(self, obj: Any) -> None: ...
+    def check_subtest_picklable(self, test: Any, subtest: Any) -> None: ...
+    def stop_if_failfast(self) -> None: ...
+    def stop(self) -> None: ...
+    def startTestRun(self) -> None: ...
+    def stopTestRun(self) -> None: ...
+    def startTest(self, test: Any) -> None: ...
+    def stopTest(self, test: Any) -> None: ...
+    def addError(self, test: Any, err: Any) -> None: ...
+    def addFailure(self, test: Any, err: Any) -> None: ...
+    def addSubTest(self, test: Any, subtest: Any, err: Any) -> None: ...
+    def addSuccess(self, test: Any) -> None: ...
+    def addSkip(self, test: Any, reason: Any) -> None: ...
+    def addExpectedFailure(self, test: Any, err: Any) -> None: ...
+    def addUnexpectedSuccess(self, test: Any) -> None: ...
+
+class RemoteTestRunner:
+    resultclass: Any = ...
+    failfast: Any = ...
+    def __init__(self, failfast: bool = ..., resultclass: Optional[Any] = ...) -> None: ...
+    def run(self, test: Any): ...
+
+def default_test_processes() -> int: ...
+
+class ParallelTestSuite(TestSuite):
+    init_worker: Any = ...
+    run_subsuite: Any = ...
+    runner_class: Any = ...
+    subsuites: Any = ...
+    processes: Any = ...
+    failfast: Any = ...
+    def __init__(self, suite: Any, processes: Any, failfast: bool = ...) -> None: ...
+    def run(self, result: Any): ...
+
+class DiscoverRunner:
+    test_suite: Any = ...
+    parallel_test_suite: Any = ...
+    test_runner: Any = ...
+    test_loader: Any = ...
+    reorder_by: Any = ...
+    pattern: Optional[str] = ...
+    top_level: None = ...
+    verbosity: int = ...
+    interactive: bool = ...
+    failfast: bool = ...
+    keepdb: bool = ...
+    reverse: bool = ...
+    debug_mode: bool = ...
+    debug_sql: bool = ...
+    parallel: int = ...
+    tags: Set[str] = ...
+    exclude_tags: Set[str] = ...
+    def __init__(
+        self,
+        pattern: Optional[str] = ...,
+        top_level: None = ...,
+        verbosity: int = ...,
+        interactive: bool = ...,
+        failfast: bool = ...,
+        keepdb: bool = ...,
+        reverse: bool = ...,
+        debug_mode: bool = ...,
+        debug_sql: bool = ...,
+        parallel: int = ...,
+        tags: Optional[List[str]] = ...,
+        exclude_tags: Optional[List[str]] = ...,
+        **kwargs: Any
+    ) -> None: ...
+    @classmethod
+    def add_arguments(cls, parser: ArgumentParser) -> None: ...
+    def setup_test_environment(self, **kwargs: Any) -> None: ...
+    def build_suite(
+        self, test_labels: Sequence[str] = ..., extra_tests: Optional[List[Any]] = ..., **kwargs: Any
+    ) -> TestSuite: ...
+    def setup_databases(self, **kwargs: Any) -> List[Tuple[BaseDatabaseWrapper, str, bool]]: ...
+    def get_resultclass(self) -> Optional[Type[DebugSQLTextTestResult]]: ...
+    def get_test_runner_kwargs(self) -> Dict[str, Optional[int]]: ...
+    def run_checks(self) -> None: ...
+    def run_suite(self, suite: TestSuite, **kwargs: Any) -> TextTestResult: ...
+    def teardown_databases(self, old_config: List[Tuple[BaseDatabaseWrapper, str, bool]], **kwargs: Any) -> None: ...
+    def teardown_test_environment(self, **kwargs: Any) -> None: ...
+    def suite_result(self, suite: TestSuite, result: TextTestResult, **kwargs: Any) -> int: ...
+    def run_tests(self, test_labels: List[str], extra_tests: List[Any] = ..., **kwargs: Any) -> int: ...
+
+def is_discoverable(label: str) -> bool: ...
+def reorder_suite(
+    suite: TestSuite, classes: Tuple[Type[TestCase], Type[SimpleTestCase]], reverse: bool = ...
+) -> TestSuite: ...
+def partition_suite_by_type(
+    suite: TestSuite, classes: Tuple[Type[TestCase], Type[SimpleTestCase]], bins: List[OrderedSet], reverse: bool = ...
+) -> None: ...
+def partition_suite_by_case(suite: Any): ...
+def filter_tests_by_tags(suite: TestSuite, tags: Set[str], exclude_tags: Set[str]) -> TestSuite: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/test/selenium.pyi

@@ -0,0 +1,14 @@
+from typing import Any
+
+from django.test import LiveServerTestCase
+
+class SeleniumTestCaseBase:
+    browsers: Any = ...
+    browser: Any = ...
+    @classmethod
+    def import_webdriver(cls, browser: Any): ...
+    def create_webdriver(self): ...
+
+class SeleniumTestCase(LiveServerTestCase):
+    implicit_wait: int = ...
+    def disable_implicit_wait(self) -> None: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/test/signals.pyi

@@ -0,0 +1,21 @@
+from typing import Any
+from django.core.signals import setting_changed as setting_changed  # noqa: F401
+
+template_rendered: Any
+COMPLEX_OVERRIDE_SETTINGS: Any
+
+def clear_cache_handlers(**kwargs: Any) -> None: ...
+def update_installed_apps(**kwargs: Any) -> None: ...
+def update_connections_time_zone(**kwargs: Any) -> None: ...
+def clear_routers_cache(**kwargs: Any) -> None: ...
+def reset_template_engines(**kwargs: Any) -> None: ...
+def clear_serializers_cache(**kwargs: Any) -> None: ...
+def language_changed(**kwargs: Any) -> None: ...
+def localize_settings_changed(**kwargs: Any) -> None: ...
+def file_storage_changed(**kwargs: Any) -> None: ...
+def complex_setting_changed(**kwargs: Any) -> None: ...
+def root_urlconf_changed(**kwargs: Any) -> None: ...
+def static_storage_changed(**kwargs: Any) -> None: ...
+def static_finders_changed(**kwargs: Any) -> None: ...
+def auth_password_validators_changed(**kwargs: Any) -> None: ...
+def user_model_swapped(**kwargs: Any) -> None: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/test/testcases.pyi

@@ -0,0 +1,229 @@
+import threading
+import unittest
+from datetime import date
+from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Type, Union, ClassVar, overload
+
+from django.core.exceptions import ImproperlyConfigured
+from django.core.handlers.wsgi import WSGIHandler
+from django.core.servers.basehttp import ThreadedWSGIServer, WSGIRequestHandler
+from django.db.backends.sqlite3.base import DatabaseWrapper
+from django.db.models.base import Model
+from django.db.models.query import QuerySet, RawQuerySet
+from django.forms.fields import EmailField
+from django.http.response import HttpResponse, HttpResponseBase
+from django.template.base import Template
+from django.test.client import Client
+from django.test.utils import CaptureQueriesContext, ContextList
+from django.utils.safestring import SafeText
+from django.db import connections as connections  # noqa: F401
+
+class _AssertNumQueriesContext(CaptureQueriesContext):
+    test_case: SimpleTestCase = ...
+    num: int = ...
+    def __init__(self, test_case: Any, num: Any, connection: Any) -> None: ...
+
+class _AssertTemplateUsedContext:
+    test_case: SimpleTestCase = ...
+    template_name: str = ...
+    rendered_templates: List[Template] = ...
+    rendered_template_names: List[str] = ...
+    context: ContextList = ...
+    def __init__(self, test_case: Any, template_name: Any) -> None: ...
+    def on_template_render(self, sender: Any, signal: Any, template: Any, context: Any, **kwargs: Any) -> None: ...
+    def test(self): ...
+    def message(self): ...
+    def __enter__(self): ...
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any): ...
+
+class _AssertTemplateNotUsedContext(_AssertTemplateUsedContext): ...
+
+class _CursorFailure:
+    cls_name: str = ...
+    wrapped: Callable = ...
+    def __init__(self, cls_name: Any, wrapped: Any) -> None: ...
+    def __call__(self) -> None: ...
+
+class SimpleTestCase(unittest.TestCase):
+    client_class: Any = ...
+    client: Client
+    allow_database_queries: bool = ...
+    # TODO: str -> Literal['__all__']
+    databases: Union[Set[str], str] = ...
+    def __call__(self, result: Optional[unittest.TestResult] = ...) -> None: ...
+    def settings(self, **kwargs: Any) -> Any: ...
+    def modify_settings(self, **kwargs: Any) -> Any: ...
+    def assertRedirects(
+        self,
+        response: HttpResponse,
+        expected_url: str,
+        status_code: int = ...,
+        target_status_code: int = ...,
+        msg_prefix: str = ...,
+        fetch_redirect_response: bool = ...,
+    ) -> None: ...
+    def assertContains(
+        self,
+        response: HttpResponseBase,
+        text: Union[bytes, int, str],
+        count: Optional[int] = ...,
+        status_code: int = ...,
+        msg_prefix: str = ...,
+        html: bool = ...,
+    ) -> None: ...
+    def assertNotContains(
+        self,
+        response: HttpResponse,
+        text: Union[bytes, str],
+        status_code: int = ...,
+        msg_prefix: str = ...,
+        html: bool = ...,
+    ) -> None: ...
+    def assertFormError(
+        self,
+        response: HttpResponse,
+        form: str,
+        field: Optional[str],
+        errors: Union[List[str], str],
+        msg_prefix: str = ...,
+    ) -> None: ...
+    def assertFormsetError(
+        self,
+        response: HttpResponse,
+        formset: str,
+        form_index: Optional[int],
+        field: Optional[str],
+        errors: Union[List[str], str],
+        msg_prefix: str = ...,
+    ) -> None: ...
+    def assertTemplateUsed(
+        self,
+        response: Optional[Union[HttpResponse, str]] = ...,
+        template_name: Optional[str] = ...,
+        msg_prefix: str = ...,
+        count: Optional[int] = ...,
+    ) -> Optional[_AssertTemplateUsedContext]: ...
+    def assertTemplateNotUsed(
+        self, response: Union[HttpResponse, str] = ..., template_name: Optional[str] = ..., msg_prefix: str = ...
+    ) -> Optional[_AssertTemplateNotUsedContext]: ...
+    def assertRaisesMessage(
+        self, expected_exception: Type[Exception], expected_message: str, *args: Any, **kwargs: Any
+    ) -> Any: ...
+    def assertWarnsMessage(
+        self, expected_warning: Type[Exception], expected_message: str, *args: Any, **kwargs: Any
+    ) -> Any: ...
+    def assertFieldOutput(
+        self,
+        fieldclass: Type[EmailField],
+        valid: Dict[str, str],
+        invalid: Dict[str, List[str]],
+        field_args: None = ...,
+        field_kwargs: None = ...,
+        empty_value: str = ...,
+    ) -> Any: ...
+    def assertHTMLEqual(self, html1: str, html2: str, msg: Optional[str] = ...) -> None: ...
+    def assertHTMLNotEqual(self, html1: str, html2: str, msg: Optional[str] = ...) -> None: ...
+    def assertInHTML(
+        self, needle: str, haystack: SafeText, count: Optional[int] = ..., msg_prefix: str = ...
+    ) -> None: ...
+    def assertJSONEqual(
+        self,
+        raw: str,
+        expected_data: Union[Dict[str, Any], List[Any], str, int, float, bool, None],
+        msg: Optional[str] = ...,
+    ) -> None: ...
+    def assertJSONNotEqual(
+        self,
+        raw: str,
+        expected_data: Union[Dict[str, Any], List[Any], str, int, float, bool, None],
+        msg: Optional[str] = ...,
+    ) -> None: ...
+    def assertXMLEqual(self, xml1: str, xml2: str, msg: Optional[str] = ...) -> None: ...
+    def assertXMLNotEqual(self, xml1: str, xml2: str, msg: Optional[str] = ...) -> None: ...
+
+class TransactionTestCase(SimpleTestCase):
+    reset_sequences: bool = ...
+    available_apps: Any = ...
+    fixtures: Any = ...
+    multi_db: bool = ...
+    serialized_rollback: bool = ...
+    def assertQuerysetEqual(
+        self,
+        qs: Union[Iterator[Any], List[Model], QuerySet, RawQuerySet],
+        values: Union[List[None], List[Tuple[str, str]], List[date], List[int], List[str], Set[str], QuerySet],
+        transform: Union[Callable, Type[str]] = ...,
+        ordered: bool = ...,
+        msg: Optional[str] = ...,
+    ) -> None: ...
+    @overload
+    def assertNumQueries(
+        self, num: int, func: Callable[..., Any], *args: Any, using: str = ..., **kwargs: Any
+    ) -> None: ...
+    @overload
+    def assertNumQueries(
+        self, num: int, func: None = ..., *args: Any, using: str = ..., **kwargs: Any
+    ) -> _AssertNumQueriesContext: ...
+
+class TestCase(TransactionTestCase):
+    @classmethod
+    def setUpTestData(cls) -> None: ...
+
+class CheckCondition:
+    conditions: Tuple[Tuple[Callable, str]] = ...
+    def __init__(self, *conditions: Any) -> None: ...
+    def add_condition(self, condition: Callable, reason: str) -> CheckCondition: ...
+    def __get__(self, instance: None, cls: Type[TransactionTestCase] = ...) -> bool: ...
+
+def skipIfDBFeature(*features: Any) -> Callable: ...
+def skipUnlessDBFeature(*features: Any) -> Callable: ...
+def skipUnlessAnyDBFeature(*features: Any) -> Callable: ...
+
+class QuietWSGIRequestHandler(WSGIRequestHandler): ...
+
+class FSFilesHandler(WSGIHandler):
+    application: Any = ...
+    base_url: Any = ...
+    def __init__(self, application: Any) -> None: ...
+    def file_path(self, url: Any): ...
+    def serve(self, request: Any): ...
+
+class _StaticFilesHandler(FSFilesHandler):
+    def get_base_dir(self): ...
+    def get_base_url(self): ...
+
+class _MediaFilesHandler(FSFilesHandler):
+    def get_base_dir(self): ...
+    def get_base_url(self): ...
+
+class LiveServerThread(threading.Thread):
+    host: str = ...
+    port: int = ...
+    is_ready: threading.Event = ...
+    error: Optional[ImproperlyConfigured] = ...
+    static_handler: Type[WSGIHandler] = ...
+    connections_override: Dict[str, Any] = ...
+    def __init__(
+        self,
+        host: str,
+        static_handler: Type[WSGIHandler],
+        connections_override: Dict[str, DatabaseWrapper] = ...,
+        port: int = ...,
+    ) -> None: ...
+    httpd: ThreadedWSGIServer = ...
+    def terminate(self) -> None: ...
+
+class LiveServerTestCase(TransactionTestCase):
+    live_server_url: ClassVar[str]
+    host: str = ...
+    port: int = ...
+    server_thread_class: Type[Any] = ...
+    server_thread: Any
+    static_handler: Any = ...
+
+class SerializeMixin:
+    lockfile: Any = ...
+    @classmethod
+    def setUpClass(cls) -> None: ...
+    @classmethod
+    def tearDownClass(cls) -> None: ...
+
+def connections_support_transactions() -> bool: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/test/utils.pyi

@@ -0,0 +1,155 @@
+import decimal
+from contextlib import contextmanager
+from decimal import Decimal
+from io import StringIO
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    ContextManager,
+    TypeVar,
+)
+
+from django.apps.registry import Apps
+from django.core.checks.registry import CheckRegistry
+from django.db.models.lookups import Lookup, Transform
+from django.db.models.query_utils import RegisterLookupMixin
+from django.test.runner import DiscoverRunner
+from django.test.testcases import SimpleTestCase
+
+from django.conf import LazySettings, Settings
+
+_TestClass = Type[SimpleTestCase]
+_DecoratedTest = Union[Callable, _TestClass]
+_C = TypeVar("_C", bound=Callable)  # Any callable
+
+TZ_SUPPORT: bool = ...
+
+class Approximate:
+    val: Union[decimal.Decimal, float] = ...
+    places: int = ...
+    def __init__(self, val: Union[Decimal, float], places: int = ...) -> None: ...
+
+class ContextList(list):
+    def get(self, key: str, default: Optional[str] = ...) -> str: ...
+    def keys(self) -> Set[str]: ...
+
+class _TestState: ...
+
+def setup_test_environment(debug: Optional[bool] = ...) -> None: ...
+def teardown_test_environment() -> None: ...
+def get_runner(settings: LazySettings, test_runner_class: Optional[str] = ...) -> Type[DiscoverRunner]: ...
+
+class TestContextDecorator:
+    attr_name: Optional[str] = ...
+    kwarg_name: Optional[str] = ...
+    def __init__(self, attr_name: Optional[str] = ..., kwarg_name: Optional[str] = ...) -> None: ...
+    def enable(self) -> Any: ...
+    def disable(self) -> None: ...
+    def __enter__(self) -> Optional[Apps]: ...
+    def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ...
+    def decorate_class(self, cls: _TestClass) -> _TestClass: ...
+    def decorate_callable(self, func: _C) -> _C: ...
+    def __call__(self, decorated: _DecoratedTest) -> Any: ...
+
+class override_settings(TestContextDecorator):
+    options: Dict[str, Any] = ...
+    def __init__(self, **kwargs: Any) -> None: ...
+    wrapped: Settings = ...
+    def save_options(self, test_func: _DecoratedTest) -> None: ...
+    def decorate_class(self, cls: type) -> type: ...
+
+class modify_settings(override_settings):
+    wrapped: Settings
+    operations: List[Tuple[str, Dict[str, Union[List[str], str]]]] = ...
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    def save_options(self, test_func: _DecoratedTest) -> None: ...
+    options: Dict[str, List[Union[Tuple[str, str], str]]] = ...
+
+class override_system_checks(TestContextDecorator):
+    registry: CheckRegistry = ...
+    new_checks: List[Callable] = ...
+    deployment_checks: Optional[List[Callable]] = ...
+    def __init__(self, new_checks: List[Callable], deployment_checks: Optional[List[Callable]] = ...) -> None: ...
+    old_checks: Set[Callable] = ...
+    old_deployment_checks: Set[Callable] = ...
+
+class CaptureQueriesContext:
+    connection: Any = ...
+    force_debug_cursor: bool = ...
+    initial_queries: int = ...
+    final_queries: Optional[int] = ...
+    def __init__(self, connection: Any) -> None: ...
+    def __iter__(self): ...
+    def __getitem__(self, index: int) -> Dict[str, str]: ...
+    def __len__(self) -> int: ...
+    @property
+    def captured_queries(self) -> List[Dict[str, str]]: ...
+    def __enter__(self) -> CaptureQueriesContext: ...
+    def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ...
+
+class ignore_warnings(TestContextDecorator):
+    ignore_kwargs: Dict[str, Any] = ...
+    filter_func: Callable = ...
+    def __init__(self, **kwargs: Any) -> None: ...
+    catch_warnings: ContextManager[Optional[list]] = ...
+
+requires_tz_support: Any
+
+def isolate_lru_cache(lru_cache_object: Callable) -> Iterator[None]: ...
+
+class override_script_prefix(TestContextDecorator):
+    prefix: str = ...
+    def __init__(self, prefix: str) -> None: ...
+    old_prefix: str = ...
+
+class LoggingCaptureMixin:
+    logger: Any = ...
+    old_stream: Any = ...
+    logger_output: Any = ...
+    def setUp(self) -> None: ...
+    def tearDown(self) -> None: ...
+
+class isolate_apps(TestContextDecorator):
+    installed_apps: Tuple[str] = ...
+    def __init__(self, *installed_apps: Any, **kwargs: Any) -> None: ...
+    old_apps: Apps = ...
+
+@contextmanager
+def extend_sys_path(*paths: str) -> Iterator[None]: ...
+@contextmanager
+def captured_output(stream_name) -> Iterator[StringIO]: ...
+@contextmanager
+def captured_stdin() -> Iterator[StringIO]: ...
+@contextmanager
+def captured_stdout() -> Iterator[StringIO]: ...
+@contextmanager
+def captured_stderr() -> Iterator[StringIO]: ...
+@contextmanager
+def freeze_time(t: float) -> Iterator[None]: ...
+def tag(*tags: str): ...
+
+_Signature = str
+_TestDatabase = Tuple[str, List[str]]
+
+def dependency_ordered(
+    test_databases: Iterable[Tuple[_Signature, _TestDatabase]], dependencies: Mapping[str, List[str]]
+) -> List[Tuple[_Signature, _TestDatabase]]: ...
+def get_unique_databases_and_mirrors() -> Tuple[Dict[_Signature, _TestDatabase], Dict[str, Any]]: ...
+def teardown_databases(
+    old_config: Iterable[Tuple[Any, str, bool]], verbosity: int, parallel: int = ..., keepdb: bool = ...
+) -> None: ...
+def require_jinja2(test_func: _C) -> _C: ...
+@contextmanager
+def register_lookup(
+    field: Type[RegisterLookupMixin], *lookups: Type[Union[Lookup, Transform]], lookup_name: Optional[str] = ...
+) -> Iterator[None]: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/utils/_os.pyi

@@ -0,0 +1,11 @@
+from os.path import abspath
+from pathlib import Path
+from typing import Any, Union
+
+abspathu = abspath
+
+def upath(path: Any): ...
+def npath(path: Any): ...
+def safe_join(base: Union[bytes, str], *paths: Any) -> str: ...
+def symlinks_supported() -> Any: ...
+def to_path(value: Union[Path, str]) -> Path: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/utils/crypto.pyi

@@ -0,0 +1,15 @@
+from hmac import HMAC
+from typing import Callable, Optional, Union
+
+using_sysrandom: bool
+
+def salted_hmac(key_salt: str, value: Union[bytes, str], secret: Optional[Union[bytes, str]] = ...) -> HMAC: ...
+def get_random_string(length: int = ..., allowed_chars: str = ...) -> str: ...
+def constant_time_compare(val1: Union[bytes, str], val2: Union[bytes, str]) -> bool: ...
+def pbkdf2(
+    password: Union[bytes, str],
+    salt: Union[bytes, str],
+    iterations: int,
+    dklen: int = ...,
+    digest: Optional[Callable] = ...,
+) -> bytes: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/utils/inspect.pyi

@@ -0,0 +1,8 @@
+from typing import Callable, List, Tuple
+
+def get_func_args(func: Callable) -> List[str]: ...
+def get_func_full_args(func: Callable) -> List[Tuple[str]]: ...
+def func_accepts_kwargs(func: Callable) -> bool: ...
+def func_accepts_var_args(func: Callable) -> bool: ...
+def method_has_no_args(meth: Callable) -> bool: ...
+def func_supports_parameter(func: Callable, parameter: str) -> bool: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/utils/module_loading.pyi

@@ -0,0 +1,6 @@
+from typing import Any
+
+def import_string(dotted_path: str) -> Any: ...
+def autodiscover_modules(*args: Any, **kwargs: Any) -> None: ...
+def module_has_submodule(package: Any, module_name: str) -> bool: ...
+def module_dir(module: Any) -> str: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/utils/six.pyi

@@ -0,0 +1,106 @@
+from __future__ import print_function
+
+import types
+import typing
+import unittest
+from typing import (
+    Any,
+    AnyStr,
+    Callable,
+    Dict,
+    ItemsView,
+    Iterable,
+    KeysView,
+    Mapping,
+    NoReturn,
+    Optional,
+    Pattern,
+    Text,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    ValuesView,
+    overload,
+)
+
+# Exports
+
+_T = TypeVar("_T")
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+# TODO make constant, then move this stub to 2and3
+# https://github.com/python/typeshed/issues/17
+PY2 = False
+PY3 = True
+PY34 = ...  # type: bool
+
+string_types = (str,)
+integer_types = (int,)
+class_types = (type,)
+text_type = str
+binary_type = bytes
+
+MAXSIZE = ...  # type: int
+
+# def add_move
+# def remove_move
+
+def callable(obj: object) -> bool: ...
+def get_unbound_function(unbound: types.FunctionType) -> types.FunctionType: ...
+def create_bound_method(func: types.FunctionType, obj: object) -> types.MethodType: ...
+def create_unbound_method(func: types.FunctionType, cls: type) -> types.FunctionType: ...
+
+Iterator = object
+
+def get_method_function(meth: types.MethodType) -> types.FunctionType: ...
+def get_method_self(meth: types.MethodType) -> Optional[object]: ...
+def get_function_closure(fun: types.FunctionType) -> Optional[Tuple[types._Cell, ...]]: ...
+def get_function_code(fun: types.FunctionType) -> types.CodeType: ...
+def get_function_defaults(fun: types.FunctionType) -> Optional[Tuple[Any, ...]]: ...
+def get_function_globals(fun: types.FunctionType) -> Dict[str, Any]: ...
+def iterkeys(d: Mapping[_K, _V]) -> typing.Iterator[_K]: ...
+def itervalues(d: Mapping[_K, _V]) -> typing.Iterator[_V]: ...
+def iteritems(d: Mapping[_K, _V]) -> typing.Iterator[Tuple[_K, _V]]: ...
+
+# def iterlists
+
+def viewkeys(d: Mapping[_K, _V]) -> KeysView[_K]: ...
+def viewvalues(d: Mapping[_K, _V]) -> ValuesView[_V]: ...
+def viewitems(d: Mapping[_K, _V]) -> ItemsView[_K, _V]: ...
+def b(s: str) -> binary_type: ...
+def u(s: str) -> text_type: ...
+
+unichr = chr
+
+def int2byte(i: int) -> bytes: ...
+def byte2int(bs: binary_type) -> int: ...
+def indexbytes(buf: binary_type, i: int) -> int: ...
+def iterbytes(buf: binary_type) -> typing.Iterator[int]: ...
+def assertCountEqual(
+    self: unittest.TestCase, first: Iterable[_T], second: Iterable[_T], msg: Optional[str] = ...
+) -> None: ...
+@overload
+def assertRaisesRegex(self: unittest.TestCase, msg: Optional[str] = ...) -> Any: ...
+@overload
+def assertRaisesRegex(self: unittest.TestCase, callable_obj: Callable[..., Any], *args: Any, **kwargs: Any) -> Any: ...
+def assertRegex(
+    self: unittest.TestCase, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: Optional[str] = ...
+) -> None: ...
+
+exec_ = exec
+
+def reraise(
+    tp: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] = ...
+) -> NoReturn: ...
+def raise_from(value: Union[BaseException, Type[BaseException]], from_value: Optional[BaseException]) -> NoReturn: ...
+
+print_ = print
+
+def with_metaclass(meta: type, *bases: type) -> type: ...
+def add_metaclass(metaclass: type) -> Callable[[_T], _T]: ...
+def ensure_binary(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> bytes: ...
+def ensure_str(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> str: ...
+def ensure_text(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> Text: ...
+def python_2_unicode_compatible(klass: _T) -> _T: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/utils/timesince.pyi

@@ -0,0 +1,10 @@
+from datetime import date
+from typing import Any, Optional, Dict
+
+TIME_STRINGS: Dict[str, str]
+TIMESINCE_CHUNKS: Any
+
+def timesince(
+    d: date, now: Optional[date] = ..., reversed: bool = ..., time_strings: Optional[Dict[str, str]] = ...
+) -> str: ...
+def timeuntil(d: date, now: Optional[date] = ..., time_strings: Optional[Dict[str, str]] = ...) -> str: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/utils/translation/__init__.pyi

@@ -0,0 +1,72 @@
+import functools
+from contextlib import ContextDecorator
+from typing import Any, Optional, Callable
+
+from django.core.handlers.wsgi import WSGIRequest
+
+LANGUAGE_SESSION_KEY: str
+
+class TranslatorCommentWarning(SyntaxWarning): ...
+
+class Trans:
+    activate: Callable
+    check_for_language: functools._lru_cache_wrapper
+    deactivate: Callable
+    deactivate_all: Callable
+    get_language: Callable
+    get_language_bidi: Callable
+    get_language_from_path: Callable
+    get_language_from_request: Callable
+    gettext: Callable
+    gettext_noop: Callable
+    ngettext: Callable
+    npgettext: Callable
+    pgettext: Callable
+    def __getattr__(self, real_name: Any): ...
+
+def gettext_noop(message: str) -> str: ...
+
+ugettext_noop = gettext_noop
+
+def gettext(message: str) -> str: ...
+
+ugettext = gettext
+
+def ngettext(singular: str, plural: str, number: float) -> str: ...
+
+ungettext = ngettext
+
+def pgettext(context: str, message: str) -> str: ...
+def npgettext(context: str, singular: str, plural: str, number: int) -> str: ...
+
+gettext_lazy = gettext
+ugettext_lazy = ugettext
+pgettext_lazy = pgettext
+ngettext_lazy = ngettext
+ungettext_lazy = ungettext
+npgettext_lazy = npgettext
+
+def activate(language: str) -> None: ...
+def deactivate() -> None: ...
+
+class override(ContextDecorator):
+    language: Optional[str] = ...
+    deactivate: bool = ...
+    def __init__(self, language: Optional[str], deactivate: bool = ...) -> None: ...
+    old_language: Optional[str] = ...
+    def __enter__(self) -> None: ...
+    def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ...
+
+def get_language() -> Optional[str]: ...
+def get_language_from_path(path: str) -> Optional[str]: ...
+def get_language_bidi() -> bool: ...
+def check_for_language(lang_code: Optional[str]) -> bool: ...
+def to_language(locale: str) -> str: ...
+def to_locale(language: str) -> str: ...
+def get_language_from_request(request: WSGIRequest, check_path: bool = ...) -> str: ...
+def templatize(src: str, **kwargs: Any) -> str: ...
+def deactivate_all() -> None: ...
+def get_supported_language_variant(lang_code: str, strict: bool = ...) -> str: ...
+def get_language_info(lang_code: str) -> Any: ...
+
+from . import trans_real as trans_real

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/utils/xmlutils.pyi

@@ -0,0 +1,11 @@
+from typing import Dict, Optional
+from xml.sax.saxutils import XMLGenerator
+
+class UnserializableContentError(ValueError): ...
+
+class SimplerXMLGenerator(XMLGenerator):
+    def addQuickElement(
+        self, name: str, contents: Optional[str] = ..., attrs: Optional[Dict[str, str]] = ...
+    ) -> None: ...
+    def characters(self, content: str) -> None: ...
+    def startElement(self, name: str, attrs: Dict[str, str]) -> None: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/__init__.pyi

@@ -0,0 +1 @@
+from .generic.base import View as View

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/decorators/cache.pyi

@@ -0,0 +1,7 @@
+from typing import Any, Callable, Optional, TypeVar
+
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+def cache_page(timeout: float, *, cache: Optional[Any] = ..., key_prefix: Optional[Any] = ...) -> Callable: ...
+def cache_control(**kwargs: Any) -> Callable: ...
+def never_cache(view_func: _F) -> _F: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/decorators/clickjacking.pyi

@@ -0,0 +1,7 @@
+from typing import Callable, TypeVar, Any
+
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+def xframe_options_deny(view_func: _F) -> _F: ...
+def xframe_options_sameorigin(view_func: _F) -> _F: ...
+def xframe_options_exempt(view_func: _F) -> _F: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/decorators/csrf.pyi

@@ -0,0 +1,19 @@
+from typing import Any, Callable, TypeVar
+
+from django.middleware.csrf import CsrfViewMiddleware
+
+csrf_protect: Any
+
+class _EnsureCsrfToken(CsrfViewMiddleware): ...
+
+requires_csrf_token: Any
+
+class _EnsureCsrfCookie(CsrfViewMiddleware):
+    get_response: None
+    def process_view(self, request: Any, callback: Any, callback_args: Any, callback_kwargs: Any): ...
+
+ensure_csrf_cookie: Any
+
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+def csrf_exempt(view_func: _F) -> _F: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/decorators/debug.pyi

@@ -0,0 +1,4 @@
+from typing import Any, Callable
+
+def sensitive_variables(*variables: Any) -> Callable: ...
+def sensitive_post_parameters(*parameters: Any) -> Callable: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/decorators/gzip.pyi

@@ -0,0 +1,5 @@
+from typing import Callable, TypeVar, Any
+
+_C = TypeVar("_C", bound=Callable[..., Any])
+
+def gzip_page(view_func: _C) -> _C: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/decorators/http.pyi

@@ -0,0 +1,12 @@
+from typing import Any, Callable, List, Optional, TypeVar
+
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+def conditional_page(_F) -> _F: ...
+def require_http_methods(request_method_list: List[str]) -> Callable: ...
+def require_GET(_F) -> _F: ...
+def require_POST(_F) -> _F: ...
+def require_safe(_F) -> _F: ...
+def condition(etag_func: Optional[Callable] = ..., last_modified_func: Optional[Callable] = ...) -> Callable: ...
+def etag(etag_func: Callable[..., Any]) -> Callable[[_F], _F]: ...
+def last_modified(last_modified_func: Callable[..., Any]) -> Callable[[_F], _F]: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/decorators/vary.pyi

@@ -0,0 +1,6 @@
+from typing import Any, Callable, TypeVar
+
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+def vary_on_headers(*headers: Any) -> Callable: ...
+def vary_on_cookie(func: _F) -> _F: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/generic/base.pyi

@@ -0,0 +1,44 @@
+from typing import Any, Callable, Dict, List, Optional, Type
+
+from django import http
+
+class ContextMixin:
+    def get_context_data(self, **kwargs: Any) -> Dict[str, Any]: ...
+
+class View:
+    http_method_names: List[str] = ...
+    request: http.HttpRequest = ...
+    args: Any = ...
+    kwargs: Any = ...
+    def __init__(self, **kwargs: Any) -> None: ...
+    @classmethod
+    def as_view(cls: Any, **initkwargs: Any) -> Callable[..., http.HttpResponse]: ...
+    def setup(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> None: ...
+    def dispatch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...
+    def http_method_not_allowed(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...
+    def options(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...
+
+class TemplateResponseMixin:
+    template_name: str = ...
+    template_engine: Optional[str] = ...
+    response_class: Type[http.HttpResponse] = ...
+    content_type: Optional[str] = ...
+    request: http.HttpRequest = ...
+    def render_to_response(self, context: Dict[str, Any], **response_kwargs: Any) -> http.HttpResponse: ...
+    def get_template_names(self) -> List[str]: ...
+
+class TemplateView(TemplateResponseMixin, ContextMixin, View):
+    def get(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...
+
+class RedirectView(View):
+    permanent: bool = ...
+    url: Optional[str] = ...
+    pattern_name: Optional[str] = ...
+    query_string: bool = ...
+    def get_redirect_url(self, *args: Any, **kwargs: Any) -> Optional[str]: ...
+    def get(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...
+    def head(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...
+    def post(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...
+    def delete(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...
+    def put(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...
+    def patch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/generic/dates.pyi

@@ -0,0 +1,82 @@
+import datetime
+from typing import Any, Dict, Optional, Sequence, Tuple
+
+from django.views.generic.base import View
+from django.views.generic.detail import BaseDetailView, SingleObjectTemplateResponseMixin
+from django.views.generic.list import MultipleObjectMixin, MultipleObjectTemplateResponseMixin
+
+from django.db import models
+from django.http import HttpRequest, HttpResponse
+
+class YearMixin:
+    year_format: str = ...
+    year: Optional[str] = ...
+    def get_year_format(self) -> str: ...
+    def get_year(self) -> str: ...
+    def get_next_year(self, date: datetime.date) -> Optional[datetime.date]: ...
+    def get_previous_year(self, date: datetime.date) -> Optional[datetime.date]: ...
+
+class MonthMixin:
+    month_format: str = ...
+    month: Optional[str] = ...
+    def get_month_format(self) -> str: ...
+    def get_month(self) -> str: ...
+    def get_next_month(self, date: datetime.date) -> Optional[datetime.date]: ...
+    def get_previous_month(self, date: datetime.date) -> Optional[datetime.date]: ...
+
+class DayMixin:
+    day_format: str = ...
+    day: Optional[str] = ...
+    def get_day_format(self) -> str: ...
+    def get_day(self) -> str: ...
+    def get_next_day(self, date: datetime.date) -> Optional[datetime.date]: ...
+    def get_previous_day(self, date: datetime.date) -> Optional[datetime.date]: ...
+
+class WeekMixin:
+    week_format: str = ...
+    week: Optional[str] = ...
+    def get_week_format(self) -> str: ...
+    def get_week(self) -> str: ...
+    def get_next_week(self, date: datetime.date) -> Optional[datetime.date]: ...
+    def get_previous_week(self, date: datetime.date) -> Optional[datetime.date]: ...
+
+class DateMixin:
+    date_field: Optional[str] = ...
+    allow_future: bool = ...
+    def get_date_field(self) -> str: ...
+    def get_allow_future(self) -> bool: ...
+    def uses_datetime_field(self) -> bool: ...
+
+DatedItems = Tuple[Optional[Sequence[datetime.date]], Sequence[object], Dict[str, Any]]
+
+class BaseDateListView(MultipleObjectMixin, DateMixin, View):
+    date_list_period: str = ...
+    def render_to_response(self, context: Dict[str, Any], **response_kwargs: Any) -> HttpResponse: ...
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def get_dated_items(self) -> DatedItems: ...
+    def get_dated_queryset(self, **lookup: Any) -> models.query.QuerySet: ...
+    def get_date_list_period(self) -> str: ...
+    def get_date_list(
+        self, queryset: models.query.QuerySet, date_type: Optional[str] = ..., ordering: str = ...
+    ) -> models.query.QuerySet: ...
+
+class BaseArchiveIndexView(BaseDateListView): ...
+class ArchiveIndexView(MultipleObjectTemplateResponseMixin, BaseArchiveIndexView): ...
+
+class BaseYearArchiveView(YearMixin, BaseDateListView):
+    make_object_list: bool = ...
+    def get_make_object_list(self) -> bool: ...
+
+class YearArchiveView(MultipleObjectTemplateResponseMixin, BaseYearArchiveView): ...
+class BaseMonthArchiveView(YearMixin, MonthMixin, BaseDateListView): ...
+class MonthArchiveView(MultipleObjectTemplateResponseMixin, BaseMonthArchiveView): ...
+class BaseWeekArchiveView(YearMixin, WeekMixin, BaseDateListView): ...
+class WeekArchiveView(MultipleObjectTemplateResponseMixin, BaseWeekArchiveView): ...
+class BaseDayArchiveView(YearMixin, MonthMixin, DayMixin, BaseDateListView): ...
+class DayArchiveView(MultipleObjectTemplateResponseMixin, BaseDayArchiveView): ...
+class BaseTodayArchiveView(BaseDayArchiveView): ...
+class TodayArchiveView(MultipleObjectTemplateResponseMixin, BaseTodayArchiveView): ...
+class BaseDateDetailView(YearMixin, MonthMixin, DayMixin, DateMixin, BaseDetailView): ...
+class DateDetailView(SingleObjectTemplateResponseMixin, BaseDateDetailView): ...
+
+def timezone_today() -> datetime.date: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/generic/detail.pyi

@@ -0,0 +1,28 @@
+from typing import Any, Optional, Type
+
+from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
+
+from django.db import models
+from django.http import HttpRequest, HttpResponse
+
+class SingleObjectMixin(ContextMixin):
+    model: Type[models.Model] = ...
+    queryset: models.query.QuerySet = ...
+    slug_field: str = ...
+    context_object_name: str = ...
+    slug_url_kwarg: str = ...
+    pk_url_kwarg: str = ...
+    query_pk_and_slug: bool = ...
+    def get_object(self, queryset: Optional[models.query.QuerySet] = ...) -> models.Model: ...
+    def get_queryset(self) -> models.query.QuerySet: ...
+    def get_slug_field(self) -> str: ...
+    def get_context_object_name(self, obj: Any) -> Optional[str]: ...
+
+class BaseDetailView(SingleObjectMixin, View):
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+
+class SingleObjectTemplateResponseMixin(TemplateResponseMixin):
+    template_name_field: Optional[str] = ...
+    template_name_suffix: str = ...
+
+class DetailView(SingleObjectTemplateResponseMixin, BaseDetailView): ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/generic/edit.pyi

@@ -0,0 +1,46 @@
+from typing import Any, Callable, Dict, Optional, Sequence, Type, Union
+
+from django.forms.forms import BaseForm
+from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
+from django.views.generic.detail import BaseDetailView, SingleObjectMixin, SingleObjectTemplateResponseMixin
+from typing_extensions import Literal
+
+from django.http import HttpRequest, HttpResponse
+
+class FormMixin(ContextMixin):
+    initial: Dict[str, Any] = ...
+    form_class: Optional[Type[BaseForm]] = ...
+    success_url: Optional[Union[str, Callable[..., Any]]] = ...
+    prefix: Optional[str] = ...
+    def get_initial(self) -> Dict[str, Any]: ...
+    def get_prefix(self) -> Optional[str]: ...
+    def get_form_class(self) -> Type[BaseForm]: ...
+    def get_form(self, form_class: Optional[Type[BaseForm]] = ...) -> BaseForm: ...
+    def get_form_kwargs(self) -> Dict[str, Any]: ...
+    def get_success_url(self) -> str: ...
+    def form_valid(self, form: BaseForm) -> HttpResponse: ...
+    def form_invalid(self, form: BaseForm) -> HttpResponse: ...
+
+class ModelFormMixin(FormMixin, SingleObjectMixin):
+    fields: Optional[Union[Sequence[str], Literal["__all__"]]] = ...
+
+class ProcessFormView(View):
+    def get(self, request: HttpRequest, *args: str, **kwargs: Any) -> HttpResponse: ...
+    def post(self, request: HttpRequest, *args: str, **kwargs: Any) -> HttpResponse: ...
+    def put(self, *args: str, **kwargs: Any) -> HttpResponse: ...
+
+class BaseFormView(FormMixin, ProcessFormView): ...
+class FormView(TemplateResponseMixin, BaseFormView): ...
+class BaseCreateView(ModelFormMixin, ProcessFormView): ...
+class CreateView(SingleObjectTemplateResponseMixin, BaseCreateView): ...
+class BaseUpdateView(ModelFormMixin, ProcessFormView): ...
+class UpdateView(SingleObjectTemplateResponseMixin, BaseUpdateView): ...
+
+class DeletionMixin:
+    success_url: Optional[str] = ...
+    def post(self, request: HttpRequest, *args: str, **kwargs: Any) -> HttpResponse: ...
+    def delete(self, request: HttpRequest, *args: str, **kwargs: Any) -> HttpResponse: ...
+    def get_success_url(self) -> str: ...
+
+class BaseDeleteView(DeletionMixin, BaseDetailView): ...
+class DeleteView(SingleObjectTemplateResponseMixin, BaseDeleteView): ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/generic/list.pyi

@@ -0,0 +1,37 @@
+from typing import Any, Optional, Sequence, Tuple, Type
+
+from django.core.paginator import Paginator
+from django.db.models.query import QuerySet, _BaseQuerySet
+from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
+
+from django.db.models import Model
+from django.http import HttpRequest, HttpResponse
+
+class MultipleObjectMixin(ContextMixin):
+    allow_empty: bool = ...
+    queryset: Optional[QuerySet] = ...
+    model: Optional[Type[Model]] = ...
+    paginate_by: int = ...
+    paginate_orphans: int = ...
+    context_object_name: Optional[str] = ...
+    paginator_class: Type[Paginator] = ...
+    page_kwarg: str = ...
+    ordering: Sequence[str] = ...
+    def get_queryset(self) -> QuerySet: ...
+    def get_ordering(self) -> Sequence[str]: ...
+    def paginate_queryset(self, queryset: _BaseQuerySet, page_size: int) -> Tuple[Paginator, int, QuerySet, bool]: ...
+    def get_paginate_by(self, queryset: _BaseQuerySet) -> Optional[int]: ...
+    def get_paginator(
+        self, queryset: QuerySet, per_page: int, orphans: int = ..., allow_empty_first_page: bool = ..., **kwargs: Any
+    ) -> Paginator: ...
+    def get_paginate_orphans(self) -> int: ...
+    def get_allow_empty(self) -> bool: ...
+    def get_context_object_name(self, object_list: _BaseQuerySet) -> Optional[str]: ...
+
+class BaseListView(MultipleObjectMixin, View):
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+
+class MultipleObjectTemplateResponseMixin(TemplateResponseMixin):
+    template_name_suffix: str = ...
+
+class ListView(MultipleObjectTemplateResponseMixin, BaseListView): ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/views/i18n.pyi

@@ -0,0 +1,31 @@
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse
+from django.utils.translation.trans_real import DjangoTranslation
+
+from django.views.generic import View
+
+LANGUAGE_QUERY_PARAMETER: str
+
+def set_language(request: HttpRequest) -> HttpResponse: ...
+def get_formats() -> Dict[str, Union[List[str], int, str]]: ...
+
+js_catalog_template: str
+
+def render_javascript_catalog(catalog: Optional[Any] = ..., plural: Optional[Any] = ...): ...
+def null_javascript_catalog(request: Any, domain: Optional[Any] = ..., packages: Optional[Any] = ...): ...
+
+class JavaScriptCatalog(View):
+    head: Callable
+    domain: str = ...
+    packages: List[str] = ...
+    translation: DjangoTranslation = ...
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def get_paths(self, packages: List[str]) -> List[str]: ...
+    def get_plural(self) -> None: ...
+    def get_catalog(self) -> Dict[str, Union[List[str], str]]: ...
+    def get_context_data(self, **kwargs: Any) -> Dict[str, Any]: ...
+    def render_to_response(self, context: Dict[str, Any], **response_kwargs: Any) -> HttpResponse: ...
+
+class JSONCatalog(JavaScriptCatalog): ...

mantis_evalkit/lib/python3.10/site-packages/wheel/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+__version__ = "0.45.1"

mantis_evalkit/lib/python3.10/site-packages/wheel/__main__.py

@@ -0,0 +1,23 @@
+"""
+Wheel command line tool (enable python -m wheel syntax)
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def main():  # needed for console script
+    if __package__ == "":
+        # To be able to run 'python wheel-0.9.whl/wheel':
+        import os.path
+
+        path = os.path.dirname(os.path.dirname(__file__))
+        sys.path[0:0] = [path]
+    import wheel.cli
+
+    sys.exit(wheel.cli.main())
+
+
+if __name__ == "__main__":
+    sys.exit(main())