move generated stubs to separate directory, too messty

django-stubs-generated/urls/__init__.pyi

@@ -0,0 +1,43 @@
+# noinspection PyUnresolvedReferences
+from .base import (
+    clear_script_prefix as clear_script_prefix,
+    clear_url_caches as clear_url_caches,
+    get_script_prefix as get_script_prefix,
+    get_urlconf as get_urlconf,
+    is_valid_path as is_valid_path,
+    resolve as resolve,
+    reverse as reverse,
+    reverse_lazy as reverse_lazy,
+    set_script_prefix as set_script_prefix,
+    set_urlconf as set_urlconf,
+    translate_url as translate_url
+)
+# noinspection PyUnresolvedReferences
+from .conf import (
+    include as include,
+    path as path,
+    re_path as re_path
+)
+# noinspection PyUnresolvedReferences
+from .converters import (
+    register_converter as register_converter
+)
+# noinspection PyUnresolvedReferences
+from .exceptions import (
+    NoReverseMatch as NoReverseMatch,
+    Resolver404 as Resolver404
+)
+# noinspection PyUnresolvedReferences
+from .resolvers import (
+    LocalePrefixPattern as LocalePrefixPattern,
+    ResolverMatch as ResolverMatch,
+    URLPattern as URLPattern,
+    URLResolver as URLResolver,
+    get_ns_resolver as get_ns_resolver,
+    get_resolver as get_resolver
+)
+# noinspection PyUnresolvedReferences
+from .utils import (
+    get_callable as get_callable,
+    get_mod_func as get_mod_func
+)

django-stubs-generated/urls/base.pyi

@@ -0,0 +1,33 @@
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+from uuid import UUID
+
+from django.urls.resolvers import ResolverMatch
+
+from .exceptions import NoReverseMatch, Resolver404
+from .resolvers import get_ns_resolver, get_resolver
+from .utils import get_callable
+
+
+def resolve(path: str, urlconf: Optional[str] = ...) -> ResolverMatch: ...
+def reverse(
+    viewname: Optional[Union[Callable, str]],
+    urlconf: Optional[str] = ...,
+    args: Optional[Union[List[UUID], Tuple]] = ...,
+    kwargs: Optional[
+        Union[
+            Dict[str, None], Dict[str, bytes], Dict[str, str], Dict[str, UUID]
+        ]
+    ] = ...,
+    current_app: Optional[str] = ...,
+) -> str: ...
+
+reverse_lazy: Any
+
+def clear_url_caches() -> None: ...
+def set_script_prefix(prefix: str) -> None: ...
+def get_script_prefix() -> str: ...
+def clear_script_prefix() -> None: ...
+def set_urlconf(urlconf_name: Optional[Union[Type[Any], str]]) -> None: ...
+def get_urlconf(default: None = ...) -> Optional[Union[Type[Any], str]]: ...
+def is_valid_path(path: str, urlconf: Optional[str] = ...) -> bool: ...
+def translate_url(url: str, lang_code: str) -> str: ...

django-stubs-generated/urls/conf.pyi

@@ -0,0 +1,23 @@
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+from django.urls.resolvers import URLPattern, URLResolver
+
+from .resolvers import (LocalePrefixPattern, RegexPattern, RoutePattern,
+                        URLPattern, URLResolver)
+
+
+def include(
+    arg: Union[
+        List[Tuple[str, Callable]],
+        List[URLPattern],
+        List[URLResolver],
+        Tuple[List[URLResolver], str],
+        str,
+    ],
+    namespace: Optional[str] = ...,
+) -> Union[
+    Tuple[List[Any], str, str], Tuple[List[URLResolver], None, None]
+]: ...
+
+path: Any
+re_path: Any

django-stubs-generated/urls/converters.pyi

