mirror of
https://github.com/davidhalter/django-stubs.git
synced 2025-12-08 21:14:49 +08:00
98 lines
4.0 KiB
Python
98 lines
4.0 KiB
Python
from collections import OrderedDict, namedtuple
|
|
from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Type, Union
|
|
|
|
from django.db.backends.sqlite3.base import DatabaseWrapper
|
|
from django.db.models.base import Model
|
|
from django.db.models.expressions import Expression
|
|
from django.db.models.fields import Field
|
|
from django.db.models.fields.mixins import FieldCacheMixin
|
|
from django.db.models.functions.datetime import TimezoneMixin
|
|
from django.db.models.lookups import FieldGetDbPrepValueMixin, IntegerFieldFloatRounding, Lookup, Transform
|
|
from django.db.models.options import Options
|
|
from django.db.models.sql.compiler import SQLCompiler
|
|
from django.db.models.sql.query import Query
|
|
from django.db.models.sql.where import WhereNode
|
|
from django.utils import tree
|
|
|
|
PathInfo = namedtuple("PathInfo", "from_opts to_opts target_fields join_field m2m direct filtered_relation")
|
|
|
|
class InvalidQuery(Exception): ...
|
|
|
|
def subclasses(cls: Type[RegisterLookupMixin]) -> Iterator[Type[RegisterLookupMixin]]: ...
|
|
|
|
class QueryWrapper:
|
|
contains_aggregate: bool = ...
|
|
data: Tuple[str, List[Any]] = ...
|
|
def __init__(self, sql: str, params: List[Any]) -> None: ...
|
|
def as_sql(self, compiler: SQLCompiler = ..., connection: DatabaseWrapper = ...) -> Tuple[str, List[Any]]: ...
|
|
|
|
class Q(tree.Node):
|
|
children: Union[List[Dict[str, str]], List[Tuple[str, Any]], List[django.db.models.query_utils.Q]]
|
|
connector: str
|
|
negated: bool
|
|
AND: str = ...
|
|
OR: str = ...
|
|
default: Any = ...
|
|
conditional: bool = ...
|
|
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
|
|
def __or__(self, other: Any) -> Q: ...
|
|
def __and__(self, other: Any) -> Q: ...
|
|
def __invert__(self) -> Q: ...
|
|
def resolve_expression(
|
|
self,
|
|
query: Query = ...,
|
|
allow_joins: bool = ...,
|
|
reuse: Optional[Set[str]] = ...,
|
|
summarize: bool = ...,
|
|
for_save: bool = ...,
|
|
) -> WhereNode: ...
|
|
def deconstruct(self) -> Tuple[str, Tuple, Dict[str, str]]: ...
|
|
|
|
class DeferredAttribute:
|
|
field_name: str = ...
|
|
def __init__(self, field_name: str) -> None: ...
|
|
def __get__(self, instance: Optional[Model], cls: Type[Model] = ...) -> Any: ...
|
|
|
|
class RegisterLookupMixin:
|
|
@classmethod
|
|
def get_lookups(cls) -> Dict[str, Type[Union[TimezoneMixin, Lookup, Transform]]]: ...
|
|
def get_lookup(self, lookup_name: str) -> Optional[Type[Union[FieldGetDbPrepValueMixin, Lookup]]]: ...
|
|
def get_transform(self, lookup_name: str) -> Optional[Type[Transform]]: ...
|
|
@staticmethod
|
|
def merge_dicts(
|
|
dicts: List[
|
|
Dict[
|
|
str, Type[Union[TimezoneMixin, FieldGetDbPrepValueMixin, IntegerFieldFloatRounding, Lookup, Transform]]
|
|
]
|
|
]
|
|
) -> Dict[str, Type[Union[TimezoneMixin, FieldGetDbPrepValueMixin, Lookup, Transform]]]: ...
|
|
@classmethod
|
|
def register_lookup(
|
|
cls, lookup: Type[Union[Lookup, Transform]], lookup_name: Optional[str] = ...
|
|
) -> Type[Union[Lookup, Transform]]: ...
|
|
|
|
def select_related_descend(
|
|
field: Field,
|
|
restricted: bool,
|
|
requested: Optional[
|
|
Union[Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, Dict[Any, Any]]]]]]]], bool]
|
|
],
|
|
load_fields: Optional[Set[str]],
|
|
reverse: bool = ...,
|
|
) -> bool: ...
|
|
def refs_expression(
|
|
lookup_parts: List[str], annotations: OrderedDict
|
|
) -> Union[Tuple[bool, Tuple], Tuple[Expression, List[str]]]: ...
|
|
def check_rel_lookup_compatibility(model: Type[Model], target_opts: Options, field: FieldCacheMixin) -> bool: ...
|
|
|
|
class FilteredRelation:
|
|
relation_name: str = ...
|
|
alias: Optional[str] = ...
|
|
condition: django.db.models.query_utils.Q = ...
|
|
path: List[str] = ...
|
|
def __init__(self, relation_name: str, *, condition: Any = ...) -> None: ...
|
|
def __eq__(self, other: FilteredRelation) -> bool: ...
|
|
def clone(self) -> FilteredRelation: ...
|
|
def resolve_expression(self, *args: Any, **kwargs: Any) -> None: ...
|
|
def as_sql(self, compiler: SQLCompiler, connection: DatabaseWrapper) -> Tuple[str, List[Union[int, str]]]: ...
|