@@ -0,0 +1,35 @@
+from typing import Any, Dict, Optional, Type, Union
+from uuid import UUID
+
+
+class IntConverter:
+    regex: str = ...
+    def to_python(self, value: str) -> int: ...
+    def to_url(self, value: Union[int, str]) -> str: ...
+
+class StringConverter:
+    regex: str = ...
+    def to_python(self, value: str) -> str: ...
+    def to_url(self, value: Union[int, str, UUID]) -> Union[int, str, UUID]: ...
+
+class UUIDConverter:
+    regex: str = ...
+    def to_python(self, value: str) -> UUID: ...
+    def to_url(self, value: Union[str, UUID]) -> str: ...
+
+class SlugConverter(StringConverter):
+    regex: str = ...
+
+class PathConverter(StringConverter):
+    regex: str = ...
+
+DEFAULT_CONVERTERS: Any
+REGISTERED_CONVERTERS: Any
+
+def register_converter(converter: Type[Any], type_name: str) -> None: ...
+def get_converters() -> Dict[
+    str, Union[IntConverter, StringConverter, UUIDConverter]
+]: ...
+def get_converter(
+    raw_converter: str
+) -> Union[IntConverter, StringConverter, UUIDConverter]: ...

django-stubs-generated/urls/exceptions.pyi

@@ -0,0 +1,9 @@
+from django.http import Http404
+
+
+class Resolver404(Http404):
+    pass
+
+
+class NoReverseMatch(Exception):
+    pass

django-stubs-generated/urls/resolvers.pyi

@@ -0,0 +1,187 @@
+from collections import OrderedDict
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+
+from django.contrib.flatpages.sitemaps import FlatPageSitemap
+from django.contrib.sitemaps import Sitemap
+from django.core.checks.messages import CheckMessage, Warning
+from django.utils.datastructures import MultiValueDict
+
+from .converters import get_converter
+from .exceptions import NoReverseMatch, Resolver404
+from .utils import get_callable
+
+
+class ResolverMatch:
+    func: Callable = ...
+    args: Tuple = ...
+    kwargs: Dict[str, Any] = ...
+    url_name: Optional[str] = ...
+    app_names: List[str] = ...
+    app_name: str = ...
+    namespaces: List[str] = ...
+    namespace: str = ...
+    view_name: str = ...
+    def __init__(
+        self,
+        func: Callable,
+        args: Tuple,
+        kwargs: Dict[str, Any],
+        url_name: Optional[str] = ...,
+        app_names: Optional[List[Optional[str]]] = ...,
+        namespaces: Optional[List[Optional[str]]] = ...,
+    ) -> None: ...
+    def __getitem__(
+        self, index: int
+    ) -> Union[
+        Callable,
+        Dict[str, Dict[str, Type[FlatPageSitemap]]],
+        Dict[str, Dict[str, Sitemap]],
+        Dict[str, OrderedDict],
+        Dict[str, int],
+        Dict[str, str],
+        Tuple,
+    ]: ...
+
+def get_resolver(
+    urlconf: Optional[Union[Type[Any], str]] = ...
+) -> URLResolver: ...
+def get_ns_resolver(
+    ns_pattern: str, resolver: URLResolver, converters: Tuple
+) -> URLResolver: ...
+
+class LocaleRegexDescriptor:
+    attr: str = ...
+    def __init__(self, attr: Any) -> None: ...
+    def __get__(
+        self, instance: Optional[RegexPattern], cls: Type[RegexPattern] = ...
+    ) -> LocaleRegexDescriptor: ...
+
+class CheckURLMixin:
+    def describe(self) -> str: ...
+
+class RegexPattern(CheckURLMixin):
+    regex: Any = ...
+    name: Optional[str] = ...
+    converters: Dict[Any, Any] = ...
+    def __init__(
+        self, regex: str, name: Optional[str] = ..., is_endpoint: bool = ...
+    ) -> None: ...
+    def match(
+        self, path: str
+    ) -> Optional[Tuple[str, Tuple, Dict[str, str]]]: ...
+    def check(self) -> List[Warning]: ...
+
+class RoutePattern(CheckURLMixin):
+    regex: Any = ...
+    name: Optional[str] = ...
+    converters: Dict[str, django.urls.converters.UUIDConverter] = ...
+    def __init__(
+        self, route: str, name: Optional[str] = ..., is_endpoint: bool = ...
+    ) -> None: ...
+    def match(
+        self, path: str
+    ) -> Optional[Tuple[str, Tuple, Dict[str, Union[int, str]]]]: ...
+    def check(self) -> List[Warning]: ...
+
+class LocalePrefixPattern:
+    prefix_default_language: bool = ...
+    converters: Dict[Any, Any] = ...
+    def __init__(self, prefix_default_language: bool = ...) -> None: ...
+    @property
+    def regex(self): ...
+    @property
+    def language_prefix(self) -> str: ...
+    def match(
+        self, path: str
+    ) -> Optional[Tuple[str, Tuple, Dict[Any, Any]]]: ...
+    def check(self) -> List[Any]: ...
+    def describe(self) -> str: ...
+
+class URLPattern:
+    lookup_str: str
+    pattern: django.urls.resolvers.CheckURLMixin = ...
+    callback: Callable = ...
+    default_args: Dict[
+        str,
+        Union[
+            Dict[str, Type[django.contrib.flatpages.sitemaps.FlatPageSitemap]],
+            Dict[str, django.contrib.sitemaps.Sitemap],
+            collections.OrderedDict,
+            str,
+        ],
+    ] = ...
+    name: Optional[str] = ...
+    def __init__(
+        self,
+        pattern: CheckURLMixin,
+        callback: Callable,
+        default_args: Optional[
+            Union[
+                Dict[str, Dict[str, Type[FlatPageSitemap]]],
+                Dict[str, Dict[str, Sitemap]],
+                Dict[str, OrderedDict],
+                Dict[str, str],
+            ]
+        ] = ...,
+        name: Optional[str] = ...,
+    ) -> None: ...
+    def check(self) -> List[Warning]: ...
+    def resolve(self, path: str) -> Optional[ResolverMatch]: ...
+    def lookup_str(self) -> str: ...
+
+class URLResolver:
+    url_patterns: List[Tuple[str, Callable]]
+    urlconf_module: Optional[Union[List[Tuple[str, Callable]], Type[Any]]]
+    pattern: Union[
+        django.urls.resolvers.CheckURLMixin,
+        django.urls.resolvers.LocalePrefixPattern,
+    ] = ...
+    urlconf_name: Optional[
+        Union[
+            List[List[Any]],
+            List[Tuple[str, Callable]],
+            List[django.urls.resolvers.URLPattern],
+            List[django.urls.resolvers.URLResolver],
+            Type[Any],
+            str,
+        ]
+    ] = ...
+    callback: None = ...
+    default_kwargs: Dict[str, Union[Dict[Any, Any], str]] = ...
+    namespace: Optional[str] = ...
+    app_name: Optional[str] = ...
+    def __init__(
+        self,
+        pattern: Union[CheckURLMixin, LocalePrefixPattern],
+        urlconf_name: Optional[
+            Union[
+                List[List[Any]],
+                List[Tuple[str, Callable]],
+                List[URLPattern],
+                List[URLResolver],
+                Type[Any],
+                str,
+            ]
+        ],
+        default_kwargs: Optional[
+            Union[Dict[str, Dict[Any, Any]], Dict[str, str]]
+        ] = ...,
+        app_name: Optional[str] = ...,
+        namespace: Optional[str] = ...,
+    ) -> None: ...
+    def check(self) -> List[CheckMessage]: ...
+    @property
+    def reverse_dict(self) -> MultiValueDict: ...
+    @property
+    def namespace_dict(self) -> Dict[str, Tuple[str, URLResolver]]: ...
+    @property
+    def app_dict(self) -> Dict[str, List[str]]: ...
+    def resolve(self, path: str) -> ResolverMatch: ...
+    def urlconf_module(
+        self
+    ) -> Optional[Union[List[Tuple[str, Callable]], Type[Any]]]: ...
+    def url_patterns(self) -> List[Tuple[str, Callable]]: ...
+    def resolve_error_handler(
+        self, view_type: int
+    ) -> Tuple[Callable, Dict[Any, Any]]: ...
+    def reverse(self, lookup_view: str, *args: Any, **kwargs: Any) -> str: ...

django-stubs-generated/urls/utils.pyi

@@ -0,0 +1,5 @@
+from typing import Any, Callable, Optional, Tuple, Union
+
+
+def get_callable(lookup_view: Union[Callable, str]) -> Callable: ...
+def get_mod_func(callback: str) -> Tuple[str, str]: ...