mirror of
https://github.com/davidhalter/django-stubs.git
synced 2025-12-09 05:24:53 +08:00
new semanal wip 1
This commit is contained in:
Maxim Kurnikov
@@ -1,5 +0,0 @@
|
||||
[mypy]
|
||||
incremental = True
|
||||
strict_optional = True
|
||||
plugins =
|
||||
mypy_django_plugin.main
|
||||
@@ -1,37 +0,0 @@
|
||||
[CASE missing_settings_ignored_flag]
|
||||
[env MYPY_DJANGO_CONFIG=${MYPY_CWD}/mypy_django.ini]
|
||||
[disable_cache]
|
||||
from django.conf import settings
|
||||
reveal_type(settings.NO_SUCH_SETTING) # N: Revealed type is 'Any'
|
||||
|
||||
[file mypy_django.ini]
|
||||
[[mypy_django_plugin]
|
||||
ignore_missing_settings = True
|
||||
[/CASE]
|
||||
|
||||
[CASE django_settings_via_config_file]
|
||||
[env MYPY_DJANGO_CONFIG=${MYPY_CWD}/mypy_django.ini]
|
||||
[disable_cache]
|
||||
from django.conf import settings
|
||||
reveal_type(settings.MY_SETTING) # N: Revealed type is 'builtins.int'
|
||||
|
||||
[file mypy_django.ini]
|
||||
[[mypy_django_plugin]
|
||||
django_settings = mysettings
|
||||
|
||||
[file mysettings.py]
|
||||
MY_SETTING: int = 1
|
||||
[/CASE]
|
||||
|
||||
[CASE mypy_django_ini_in_current_directory_is_a_default]
|
||||
[disable_cache]
|
||||
from django.conf import settings
|
||||
reveal_type(settings.MY_SETTING) # N: Revealed type is 'builtins.int'
|
||||
|
||||
[file mypy_django.ini]
|
||||
[[mypy_django_plugin]
|
||||
django_settings = mysettings
|
||||
|
||||
[file mysettings.py]
|
||||
MY_SETTING: int = 1
|
||||
[/CASE]
|
||||
@@ -1,144 +0,0 @@
|
||||
[CASE test_model_fields_classes_present_as_primitives]
|
||||
from django.db import models
|
||||
|
||||
class User(models.Model):
|
||||
id = models.AutoField(primary_key=True)
|
||||
small_int = models.SmallIntegerField()
|
||||
name = models.CharField(max_length=255)
|
||||
slug = models.SlugField(max_length=255)
|
||||
text = models.TextField()
|
||||
|
||||
user = User()
|
||||
reveal_type(user.id) # N: Revealed type is 'builtins.int'
|
||||
reveal_type(user.small_int) # N: Revealed type is 'builtins.int*'
|
||||
reveal_type(user.name) # N: Revealed type is 'builtins.str*'
|
||||
reveal_type(user.slug) # N: Revealed type is 'builtins.str*'
|
||||
reveal_type(user.text) # N: Revealed type is 'builtins.str*'
|
||||
[/CASE]
|
||||
|
||||
[CASE test_model_field_classes_from_existing_locations]
|
||||
from django.db import models
|
||||
from django.contrib.postgres import fields as pg_fields
|
||||
from decimal import Decimal
|
||||
|
||||
class Booking(models.Model):
|
||||
id = models.AutoField(primary_key=True)
|
||||
time_range = pg_fields.DateTimeRangeField(null=False)
|
||||
some_decimal = models.DecimalField(max_digits=10, decimal_places=5)
|
||||
|
||||
booking = Booking()
|
||||
reveal_type(booking.id) # N: Revealed type is 'builtins.int'
|
||||
reveal_type(booking.time_range) # N: Revealed type is 'Any'
|
||||
reveal_type(booking.some_decimal) # N: Revealed type is 'decimal.Decimal*'
|
||||
[/CASE]
|
||||
|
||||
[CASE test_add_id_field_if_no_primary_key_defined]
|
||||
from django.db import models
|
||||
|
||||
class User(models.Model):
|
||||
pass
|
||||
|
||||
reveal_type(User().id) # N: Revealed type is 'builtins.int'
|
||||
[/CASE]
|
||||
|
||||
[CASE test_do_not_add_id_if_field_with_primary_key_True_defined]
|
||||
from django.db import models
|
||||
|
||||
class User(models.Model):
|
||||
my_pk = models.IntegerField(primary_key=True)
|
||||
|
||||
reveal_type(User().my_pk) # N: Revealed type is 'builtins.int*'
|
||||
reveal_type(User().id)
|
||||
[out]
|
||||
main:7: note: Revealed type is 'Any'
|
||||
main:7: error: "User" has no attribute "id"
|
||||
[/CASE]
|
||||
|
||||
[CASE test_meta_nested_class_allows_subclassing_in_multiple_inheritance]
|
||||
from typing import Any
|
||||
from django.db import models
|
||||
|
||||
class Mixin1(models.Model):
|
||||
class Meta:
|
||||
abstract = True
|
||||
|
||||
class Mixin2(models.Model):
|
||||
class Meta:
|
||||
abstract = True
|
||||
|
||||
class User(Mixin1, Mixin2):
|
||||
pass
|
||||
[/CASE]
|
||||
|
||||
[CASE test_inheritance_from_abstract_model_does_not_fail_if_field_with_id_exists]
|
||||
from django.db import models
|
||||
class Abstract(models.Model):
|
||||
class Meta:
|
||||
abstract = True
|
||||
class User(Abstract):
|
||||
id = models.AutoField(primary_key=True)
|
||||
[/CASE]
|
||||
|
||||
[CASE test_primary_key_on_optional_queryset_method]
|
||||
from django.db import models
|
||||
class User(models.Model):
|
||||
pass
|
||||
reveal_type(User.objects.first().id)
|
||||
[out]
|
||||
main:4: note: Revealed type is 'Any'
|
||||
main:4: error: Item "None" of "Optional[User]" has no attribute "id"
|
||||
[/CASE]
|
||||
|
||||
[CASE standard_it_from_parent_model_could_be_overridden_with_non_integer_field_in_child_model]
|
||||
from django.db import models
|
||||
import uuid
|
||||
class ParentModel(models.Model):
|
||||
pass
|
||||
class MyModel(ParentModel):
|
||||
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
|
||||
reveal_type(MyModel().id) # N: Revealed type is 'uuid.UUID'
|
||||
[/CASE]
|
||||
|
||||
[CASE blank_and_null_char_field_allows_none]
|
||||
from django.db import models
|
||||
class MyModel(models.Model):
|
||||
nulltext=models.CharField(max_length=1, blank=True, null=True)
|
||||
MyModel(nulltext="")
|
||||
MyModel(nulltext=None)
|
||||
MyModel().nulltext=None
|
||||
reveal_type(MyModel().nulltext) # N: Revealed type is 'Union[builtins.str, None]'
|
||||
[/CASE]
|
||||
|
||||
[CASE blank_and_not_null_charfield_does_not_allow_none]
|
||||
from django.db import models
|
||||
class MyModel(models.Model):
|
||||
notnulltext=models.CharField(max_length=1, blank=True, null=False)
|
||||
MyModel(notnulltext=None) # Should allow None in constructor
|
||||
MyModel(notnulltext="")
|
||||
MyModel().notnulltext = None # E: Incompatible types in assignment (expression has type "None", variable has type "Union[str, int, Combinable]")
|
||||
reveal_type(MyModel().notnulltext) # N: Revealed type is 'builtins.str*'
|
||||
[/CASE]
|
||||
|
||||
[CASE array_field_descriptor_access]
|
||||
from django.db import models
|
||||
from django.contrib.postgres.fields import ArrayField
|
||||
|
||||
class User(models.Model):
|
||||
array = ArrayField(base_field=models.Field())
|
||||
|
||||
user = User()
|
||||
reveal_type(user.array) # N: Revealed type is 'builtins.list*[Any]'
|
||||
[/CASE]
|
||||
|
||||
[CASE array_field_base_field_parsed_into_generic_typevar]
|
||||
from django.db import models
|
||||
from django.contrib.postgres.fields import ArrayField
|
||||
|
||||
class User(models.Model):
|
||||
members = ArrayField(base_field=models.IntegerField())
|
||||
members_as_text = ArrayField(base_field=models.CharField(max_length=255))
|
||||
|
||||
user = User()
|
||||
reveal_type(user.members) # N: Revealed type is 'builtins.list*[builtins.int]'
|
||||
reveal_type(user.members_as_text) # N: Revealed type is 'builtins.list*[builtins.str]'
|
||||
[/CASE]
|
||||
@@ -1,41 +0,0 @@
|
||||
[CASE no_incompatible_meta_nested_class_false_positive]
|
||||
from django.db import models
|
||||
from django import forms
|
||||
|
||||
class Article(models.Model):
|
||||
pass
|
||||
class Category(models.Model):
|
||||
pass
|
||||
class ArticleForm(forms.ModelForm):
|
||||
class Meta:
|
||||
model = Article
|
||||
fields = '__all__'
|
||||
class CategoryForm(forms.ModelForm):
|
||||
class Meta:
|
||||
model = Category
|
||||
fields = '__all__'
|
||||
class CompositeForm(ArticleForm, CategoryForm):
|
||||
pass
|
||||
[/CASE]
|
||||
|
||||
[CASE formview_methods_on_forms_return_proper_types]
|
||||
from typing import Any
|
||||
from django import forms
|
||||
from django.views.generic.edit import FormView
|
||||
|
||||
class MyForm(forms.ModelForm):
|
||||
pass
|
||||
class MyForm2(forms.ModelForm):
|
||||
pass
|
||||
|
||||
class MyView(FormView):
|
||||
form_class = MyForm
|
||||
|
||||
def post(self, request, *args: Any, **kwds: Any):
|
||||
form_class = self.get_form_class()
|
||||
reveal_type(form_class) # N: Revealed type is 'Type[main.MyForm]'
|
||||
reveal_type(self.get_form(None)) # N: Revealed type is 'main.MyForm'
|
||||
reveal_type(self.get_form()) # N: Revealed type is 'main.MyForm'
|
||||
reveal_type(self.get_form(form_class)) # N: Revealed type is 'main.MyForm'
|
||||
reveal_type(self.get_form(MyForm2)) # N: Revealed type is 'main.MyForm2'
|
||||
[/CASE]
|
||||
@@ -1,402 +0,0 @@
|
||||
[CASE import_all_packages_to_trigger_stubs_check]
|
||||
import django.apps
|
||||
import django.apps.config
|
||||
import django.apps.registry
|
||||
import django.conf.global_settings
|
||||
import django.conf.urls
|
||||
import django.conf.urls.i18n
|
||||
import django.conf.urls.static
|
||||
import django.contrib.admin.actions
|
||||
import django.contrib.admin.apps
|
||||
import django.contrib.admin.checks
|
||||
import django.contrib.admin.decorators
|
||||
import django.contrib.admin.filters
|
||||
import django.contrib.admin.forms
|
||||
import django.contrib.admin.helpers
|
||||
import django.contrib.admin.models
|
||||
import django.contrib.admin.options
|
||||
import django.contrib.admin.sites
|
||||
import django.contrib.admin.templatetags
|
||||
import django.contrib.admin.templatetags.admin_list
|
||||
import django.contrib.admin.templatetags.admin_modify
|
||||
import django.contrib.admin.templatetags.admin_static
|
||||
import django.contrib.admin.templatetags.admin_urls
|
||||
import django.contrib.admin.templatetags.base
|
||||
import django.contrib.admin.templatetags.log
|
||||
import django.contrib.admin.utils
|
||||
import django.contrib.admin.views
|
||||
import django.contrib.admin.views.autocomplete
|
||||
import django.contrib.admin.views.decorators
|
||||
import django.contrib.admin.views.main
|
||||
import django.contrib.admin.widgets
|
||||
import django.contrib.admindocs
|
||||
import django.contrib.admindocs.middleware
|
||||
import django.contrib.admindocs.utils
|
||||
import django.contrib.admindocs.views
|
||||
import django.contrib.auth.admin
|
||||
import django.contrib.auth.apps
|
||||
import django.contrib.auth.backends
|
||||
import django.contrib.auth.base_user
|
||||
import django.contrib.auth.checks
|
||||
import django.contrib.auth.context_processors
|
||||
import django.contrib.auth.decorators
|
||||
import django.contrib.auth.forms
|
||||
import django.contrib.auth.handlers
|
||||
import django.contrib.auth.handlers.modwsgi
|
||||
import django.contrib.auth.hashers
|
||||
import django.contrib.auth.management.commands
|
||||
import django.contrib.auth.management.commands.changepassword
|
||||
import django.contrib.auth.management.commands.createsuperuser
|
||||
import django.contrib.auth.middleware
|
||||
import django.contrib.auth.mixins
|
||||
import django.contrib.auth.models
|
||||
import django.contrib.auth.password_validation
|
||||
import django.contrib.auth.signals
|
||||
import django.contrib.auth.tokens
|
||||
import django.contrib.auth.validators
|
||||
import django.contrib.auth.views
|
||||
import django.contrib.contenttypes.admin
|
||||
import django.contrib.contenttypes.apps
|
||||
import django.contrib.contenttypes.checks
|
||||
import django.contrib.contenttypes.fields
|
||||
import django.contrib.contenttypes.forms
|
||||
import django.contrib.contenttypes.management.commands
|
||||
import django.contrib.contenttypes.management.commands.remove_stale_contenttypes
|
||||
import django.contrib.contenttypes.models
|
||||
import django.contrib.contenttypes.views
|
||||
import django.contrib.flatpages.forms
|
||||
import django.contrib.flatpages.middleware
|
||||
import django.contrib.flatpages.models
|
||||
import django.contrib.flatpages.sitemaps
|
||||
import django.contrib.flatpages.templatetags
|
||||
import django.contrib.flatpages.templatetags.flatpages
|
||||
import django.contrib.flatpages.views
|
||||
import django.contrib.humanize.templatetags
|
||||
import django.contrib.humanize.templatetags.humanize
|
||||
import django.contrib.messages.api
|
||||
import django.contrib.messages.context_processors
|
||||
import django.contrib.messages.middleware
|
||||
import django.contrib.messages.storage
|
||||
import django.contrib.messages.storage.base
|
||||
import django.contrib.messages.storage.cookie
|
||||
import django.contrib.messages.storage.fallback
|
||||
import django.contrib.messages.storage.session
|
||||
import django.contrib.messages.utils
|
||||
import django.contrib.messages.views
|
||||
import django.contrib.postgres.fields
|
||||
import django.contrib.postgres.fields.array
|
||||
import django.contrib.postgres.fields.citext
|
||||
import django.contrib.postgres.fields.hstore
|
||||
import django.contrib.postgres.fields.jsonb
|
||||
import django.contrib.postgres.fields.mixins
|
||||
import django.contrib.postgres.fields.ranges
|
||||
import django.contrib.postgres.operations
|
||||
import django.contrib.redirects
|
||||
import django.contrib.redirects.middleware
|
||||
import django.contrib.redirects.models
|
||||
import django.contrib.sessions.backends
|
||||
import django.contrib.sessions.backends.base
|
||||
import django.contrib.sessions.backends.cache
|
||||
import django.contrib.sessions.backends.cached_db
|
||||
import django.contrib.sessions.backends.db
|
||||
import django.contrib.sessions.backends.file
|
||||
import django.contrib.sessions.backends.signed_cookies
|
||||
import django.contrib.sessions.base_session
|
||||
import django.contrib.sessions.management.commands
|
||||
import django.contrib.sessions.management.commands.clearsessions
|
||||
import django.contrib.sessions.middleware
|
||||
import django.contrib.sessions.models
|
||||
import django.contrib.sessions.serializers
|
||||
import django.contrib.sitemaps.management.commands
|
||||
import django.contrib.sitemaps.management.commands.ping_google
|
||||
import django.contrib.sitemaps.views
|
||||
import django.contrib.sites
|
||||
import django.contrib.sites.apps
|
||||
import django.contrib.sites.management
|
||||
import django.contrib.sites.managers
|
||||
import django.contrib.sites.middleware
|
||||
import django.contrib.sites.models
|
||||
import django.contrib.sites.requests
|
||||
import django.contrib.sites.shortcuts
|
||||
import django.contrib.staticfiles.apps
|
||||
import django.contrib.staticfiles.checks
|
||||
import django.contrib.staticfiles.finders
|
||||
import django.contrib.staticfiles.handlers
|
||||
import django.contrib.staticfiles.management.commands
|
||||
import django.contrib.staticfiles.management.commands.collectstatic
|
||||
import django.contrib.staticfiles.management.commands.findstatic
|
||||
import django.contrib.staticfiles.management.commands.runserver
|
||||
import django.contrib.staticfiles.storage
|
||||
import django.contrib.staticfiles.templatetags
|
||||
import django.contrib.staticfiles.templatetags.staticfiles
|
||||
import django.contrib.staticfiles.urls
|
||||
import django.contrib.staticfiles.utils
|
||||
import django.contrib.staticfiles.views
|
||||
import django.contrib.syndication
|
||||
import django.contrib.syndication.views
|
||||
import django.core.cache.backends
|
||||
import django.core.cache.backends.base
|
||||
import django.core.cache.backends.db
|
||||
import django.core.cache.backends.dummy
|
||||
import django.core.cache.backends.filebased
|
||||
import django.core.cache.backends.locmem
|
||||
import django.core.cache.utils
|
||||
import django.core.checks.caches
|
||||
import django.core.checks.database
|
||||
import django.core.checks.messages
|
||||
import django.core.checks.model_checks
|
||||
import django.core.checks.registry
|
||||
import django.core.checks.security
|
||||
import django.core.checks.security.base
|
||||
import django.core.checks.security.csrf
|
||||
import django.core.checks.security.sessions
|
||||
import django.core.checks.templates
|
||||
import django.core.checks.urls
|
||||
import django.core.exceptions
|
||||
import django.core.files
|
||||
import django.core.files.base
|
||||
import django.core.files.images
|
||||
import django.core.files.locks
|
||||
import django.core.files.move
|
||||
import django.core.files.storage
|
||||
import django.core.files.temp
|
||||
import django.core.files.uploadedfile
|
||||
import django.core.files.uploadhandler
|
||||
import django.core.files.utils
|
||||
import django.core.handlers
|
||||
import django.core.handlers.base
|
||||
import django.core.handlers.exception
|
||||
import django.core.handlers.wsgi
|
||||
import django.core.mail
|
||||
import django.core.mail.message
|
||||
import django.core.mail.utils
|
||||
import django.core.management
|
||||
import django.core.management.base
|
||||
import django.core.management.color
|
||||
import django.core.management.sql
|
||||
import django.core.management.templates
|
||||
import django.core.management.utils
|
||||
import django.core.paginator
|
||||
import django.core.serializers
|
||||
import django.core.serializers.base
|
||||
import django.core.serializers.json
|
||||
import django.core.serializers.python
|
||||
import django.core.servers
|
||||
import django.core.servers.basehttp
|
||||
import django.core.signals
|
||||
import django.core.signing
|
||||
import django.core.validators
|
||||
import django.core.wsgi
|
||||
import django.db.backends.base
|
||||
import django.db.backends.base.base
|
||||
import django.db.backends.base.client
|
||||
import django.db.backends.base.creation
|
||||
import django.db.backends.base.features
|
||||
import django.db.backends.base.introspection
|
||||
import django.db.backends.base.operations
|
||||
import django.db.backends.base.schema
|
||||
import django.db.backends.base.validation
|
||||
import django.db.backends.ddl_references
|
||||
import django.db.backends.dummy
|
||||
import django.db.backends.dummy.base
|
||||
import django.db.backends.mysql
|
||||
import django.db.backends.mysql.client
|
||||
import django.db.backends.postgresql
|
||||
import django.db.backends.postgresql.client
|
||||
import django.db.backends.sqlite3
|
||||
import django.db.backends.sqlite3.base
|
||||
import django.db.backends.sqlite3.creation
|
||||
import django.db.backends.sqlite3.features
|
||||
import django.db.backends.sqlite3.introspection
|
||||
import django.db.backends.sqlite3.operations
|
||||
import django.db.backends.sqlite3.schema
|
||||
import django.db.backends.utils
|
||||
import django.db.migrations.autodetector
|
||||
import django.db.migrations.exceptions
|
||||
import django.db.migrations.executor
|
||||
import django.db.migrations.graph
|
||||
import django.db.migrations.loader
|
||||
import django.db.migrations.migration
|
||||
import django.db.migrations.operations
|
||||
import django.db.migrations.operations.base
|
||||
import django.db.migrations.operations.fields
|
||||
import django.db.migrations.operations.models
|
||||
import django.db.migrations.operations.special
|
||||
import django.db.migrations.operations.utils
|
||||
import django.db.migrations.optimizer
|
||||
import django.db.migrations.questioner
|
||||
import django.db.migrations.recorder
|
||||
import django.db.migrations.serializer
|
||||
import django.db.migrations.state
|
||||
import django.db.migrations.topological_sort
|
||||
import django.db.migrations.utils
|
||||
import django.db.migrations.writer
|
||||
import django.db.models.aggregates
|
||||
import django.db.models.base
|
||||
import django.db.models.deletion
|
||||
import django.db.models.expressions
|
||||
import django.db.models.fields
|
||||
import django.db.models.fields.files
|
||||
import django.db.models.fields.mixins
|
||||
import django.db.models.fields.proxy
|
||||
import django.db.models.fields.related
|
||||
import django.db.models.fields.related_descriptors
|
||||
import django.db.models.fields.related_lookups
|
||||
import django.db.models.fields.reverse_related
|
||||
import django.db.models.functions
|
||||
import django.db.models.functions.comparison
|
||||
import django.db.models.functions.datetime
|
||||
import django.db.models.functions.text
|
||||
import django.db.models.functions.window
|
||||
import django.db.models.indexes
|
||||
import django.db.models.lookups
|
||||
import django.db.models.manager
|
||||
import django.db.models.options
|
||||
import django.db.models.query
|
||||
import django.db.models.query_utils
|
||||
import django.db.models.signals
|
||||
import django.db.models.sql
|
||||
import django.db.models.sql.compiler
|
||||
import django.db.models.sql.constants
|
||||
import django.db.models.sql.datastructures
|
||||
import django.db.models.sql.query
|
||||
import django.db.models.sql.subqueries
|
||||
import django.db.models.sql.where
|
||||
import django.db.models.utils
|
||||
import django.db.transaction
|
||||
import django.db.utils
|
||||
import django.dispatch
|
||||
import django.dispatch.dispatcher
|
||||
import django.forms
|
||||
import django.forms.boundfield
|
||||
import django.forms.fields
|
||||
import django.forms.forms
|
||||
import django.forms.formsets
|
||||
import django.forms.models
|
||||
import django.forms.renderers
|
||||
import django.forms.utils
|
||||
import django.forms.widgets
|
||||
import django.http
|
||||
import django.http.cookie
|
||||
import django.http.multipartparser
|
||||
import django.http.request
|
||||
import django.http.response
|
||||
import django.middleware
|
||||
import django.middleware.cache
|
||||
import django.middleware.clickjacking
|
||||
import django.middleware.common
|
||||
import django.middleware.csrf
|
||||
import django.middleware.gzip
|
||||
import django.middleware.http
|
||||
import django.middleware.locale
|
||||
import django.middleware.security
|
||||
import django.shortcuts
|
||||
import django.template.backends
|
||||
import django.template.backends.base
|
||||
import django.template.backends.django
|
||||
import django.template.backends.dummy
|
||||
import django.template.backends.jinja2
|
||||
import django.template.backends.utils
|
||||
import django.template.base
|
||||
import django.template.context
|
||||
import django.template.context_processors
|
||||
import django.template.defaultfilters
|
||||
import django.template.defaulttags
|
||||
import django.template.engine
|
||||
import django.template.exceptions
|
||||
import django.template.library
|
||||
import django.template.loader
|
||||
import django.template.loader_tags
|
||||
import django.template.loaders
|
||||
import django.template.loaders.app_directories
|
||||
import django.template.loaders.base
|
||||
import django.template.loaders.cached
|
||||
import django.template.loaders.filesystem
|
||||
import django.template.loaders.locmem
|
||||
import django.template.response
|
||||
import django.template.smartif
|
||||
import django.template.utils
|
||||
import django.templatetags
|
||||
import django.templatetags.cache
|
||||
import django.templatetags.i18n
|
||||
import django.templatetags.l10n
|
||||
import django.templatetags.static
|
||||
import django.templatetags.tz
|
||||
import django.test
|
||||
import django.test.client
|
||||
import django.test.html
|
||||
import django.test.runner
|
||||
import django.test.selenium
|
||||
import django.test.signals
|
||||
import django.test.testcases
|
||||
import django.test.utils
|
||||
import django.urls
|
||||
import django.urls.base
|
||||
import django.urls.conf
|
||||
import django.urls.converters
|
||||
import django.urls.exceptions
|
||||
import django.urls.resolvers
|
||||
import django.urls.utils
|
||||
import django.utils._os
|
||||
import django.utils.archive
|
||||
import django.utils.autoreload
|
||||
import django.utils.baseconv
|
||||
import django.utils.cache
|
||||
import django.utils.crypto
|
||||
import django.utils.datastructures
|
||||
import django.utils.dateformat
|
||||
import django.utils.dateparse
|
||||
import django.utils.dates
|
||||
import django.utils.datetime_safe
|
||||
import django.utils.deconstruct
|
||||
import django.utils.decorators
|
||||
import django.utils.deprecation
|
||||
import django.utils.duration
|
||||
import django.utils.encoding
|
||||
import django.utils.feedgenerator
|
||||
import django.utils.formats
|
||||
import django.utils.functional
|
||||
import django.utils.html
|
||||
import django.utils.http
|
||||
import django.utils.inspect
|
||||
import django.utils.ipv6
|
||||
import django.utils.itercompat
|
||||
import django.utils.jslex
|
||||
import django.utils.log
|
||||
import django.utils.lorem_ipsum
|
||||
import django.utils.module_loading
|
||||
import django.utils.numberformat
|
||||
import django.utils.regex_helper
|
||||
import django.utils.safestring
|
||||
import django.utils.six
|
||||
import django.utils.termcolors
|
||||
import django.utils.text
|
||||
import django.utils.timesince
|
||||
import django.utils.timezone
|
||||
import django.utils.translation
|
||||
import django.utils.translation.template
|
||||
import django.utils.translation.trans_null
|
||||
import django.utils.translation.trans_real
|
||||
import django.utils.tree
|
||||
import django.utils.version
|
||||
import django.utils.xmlutils
|
||||
import django.views.csrf
|
||||
import django.views.debug
|
||||
import django.views.decorators
|
||||
import django.views.decorators.cache
|
||||
import django.views.decorators.clickjacking
|
||||
import django.views.decorators.csrf
|
||||
import django.views.decorators.debug
|
||||
import django.views.decorators.gzip
|
||||
import django.views.decorators.http
|
||||
import django.views.decorators.vary
|
||||
import django.views.defaults
|
||||
import django.views.generic
|
||||
import django.views.generic.base
|
||||
import django.views.generic.dates
|
||||
import django.views.generic.detail
|
||||
import django.views.generic.edit
|
||||
import django.views.generic.list
|
||||
import django.views.i18n
|
||||
import django.views.static
|
||||
[/CASE]
|
||||
@@ -1,201 +0,0 @@
|
||||
[CASE test_every_model_has_objects_queryset_available]
|
||||
from django.db import models
|
||||
class User(models.Model):
|
||||
pass
|
||||
reveal_type(User.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.User]'
|
||||
reveal_type(User.objects.get()) # N: Revealed type is 'main.User*'
|
||||
|
||||
[CASE every_model_has_its_own_objects_queryset]
|
||||
from django.db import models
|
||||
class Parent(models.Model):
|
||||
pass
|
||||
class Child(Parent):
|
||||
pass
|
||||
reveal_type(Parent.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.Parent]'
|
||||
reveal_type(Child.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.Child]'
|
||||
[out]
|
||||
|
||||
[CASE if_manager_is_defined_on_model_do_not_add_objects]
|
||||
from django.db import models
|
||||
|
||||
class MyModel(models.Model):
|
||||
authors = models.Manager[MyModel]()
|
||||
reveal_type(MyModel.authors) # N: Revealed type is 'django.db.models.manager.Manager[main.MyModel]'
|
||||
MyModel.objects # E: "Type[MyModel]" has no attribute "objects"
|
||||
[out]
|
||||
|
||||
[CASE test_model_objects_attribute_present_in_case_of_model_cls_passed_as_generic_parameter]
|
||||
from typing import TypeVar, Generic, Type
|
||||
from django.db import models
|
||||
|
||||
_T = TypeVar('_T', bound=models.Model)
|
||||
class Base(Generic[_T]):
|
||||
def __init__(self, model_cls: Type[_T]):
|
||||
self.model_cls = model_cls
|
||||
reveal_type(self.model_cls._default_manager) # N: Revealed type is 'django.db.models.manager.Manager[django.db.models.base.Model]'
|
||||
class MyModel(models.Model):
|
||||
pass
|
||||
base_instance = Base(MyModel)
|
||||
reveal_type(base_instance.model_cls._default_manager) # N: Revealed type is 'django.db.models.manager.Manager[main.MyModel]'
|
||||
|
||||
class Child(Base[MyModel]):
|
||||
def method(self) -> None:
|
||||
reveal_type(self.model_cls._default_manager) # N: Revealed type is 'django.db.models.manager.Manager[main.MyModel]'
|
||||
|
||||
[CASE if_custom_manager_defined_it_is_set_to_default_manager]
|
||||
from typing import TypeVar
|
||||
from django.db import models
|
||||
_T = TypeVar('_T', bound=models.Model)
|
||||
class CustomManager(models.Manager[_T]):
|
||||
pass
|
||||
class MyModel(models.Model):
|
||||
manager = CustomManager[MyModel]()
|
||||
reveal_type(MyModel._default_manager) # N: Revealed type is 'main.CustomManager[main.MyModel]'
|
||||
|
||||
[CASE if_default_manager_name_is_passed_set_default_manager_to_it]
|
||||
from typing import TypeVar
|
||||
from django.db import models
|
||||
|
||||
_T = TypeVar('_T', bound=models.Model)
|
||||
class Manager1(models.Manager[_T]):
|
||||
pass
|
||||
class Manager2(models.Manager[_T]):
|
||||
pass
|
||||
class MyModel(models.Model):
|
||||
class Meta:
|
||||
default_manager_name = 'm2'
|
||||
m1: Manager1[MyModel]
|
||||
m2: Manager2[MyModel]
|
||||
reveal_type(MyModel._default_manager) # N: Revealed type is 'main.Manager2[main.MyModel]'
|
||||
|
||||
[CASE test_leave_as_is_if_objects_is_set_and_fill_typevars_with_outer_class]
|
||||
from django.db import models
|
||||
|
||||
class UserManager(models.Manager[MyUser]):
|
||||
def get_or_404(self) -> MyUser:
|
||||
pass
|
||||
|
||||
class MyUser(models.Model):
|
||||
objects = UserManager()
|
||||
|
||||
reveal_type(MyUser.objects) # N: Revealed type is 'main.UserManager[main.MyUser]'
|
||||
reveal_type(MyUser.objects.get()) # N: Revealed type is 'main.MyUser*'
|
||||
reveal_type(MyUser.objects.get_or_404()) # N: Revealed type is 'main.MyUser'
|
||||
|
||||
[CASE model_imported_from_different_file]
|
||||
from django.db import models
|
||||
from models.main import Inventory
|
||||
|
||||
class Band(models.Model):
|
||||
pass
|
||||
reveal_type(Inventory.objects) # N: Revealed type is 'django.db.models.manager.Manager[models.main.Inventory]'
|
||||
reveal_type(Band.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.Band]'
|
||||
[file models/__init__.py]
|
||||
[file models/main.py]
|
||||
from django.db import models
|
||||
class Inventory(models.Model):
|
||||
pass
|
||||
|
||||
[CASE managers_that_defined_on_other_models_do_not_influence]
|
||||
from django.db import models
|
||||
|
||||
class AbstractPerson(models.Model):
|
||||
abstract_persons = models.Manager[AbstractPerson]()
|
||||
class PublishedBookManager(models.Manager[Book]):
|
||||
pass
|
||||
class AnnotatedBookManager(models.Manager[Book]):
|
||||
pass
|
||||
class Book(models.Model):
|
||||
title = models.CharField(max_length=50)
|
||||
published_objects = PublishedBookManager()
|
||||
annotated_objects = AnnotatedBookManager()
|
||||
|
||||
reveal_type(AbstractPerson.abstract_persons) # N: Revealed type is 'django.db.models.manager.Manager[main.AbstractPerson]'
|
||||
reveal_type(Book.published_objects) # N: Revealed type is 'main.PublishedBookManager[main.Book]'
|
||||
Book.published_objects.create(title='hello')
|
||||
reveal_type(Book.annotated_objects) # N: Revealed type is 'main.AnnotatedBookManager[main.Book]'
|
||||
Book.annotated_objects.create(title='hello')
|
||||
[out]
|
||||
|
||||
[CASE managers_inherited_from_abstract_classes_multiple_inheritance]
|
||||
from django.db import models
|
||||
class CustomManager1(models.Manager[AbstractBase1]):
|
||||
pass
|
||||
class AbstractBase1(models.Model):
|
||||
class Meta:
|
||||
abstract = True
|
||||
name = models.CharField(max_length=50)
|
||||
manager1 = CustomManager1()
|
||||
class CustomManager2(models.Manager[AbstractBase2]):
|
||||
pass
|
||||
class AbstractBase2(models.Model):
|
||||
class Meta:
|
||||
abstract = True
|
||||
value = models.CharField(max_length=50)
|
||||
restricted = CustomManager2()
|
||||
|
||||
class Child(AbstractBase1, AbstractBase2):
|
||||
pass
|
||||
[out]
|
||||
|
||||
[CASE managers_from_unrelated_models_dont_interfere]
|
||||
|
||||
from django.db import models
|
||||
|
||||
# Normal scenario where one model has a manager with an annotation of the same type as the model
|
||||
class UnrelatedModel(models.Model):
|
||||
objects = models.Manager[UnrelatedModel]()
|
||||
|
||||
class MyModel(models.Model):
|
||||
pass
|
||||
|
||||
reveal_type(UnrelatedModel.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.UnrelatedModel]'
|
||||
reveal_type(UnrelatedModel.objects.first()) # N: Revealed type is 'Union[main.UnrelatedModel*, None]'
|
||||
|
||||
reveal_type(MyModel.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.MyModel]'
|
||||
reveal_type(MyModel.objects.first()) # N: Revealed type is 'Union[main.MyModel*, None]'
|
||||
|
||||
# Possible to specify objects without explicit annotation of models.Manager()
|
||||
class UnrelatedModel2(models.Model):
|
||||
objects = models.Manager()
|
||||
|
||||
class MyModel2(models.Model):
|
||||
pass
|
||||
|
||||
reveal_type(UnrelatedModel2.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.UnrelatedModel2]'
|
||||
reveal_type(UnrelatedModel2.objects.first()) # N: Revealed type is 'Union[main.UnrelatedModel2*, None]'
|
||||
|
||||
reveal_type(MyModel2.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.MyModel2]'
|
||||
reveal_type(MyModel2.objects.first()) # N: Revealed type is 'Union[main.MyModel2*, None]'
|
||||
|
||||
|
||||
# Inheritance works
|
||||
class ParentOfMyModel3(models.Model):
|
||||
objects = models.Manager()
|
||||
|
||||
class MyModel3(ParentOfMyModel3):
|
||||
pass
|
||||
|
||||
|
||||
reveal_type(ParentOfMyModel3.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.ParentOfMyModel3]'
|
||||
reveal_type(ParentOfMyModel3.objects.first()) # N: Revealed type is 'Union[main.ParentOfMyModel3*, None]'
|
||||
|
||||
reveal_type(MyModel3.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.MyModel3]'
|
||||
reveal_type(MyModel3.objects.first()) # N: Revealed type is 'Union[main.MyModel3*, None]'
|
||||
|
||||
|
||||
# Inheritance works with explicit objects in child
|
||||
class ParentOfMyModel4(models.Model):
|
||||
objects = models.Manager()
|
||||
|
||||
class MyModel4(ParentOfMyModel4):
|
||||
objects = models.Manager[MyModel4]()
|
||||
|
||||
reveal_type(ParentOfMyModel4.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.ParentOfMyModel4]'
|
||||
reveal_type(ParentOfMyModel4.objects.first()) # N: Revealed type is 'Union[main.ParentOfMyModel4*, None]'
|
||||
|
||||
reveal_type(MyModel4.objects) # N: Revealed type is 'django.db.models.manager.Manager[main.MyModel4]'
|
||||
reveal_type(MyModel4.objects.first()) # N: Revealed type is 'Union[main.MyModel4*, None]'
|
||||
|
||||
|
||||
[out]
|
||||
@@ -1,10 +0,0 @@
|
||||
[CASE successmessagemixin_compatible_with_formmixin]
|
||||
from django.views.generic.edit import FormMixin
|
||||
from django.contrib.messages.views import SuccessMessageMixin
|
||||
|
||||
class FormFirstView(FormMixin, SuccessMessageMixin):
|
||||
pass
|
||||
|
||||
class SuccessMessageFirstView(FormMixin, SuccessMessageMixin):
|
||||
pass
|
||||
[/CASE]
|
||||
@@ -1,48 +0,0 @@
|
||||
[CASE registry_apps_get_model]
|
||||
from django.apps.registry import Apps
|
||||
from typing import TYPE_CHECKING
|
||||
if TYPE_CHECKING:
|
||||
from myapp.models import User
|
||||
apps = Apps()
|
||||
model_cls = apps.get_model('myapp', 'User')
|
||||
reveal_type(model_cls) # N: Revealed type is 'Type[myapp.models.User]'
|
||||
reveal_type(model_cls.objects) # N: Revealed type is 'django.db.models.manager.Manager[myapp.models.User]'
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models.py]
|
||||
from django.db import models
|
||||
class User(models.Model):
|
||||
pass
|
||||
|
||||
[CASE registry_apps_get_model_passed_as_variables_not_supported]
|
||||
from django.apps.registry import Apps
|
||||
from typing import TYPE_CHECKING
|
||||
if TYPE_CHECKING:
|
||||
from myapp.models import User
|
||||
app_name = 'myapp'
|
||||
model_name = 'User'
|
||||
apps = Apps()
|
||||
model_cls = apps.get_model(app_name, model_name)
|
||||
reveal_type(model_cls) # N: Revealed type is 'Type[django.db.models.base.Model]'
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models.py]
|
||||
from django.db import models
|
||||
class User(models.Model):
|
||||
pass
|
||||
|
||||
[CASE state_apps_get_model]
|
||||
from django.db.migrations.state import StateApps
|
||||
from typing import TYPE_CHECKING
|
||||
if TYPE_CHECKING:
|
||||
from myapp.models import User
|
||||
apps = StateApps([], {})
|
||||
model_cls = apps.get_model('myapp', 'User')
|
||||
reveal_type(model_cls) # N: Revealed type is 'Type[myapp.models.User]'
|
||||
reveal_type(model_cls.objects) # N: Revealed type is 'django.db.models.manager.Manager[myapp.models.User]'
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models.py]
|
||||
from django.db import models
|
||||
class User(models.Model):
|
||||
pass
|
||||
@@ -1,60 +0,0 @@
|
||||
[CASE test_typechecking_for_model_subclasses]
|
||||
from django.db import models
|
||||
|
||||
class A(models.Model):
|
||||
pass
|
||||
class B(models.Model):
|
||||
b_attr = 1
|
||||
pass
|
||||
class C(A):
|
||||
pass
|
||||
|
||||
def service(a: A) -> int:
|
||||
pass
|
||||
|
||||
b_instance = B()
|
||||
service(b_instance) # E: Argument 1 to "service" has incompatible type "B"; expected "A"
|
||||
|
||||
a_instance = A()
|
||||
c_instance = C()
|
||||
service(a_instance)
|
||||
service(c_instance)
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE fail_if_no_such_attribute_on_model]
|
||||
from django.db import models
|
||||
|
||||
class B(models.Model):
|
||||
b_attr = 1
|
||||
pass
|
||||
|
||||
b_instance = B()
|
||||
reveal_type(b_instance.b_attr) # N: Revealed type is 'builtins.int'
|
||||
|
||||
reveal_type(b_instance.non_existent_attribute)
|
||||
b_instance.non_existent_attribute = 2
|
||||
[out]
|
||||
main:10: note: Revealed type is 'Any'
|
||||
main:10: error: "B" has no attribute "non_existent_attribute"
|
||||
main:11: error: "B" has no attribute "non_existent_attribute"
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE ignore_missing_attributes_if_setting_is_passed]
|
||||
from django.db import models
|
||||
|
||||
class B(models.Model):
|
||||
pass
|
||||
|
||||
b_instance = B()
|
||||
reveal_type(b_instance.non_existent_attribute) # N: Revealed type is 'Any'
|
||||
b_instance.non_existent_attribute = 2
|
||||
|
||||
[env MYPY_DJANGO_CONFIG=${MYPY_CWD}/mypy_django.ini]
|
||||
|
||||
[file mypy_django.ini]
|
||||
[[mypy_django_plugin]
|
||||
ignore_missing_model_attributes = True
|
||||
|
||||
[/CASE]
|
||||
@@ -1,64 +0,0 @@
|
||||
[CASE default_manager_create_is_typechecked]
|
||||
from django.db import models
|
||||
|
||||
class User(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
age = models.IntegerField()
|
||||
|
||||
User.objects.create(name='Max', age=10)
|
||||
User.objects.create(age=[]) # E: Incompatible type for "age" of "User" (got "List[Any]", expected "Union[float, int, str, Combinable]")
|
||||
[out]
|
||||
|
||||
[CASE model_recognises_parent_attributes]
|
||||
from django.db import models
|
||||
|
||||
class Parent(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
class Child(Parent):
|
||||
lastname = models.CharField(max_length=100)
|
||||
Child.objects.create(name='Maxim', lastname='Maxim2')
|
||||
[out]
|
||||
|
||||
[CASE deep_multiple_inheritance_with_create]
|
||||
from django.db import models
|
||||
|
||||
class Parent1(models.Model):
|
||||
name1 = models.CharField(max_length=50)
|
||||
class Parent2(models.Model):
|
||||
id2 = models.AutoField(primary_key=True)
|
||||
name2 = models.CharField(max_length=50)
|
||||
|
||||
class Child1(Parent1, Parent2):
|
||||
value = models.IntegerField()
|
||||
class Child4(Child1):
|
||||
value4 = models.IntegerField()
|
||||
Child4.objects.create(name1='n1', name2='n2', value=1, value4=4)
|
||||
|
||||
[CASE optional_primary_key_for_create_is_error]
|
||||
from django.db import models
|
||||
class MyModel(models.Model):
|
||||
pass
|
||||
MyModel.objects.create(id=None) # E: Incompatible type for "id" of "MyModel" (got "None", expected "int")
|
||||
|
||||
[CASE optional_related_model_for_create_is_error]
|
||||
from django.db import models
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)
|
||||
Book.objects.create(publisher=None) # E: Incompatible type for "publisher" of "Book" (got "None", expected "Union[Publisher, Combinable]")
|
||||
|
||||
[CASE when_default_for_primary_key_is_specified_allow_none_to_be_set]
|
||||
from django.db import models
|
||||
def return_int():
|
||||
return 0
|
||||
class MyModel(models.Model):
|
||||
id = models.IntegerField(primary_key=True, default=return_int)
|
||||
MyModel(id=None)
|
||||
MyModel.objects.create(id=None)
|
||||
|
||||
class MyModel2(models.Model):
|
||||
id = models.IntegerField(primary_key=True, default=None)
|
||||
MyModel2(id=None) # E: Incompatible type for "id" of "MyModel2" (got "None", expected "Union[float, int, str, Combinable]")
|
||||
MyModel2.objects.create(id=None) # E: Incompatible type for "id" of "MyModel2" (got "None", expected "Union[float, int, str, Combinable]")
|
||||
[out]
|
||||
@@ -1,177 +0,0 @@
|
||||
[CASE arguments_to_init_unexpected_attributes]
|
||||
from django.db import models
|
||||
|
||||
class MyUser(models.Model):
|
||||
pass
|
||||
user = MyUser(name=1, age=12)
|
||||
[out]
|
||||
main:5: error: Unexpected attribute "name" for model "MyUser"
|
||||
main:5: error: Unexpected attribute "age" for model "MyUser"
|
||||
|
||||
[CASE arguments_to_init_from_class_incompatible_type]
|
||||
from django.db import models
|
||||
|
||||
class MyUser(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
age = models.IntegerField()
|
||||
user = MyUser(name='hello', age=[])
|
||||
[out]
|
||||
main:6: error: Incompatible type for "age" of "MyUser" (got "List[Any]", expected "Union[float, int, str, Combinable]")
|
||||
|
||||
[CASE arguments_to_init_combined_from_base_classes]
|
||||
from django.db import models
|
||||
|
||||
class BaseUser(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
age = models.IntegerField()
|
||||
class ChildUser(BaseUser):
|
||||
lastname = models.CharField(max_length=100)
|
||||
user = ChildUser(name='Max', age=12, lastname='Lastname')
|
||||
[out]
|
||||
|
||||
[CASE fields_from_abstract_user_propagate_to_init]
|
||||
from django.contrib.auth.models import AbstractUser
|
||||
|
||||
class MyUser(AbstractUser):
|
||||
pass
|
||||
user = MyUser(username='maxim', password='password', first_name='Max', last_name='MaxMax')
|
||||
[out]
|
||||
|
||||
[CASE generic_foreign_key_field_no_typechecking]
|
||||
from django.db import models
|
||||
from django.contrib.contenttypes.fields import GenericForeignKey
|
||||
|
||||
class MyUser(models.Model):
|
||||
content_object = GenericForeignKey()
|
||||
|
||||
user = MyUser(content_object=1)
|
||||
[out]
|
||||
|
||||
[CASE pk_refers_to_primary_key_and_could_be_passed_to_init]
|
||||
from django.db import models
|
||||
|
||||
class MyUser1(models.Model):
|
||||
mypk = models.CharField(primary_key=True)
|
||||
class MyUser2(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
user2 = MyUser1(pk='hello')
|
||||
user3= MyUser2(pk=1)
|
||||
[out]
|
||||
|
||||
[CASE typechecking_of_pk]
|
||||
from django.db import models
|
||||
|
||||
class MyUser1(models.Model):
|
||||
mypk = models.IntegerField(primary_key=True)
|
||||
user = MyUser1(pk=[]) # E: Incompatible type for "pk" of "MyUser1" (got "List[Any]", expected "Union[float, int, str, Combinable]")
|
||||
[out]
|
||||
|
||||
[CASE can_set_foreign_key_by_its_primary_key]
|
||||
from django.db import models
|
||||
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
class PublisherDatetime(models.Model):
|
||||
dt_pk = models.DateTimeField(primary_key=True)
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)
|
||||
publisher_dt = models.ForeignKey(PublisherDatetime, on_delete=models.CASCADE)
|
||||
|
||||
Book(publisher_id=1)
|
||||
Book(publisher_id=[]) # E: Incompatible type for "publisher_id" of "Book" (got "List[Any]", expected "Union[Combinable, int, str, None]")
|
||||
Book(publisher_dt_id=11) # E: Incompatible type for "publisher_dt_id" of "Book" (got "int", expected "Union[str, date, Combinable, None]")
|
||||
[out]
|
||||
|
||||
[CASE setting_value_to_an_array_of_ints]
|
||||
from typing import List, Tuple
|
||||
|
||||
from django.db import models
|
||||
from django.contrib.postgres.fields import ArrayField
|
||||
|
||||
class MyModel(models.Model):
|
||||
array = ArrayField(base_field=models.IntegerField())
|
||||
array_val: Tuple[int, ...] = (1,)
|
||||
MyModel(array=array_val)
|
||||
array_val2: List[int] = [1]
|
||||
MyModel(array=array_val2)
|
||||
array_val3: List[str] = ['hello']
|
||||
MyModel(array=array_val3) # E: Incompatible type for "array" of "MyModel" (got "List[str]", expected "Union[Sequence[int], Combinable]")
|
||||
[out]
|
||||
|
||||
[CASE if_no_explicit_primary_key_id_can_be_passed]
|
||||
from django.db import models
|
||||
|
||||
class MyModel(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
MyModel(id=1, name='maxim')
|
||||
[out]
|
||||
|
||||
[CASE arguments_can_be_passed_as_positionals]
|
||||
from django.db import models
|
||||
class MyModel(models.Model):
|
||||
pass
|
||||
MyModel(1)
|
||||
|
||||
class MyModel2(models.Model):
|
||||
name = models.IntegerField()
|
||||
MyModel2(1, 12)
|
||||
MyModel2(1, []) # E: Incompatible type for "name" of "MyModel2" (got "List[Any]", expected "Union[float, int, str, Combinable]")
|
||||
[out]
|
||||
|
||||
[CASE arguments_passed_as_dictionary_unpacking_are_not_supported]
|
||||
from django.db import models
|
||||
class MyModel(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
MyModel(**{'name': 'hello'})
|
||||
[out]
|
||||
|
||||
[CASE pointer_to_parent_model_is_not_supported]
|
||||
from django.db import models
|
||||
class Place(models.Model):
|
||||
pass
|
||||
class Restaurant(Place):
|
||||
pass
|
||||
place = Place()
|
||||
Restaurant(place_ptr=place)
|
||||
Restaurant(place_ptr_id=place.id)
|
||||
[out]
|
||||
|
||||
[CASE charfield_with_integer_choices]
|
||||
from django.db import models
|
||||
class MyModel(models.Model):
|
||||
day = models.CharField(max_length=3, choices=((1, 'Fri'), (2, 'Sat')))
|
||||
MyModel(day=1)
|
||||
[out]
|
||||
|
||||
[CASE if_there_is_no_data_for_base_classes_of_fields_and_ignore_unresolved_attributes_set_to_true_to_not_fail]
|
||||
from decimal import Decimal
|
||||
from django.db import models
|
||||
from fields2 import MoneyField
|
||||
|
||||
class InvoiceRow(models.Model):
|
||||
base_amount = MoneyField(max_digits=10, decimal_places=2)
|
||||
vat_rate = models.DecimalField(max_digits=10, decimal_places=2)
|
||||
InvoiceRow(1, Decimal(0), Decimal(0))
|
||||
InvoiceRow(base_amount=Decimal(0), vat_rate=Decimal(0))
|
||||
InvoiceRow.objects.create(base_amount=Decimal(0), vat_rate=Decimal(0))
|
||||
[out]
|
||||
main:3: error: Cannot find module named 'fields2'
|
||||
main:3: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports
|
||||
|
||||
[CASE optional_primary_key_is_allowed_for_init]
|
||||
from django.db import models
|
||||
class MyModel(models.Model):
|
||||
pass
|
||||
MyModel(id=None)
|
||||
MyModel(None)
|
||||
[out]
|
||||
|
||||
[CASE optional_related_model_is_allowed_for_init]
|
||||
from django.db import models
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)
|
||||
Book(publisher=None)
|
||||
Book(publisher_id=None)
|
||||
[out]
|
||||
@@ -1,42 +0,0 @@
|
||||
[CASE nullable_field_with_strict_optional_true]
|
||||
from django.db import models
|
||||
class MyModel(models.Model):
|
||||
text_nullable = models.CharField(max_length=100, null=True)
|
||||
text = models.CharField(max_length=100)
|
||||
reveal_type(MyModel().text) # N: Revealed type is 'builtins.str*'
|
||||
reveal_type(MyModel().text_nullable) # N: Revealed type is 'Union[builtins.str, None]'
|
||||
MyModel().text = None # E: Incompatible types in assignment (expression has type "None", variable has type "Union[str, int, Combinable]")
|
||||
MyModel().text_nullable = None
|
||||
[out]
|
||||
|
||||
[CASE nullable_array_field]
|
||||
from django.db import models
|
||||
from django.contrib.postgres.fields import ArrayField
|
||||
|
||||
class MyModel(models.Model):
|
||||
lst = ArrayField(base_field=models.CharField(max_length=100), null=True)
|
||||
reveal_type(MyModel().lst) # N: Revealed type is 'Union[builtins.list[builtins.str], None]'
|
||||
[out]
|
||||
|
||||
[CASE nullable_foreign_key]
|
||||
from django.db import models
|
||||
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(to=Publisher, on_delete=models.CASCADE, null=True)
|
||||
reveal_type(Book().publisher) # N: Revealed type is 'Union[main.Publisher, None]'
|
||||
Book().publisher = 11 # E: Incompatible types in assignment (expression has type "int", variable has type "Union[Publisher, Combinable, None]")
|
||||
[out]
|
||||
|
||||
[CASE nullable_self_foreign_key]
|
||||
from django.db import models
|
||||
class Inventory(models.Model):
|
||||
parent = models.ForeignKey('self', on_delete=models.SET_NULL, null=True)
|
||||
parent = Inventory()
|
||||
core = Inventory(parent_id=parent.id)
|
||||
reveal_type(core.parent_id) # N: Revealed type is 'Union[builtins.int, None]'
|
||||
reveal_type(core.parent) # N: Revealed type is 'Union[main.Inventory, None]'
|
||||
Inventory(parent=None)
|
||||
Inventory(parent_id=None)
|
||||
[out]
|
||||
@@ -1,389 +0,0 @@
|
||||
[CASE test_queryset_second_argument_filled_automatically]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model): pass
|
||||
|
||||
# QuerySet where second type argument is not specified shouldn't raise any errors
|
||||
class BlogQuerySet(models.QuerySet[Blog]):
|
||||
pass
|
||||
|
||||
blog_qs: models.QuerySet[Blog]
|
||||
reveal_type(blog_qs) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog, main.Blog]'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_methods]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
created_at = models.DateTimeField()
|
||||
|
||||
qs = Blog.objects.all()
|
||||
reveal_type(qs) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, main.Blog*]'
|
||||
reveal_type(qs.get(id=1)) # N: Revealed type is 'main.Blog*'
|
||||
reveal_type(iter(qs)) # N: Revealed type is 'typing.Iterator[main.Blog*]'
|
||||
reveal_type(qs.iterator()) # N: Revealed type is 'typing.Iterator[main.Blog*]'
|
||||
reveal_type(qs.first()) # N: Revealed type is 'Union[main.Blog*, None]'
|
||||
reveal_type(qs.earliest()) # N: Revealed type is 'main.Blog*'
|
||||
reveal_type(qs[0]) # N: Revealed type is 'main.Blog*'
|
||||
reveal_type(qs[:9]) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, main.Blog*]'
|
||||
reveal_type(qs.in_bulk()) # N: Revealed type is 'builtins.dict[Any, main.Blog*]'
|
||||
|
||||
# .dates / .datetimes
|
||||
reveal_type(Blog.objects.dates("created_at", "day")) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, datetime.date]'
|
||||
reveal_type(Blog.objects.datetimes("created_at", "day")) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, datetime.datetime]'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_combine_querysets_with_and]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
created_at = models.DateTimeField()
|
||||
|
||||
# When ANDing QuerySets, the left-side's _Row parameter is used
|
||||
reveal_type(Blog.objects.all() & Blog.objects.values()) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, main.Blog*]'
|
||||
reveal_type(Blog.objects.values() & Blog.objects.values()) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, builtins.dict*[builtins.str, Any]]'
|
||||
reveal_type(Blog.objects.values_list('id', 'name') & Blog.objects.values()) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, Tuple[builtins.int, builtins.str]]'
|
||||
reveal_type(Blog.objects.values_list('id', 'name', named=True) & Blog.objects.values()) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, Tuple[builtins.int, builtins.str, fallback=main.Row]]'
|
||||
reveal_type(Blog.objects.values_list('id', flat=True) & Blog.objects.values()) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, builtins.int*]'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_values_method]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model): pass
|
||||
|
||||
values_qs = Blog.objects.values()
|
||||
reveal_type(values_qs) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, builtins.dict[builtins.str, Any]]'
|
||||
reveal_type(values_qs.all()) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, builtins.dict*[builtins.str, Any]]'
|
||||
reveal_type(values_qs.get(id=1)) # N: Revealed type is 'builtins.dict*[builtins.str, Any]'
|
||||
reveal_type(iter(values_qs)) # N: Revealed type is 'typing.Iterator[builtins.dict*[builtins.str, Any]]'
|
||||
reveal_type(values_qs.iterator()) # N: Revealed type is 'typing.Iterator[builtins.dict*[builtins.str, Any]]'
|
||||
reveal_type(values_qs.first()) # N: Revealed type is 'Union[builtins.dict*[builtins.str, Any], None]'
|
||||
reveal_type(values_qs.earliest()) # N: Revealed type is 'builtins.dict*[builtins.str, Any]'
|
||||
reveal_type(values_qs[0]) # N: Revealed type is 'builtins.dict*[builtins.str, Any]'
|
||||
reveal_type(values_qs[:9]) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, builtins.dict*[builtins.str, Any]]'
|
||||
reveal_type(values_qs.in_bulk()) # N: Revealed type is 'builtins.dict[Any, main.Blog*]'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_values_list_named_false_flat_false]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
|
||||
values_list_qs = Blog.objects.values_list('id', 'name')
|
||||
reveal_type(values_list_qs) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, Tuple[builtins.int, builtins.str]]'
|
||||
reveal_type(values_list_qs.all()) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, Tuple[builtins.int, builtins.str]]'
|
||||
reveal_type(values_list_qs.get(id=1)) # N: Revealed type is 'Tuple[builtins.int, builtins.str]'
|
||||
reveal_type(iter(values_list_qs)) # N: Revealed type is 'typing.Iterator[Tuple[builtins.int, builtins.str]]'
|
||||
reveal_type(values_list_qs.iterator()) # N: Revealed type is 'typing.Iterator[Tuple[builtins.int, builtins.str]]'
|
||||
reveal_type(values_list_qs.first()) # N: Revealed type is 'Union[Tuple[builtins.int, builtins.str], None]'
|
||||
reveal_type(values_list_qs.earliest()) # N: Revealed type is 'Tuple[builtins.int, builtins.str]'
|
||||
reveal_type(values_list_qs[0]) # N: Revealed type is 'Tuple[builtins.int, builtins.str]'
|
||||
reveal_type(values_list_qs[:9]) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, Tuple[builtins.int, builtins.str]]'
|
||||
reveal_type(values_list_qs.in_bulk()) # N: Revealed type is 'builtins.dict[Any, main.Blog*]'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_values_list_named_false_flat_true]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
|
||||
flat_values_list_qs = Blog.objects.values_list('id', flat=True)
|
||||
reveal_type(flat_values_list_qs) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, builtins.int]'
|
||||
reveal_type(flat_values_list_qs.all()) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, builtins.int*]'
|
||||
reveal_type(flat_values_list_qs.get(id=1)) # N: Revealed type is 'builtins.int*'
|
||||
reveal_type(iter(flat_values_list_qs)) # N: Revealed type is 'typing.Iterator[builtins.int*]'
|
||||
reveal_type(flat_values_list_qs.iterator()) # N: Revealed type is 'typing.Iterator[builtins.int*]'
|
||||
reveal_type(flat_values_list_qs.first()) # N: Revealed type is 'Union[builtins.int*, None]'
|
||||
reveal_type(flat_values_list_qs.earliest()) # N: Revealed type is 'builtins.int*'
|
||||
reveal_type(flat_values_list_qs[0]) # N: Revealed type is 'builtins.int*'
|
||||
reveal_type(flat_values_list_qs[:9]) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, builtins.int*]'
|
||||
reveal_type(flat_values_list_qs.in_bulk()) # N: Revealed type is 'builtins.dict[Any, main.Blog*]'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_values_list_named_true_flat_false]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
|
||||
named_values_list_qs = Blog.objects.values_list('id', named=True)
|
||||
reveal_type(named_values_list_qs) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, Tuple[builtins.int, fallback=main.Row]]'
|
||||
reveal_type(named_values_list_qs.all()) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, Tuple[builtins.int, fallback=main.Row]]'
|
||||
reveal_type(named_values_list_qs.get(id=1)) # N: Revealed type is 'Tuple[builtins.int, fallback=main.Row]'
|
||||
reveal_type(iter(named_values_list_qs)) # N: Revealed type is 'typing.Iterator[Tuple[builtins.int, fallback=main.Row]]'
|
||||
reveal_type(named_values_list_qs.iterator()) # N: Revealed type is 'typing.Iterator[Tuple[builtins.int, fallback=main.Row]]'
|
||||
reveal_type(named_values_list_qs.first()) # N: Revealed type is 'Union[Tuple[builtins.int, fallback=main.Row], None]'
|
||||
reveal_type(named_values_list_qs.earliest()) # N: Revealed type is 'Tuple[builtins.int, fallback=main.Row]'
|
||||
reveal_type(named_values_list_qs[0]) # N: Revealed type is 'Tuple[builtins.int, fallback=main.Row]'
|
||||
reveal_type(named_values_list_qs[:9]) # N: Revealed type is 'django.db.models.query.QuerySet[main.Blog*, Tuple[builtins.int, fallback=main.Row]]'
|
||||
reveal_type(named_values_list_qs.in_bulk()) # N: Revealed type is 'builtins.dict[Any, main.Blog*]'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_values_list_flat_true_custom_primary_key_get_element]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
primary_uuid = models.UUIDField(primary_key=True)
|
||||
|
||||
# Blog has a primary key field specified, so no automatic 'id' field is expected to exist
|
||||
reveal_type(Blog.objects.values_list('id', flat=True).get()) # N: Revealed type is 'Any'
|
||||
|
||||
# Access Blog's pk (which is UUID field)
|
||||
reveal_type(Blog.objects.values_list('pk', flat=True).get()) # N: Revealed type is 'uuid.UUID*'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_values_list_flat_true_custom_primary_key_related_field]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
primary_uuid = models.UUIDField(primary_key=True)
|
||||
|
||||
class Entry(models.Model):
|
||||
blog = models.ForeignKey(Blog, on_delete=models.CASCADE, related_name="entries")
|
||||
|
||||
# Accessing PK of model pointed to by foreign key
|
||||
reveal_type(Entry.objects.values_list('blog', flat=True).get()) # N: Revealed type is 'uuid.UUID*'
|
||||
# Alternative way of accessing PK of model pointed to by foreign key
|
||||
reveal_type(Entry.objects.values_list('blog_id', flat=True).get()) # N: Revealed type is 'uuid.UUID*'
|
||||
# Yet another (more explicit) way of accessing PK of related model
|
||||
reveal_type(Entry.objects.values_list('blog__pk', flat=True).get()) # N: Revealed type is 'uuid.UUID*'
|
||||
|
||||
# Blog has a primary key field specified, so no automatic 'id' field is expected to exist
|
||||
reveal_type(Entry.objects.values_list('blog__id', flat=True).get()) # N: Revealed type is 'Any'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_values_list_error_conditions]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
|
||||
# Emulate at type-check time the errors that Django reports
|
||||
Blog.objects.values_list('id', flat=True, named=True) # E: 'flat' and 'named' can't be used together.
|
||||
Blog.objects.values_list('id', 'name', flat=True) # E: 'flat' is not valid when values_list is called with more than one field.
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_values_list_returns_tuple_of_fields]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
created_at = models.DateTimeField()
|
||||
|
||||
# values_list where parameter types are all known
|
||||
reveal_type(Blog.objects.values_list('id', 'created_at').get()) # N: Revealed type is 'Tuple[builtins.int, datetime.datetime]'
|
||||
tup = Blog.objects.values_list('id', 'created_at').get()
|
||||
reveal_type(tup[0]) # N: Revealed type is 'builtins.int'
|
||||
reveal_type(tup[1]) # N: Revealed type is 'datetime.datetime'
|
||||
tup[2] # E: Tuple index out of range
|
||||
|
||||
# values_list returning namedtuple
|
||||
reveal_type(Blog.objects.values_list('id', 'created_at', named=True).get()) # N: Revealed type is 'Tuple[builtins.int, datetime.datetime, fallback=main.Row]'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_values_list_invalid_lookups_produce_any]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model): pass
|
||||
class Entry(models.Model):
|
||||
blog = models.ForeignKey(Blog, on_delete=models.CASCADE, related_name="entries")
|
||||
|
||||
# Invalid lookups produce Any type rather than giving errors.
|
||||
reveal_type(Blog.objects.values_list('id', 'invalid_lookup').get()) # N: Revealed type is 'Tuple[builtins.int, Any]'
|
||||
reveal_type(Blog.objects.values_list('entries_id', flat=True).get()) # N: Revealed type is 'Any'
|
||||
reveal_type(Blog.objects.values_list('entries__foo', flat=True).get()) # N: Revealed type is 'Any'
|
||||
reveal_type(Blog.objects.values_list('+', flat=True).get()) # N: Revealed type is 'Any'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_values_list_basic_inheritance]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
created_at = models.DateTimeField()
|
||||
|
||||
class BlogChild(Blog):
|
||||
child_field = models.CharField(max_length=100)
|
||||
|
||||
# Basic inheritance
|
||||
reveal_type(BlogChild.objects.values_list('id', 'created_at', 'child_field').get()) # N: Revealed type is 'Tuple[builtins.int, datetime.datetime, builtins.str]'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_query_values_list_flat_true_plain_foreign_key]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model): pass
|
||||
class Entry(models.Model):
|
||||
blog = models.ForeignKey(Blog, on_delete=models.CASCADE)
|
||||
|
||||
# Foreign key
|
||||
reveal_type(Entry.objects.values_list('blog', flat=True).get()) # N: Revealed type is 'builtins.int*'
|
||||
reveal_type(Entry.objects.values_list('blog__id', flat=True).get()) # N: Revealed type is 'builtins.int*'
|
||||
reveal_type(Entry.objects.values_list('blog__pk', flat=True).get()) # N: Revealed type is 'builtins.int*'
|
||||
reveal_type(Entry.objects.values_list('blog_id', flat=True).get()) # N: Revealed type is 'builtins.int*'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_query_values_list_flat_true_custom_primary_key]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
id = models.UUIDField(primary_key=True)
|
||||
|
||||
class Entry(models.Model):
|
||||
blog = models.ForeignKey(Blog, on_delete=models.CASCADE)
|
||||
|
||||
# Foreign key
|
||||
reveal_type(Entry.objects.values_list('blog', flat=True).get()) # N: Revealed type is 'uuid.UUID*'
|
||||
reveal_type(Entry.objects.values_list('blog__id', flat=True).get()) # N: Revealed type is 'uuid.UUID*'
|
||||
reveal_type(Entry.objects.values_list('blog__pk', flat=True).get()) # N: Revealed type is 'uuid.UUID*'
|
||||
reveal_type(Entry.objects.values_list('blog_id', flat=True).get()) # N: Revealed type is 'uuid.UUID*'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_query_values_list_flat_true_nullable_foreign_key]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model): pass
|
||||
class Entry(models.Model):
|
||||
nullable_blog = models.ForeignKey(Blog, on_delete=models.CASCADE, related_name="+", null=True)
|
||||
|
||||
# Foreign key (nullable=True)
|
||||
reveal_type(Entry.objects.values_list('nullable_blog', flat=True).get()) # N: Revealed type is 'Union[builtins.int, None]'
|
||||
reveal_type(Entry.objects.values_list('nullable_blog_id', flat=True).get()) # N: Revealed type is 'Union[builtins.int, None]'
|
||||
reveal_type(Entry.objects.values_list('nullable_blog__id', flat=True).get()) # N: Revealed type is 'Union[builtins.int, None]'
|
||||
reveal_type(Entry.objects.values_list('nullable_blog__pk', flat=True).get()) # N: Revealed type is 'Union[builtins.int, None]'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_query_values_list_flat_true_foreign_key_reverse_relation]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model): pass
|
||||
class Entry(models.Model):
|
||||
blog = models.ForeignKey(Blog, on_delete=models.CASCADE, related_name='entries')
|
||||
blog_with_related_query_name = models.ForeignKey(Blog, on_delete=models.CASCADE, related_query_name="my_related_query_name")
|
||||
title = models.CharField(max_length=100)
|
||||
|
||||
# Reverse relation of ForeignKey
|
||||
reveal_type(Blog.objects.values_list('entries', flat=True).get()) # N: Revealed type is 'builtins.int*'
|
||||
reveal_type(Blog.objects.values_list('entries__id', flat=True).get()) # N: Revealed type is 'builtins.int*'
|
||||
reveal_type(Blog.objects.values_list('entries__title', flat=True).get()) # N: Revealed type is 'builtins.str*'
|
||||
|
||||
# Reverse relation of ForeignKey (with related_query_name set)
|
||||
reveal_type(Blog.objects.values_list('my_related_query_name__id', flat=True).get()) # N: Revealed type is 'builtins.int*'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_query_values_list_flat_true_foreign_key_custom_primary_key_reverse_relation]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model): pass
|
||||
|
||||
class Entry(models.Model):
|
||||
id = models.UUIDField(primary_key=True)
|
||||
blog = models.ForeignKey(Blog, on_delete=models.CASCADE, related_name='entries')
|
||||
blog_with_related_query_name = models.ForeignKey(Blog, on_delete=models.CASCADE, related_query_name="my_related_query_name")
|
||||
title = models.CharField(max_length=100)
|
||||
|
||||
# Reverse relation of ForeignKey
|
||||
reveal_type(Blog.objects.values_list('entries', flat=True).get()) # N: Revealed type is 'uuid.UUID*'
|
||||
reveal_type(Blog.objects.values_list('entries__id', flat=True).get()) # N: Revealed type is 'uuid.UUID*'
|
||||
|
||||
# Reverse relation of ForeignKey (with related_query_name set)
|
||||
reveal_type(Blog.objects.values_list('my_related_query_name__id', flat=True).get()) # N: Revealed type is 'uuid.UUID*'
|
||||
[/CASE]
|
||||
|
||||
|
||||
[CASE test_queryset_values_list_and_values_behavior_with_no_fields_specified_and_accessing_unknown_attributes]
|
||||
from django.db import models
|
||||
|
||||
class Blog(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
created_at = models.DateTimeField()
|
||||
|
||||
row_named = Blog.objects.values_list('id', 'created_at', named=True).get()
|
||||
reveal_type(row_named.id) # N: Revealed type is 'builtins.int'
|
||||
reveal_type(row_named.created_at) # N: Revealed type is 'datetime.datetime'
|
||||
row_named.non_existent_field # E: "Row" has no attribute "non_existent_field"
|
||||
|
||||
|
||||
# When no fields are specified, fallback to Any
|
||||
row_named_no_fields = Blog.objects.values_list(named=True).get()
|
||||
reveal_type(row_named_no_fields) # N: Revealed type is 'Tuple[, fallback=django._NamedTupleAnyAttr]'
|
||||
|
||||
# Don't complain about access to any attribute for now
|
||||
reveal_type(row_named_no_fields.non_existent_field) # N: Revealed type is 'Any'
|
||||
row_named_no_fields.non_existent_field = 1
|
||||
|
||||
# It should still behave like a NamedTuple
|
||||
reveal_type(row_named_no_fields._asdict()) # N: Revealed type is 'builtins.dict[builtins.str, Any]'
|
||||
|
||||
|
||||
dict_row = Blog.objects.values('id', 'created_at').get()
|
||||
reveal_type(dict_row["id"]) # N: Revealed type is 'builtins.int'
|
||||
reveal_type(dict_row["created_at"]) # N: Revealed type is 'datetime.datetime'
|
||||
dict_row["non_existent_field"] # E: 'non_existent_field' is not a valid TypedDict key; expected one of ('id', 'created_at')
|
||||
dict_row.pop('created_at')
|
||||
dict_row.pop('non_existent_field') # E: 'non_existent_field' is not a valid TypedDict key; expected one of ('id', 'created_at')
|
||||
|
||||
row_dict_no_fields = Blog.objects.values().get()
|
||||
reveal_type(row_dict_no_fields) # N: Revealed type is 'builtins.dict*[builtins.str, Any]'
|
||||
reveal_type(row_dict_no_fields["non_existent_field"]) # N: Revealed type is 'Any'
|
||||
|
||||
[CASE values_with_annotate_inside_the_expressions]
|
||||
from django.db import models
|
||||
from django.db.models.functions import Lower, Upper
|
||||
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
|
||||
class Book(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
publisher = models.ForeignKey(to=Publisher, on_delete=models.CASCADE, related_name='books')
|
||||
|
||||
reveal_type(Publisher().books.values('name', lower_name=Lower('name'), upper_name=Upper('name'))) # N: Revealed type is 'django.db.models.query.QuerySet[main.Book*, TypedDict({'name'?: builtins.str, 'lower_name'?: Any, 'upper_name'?: Any})]'
|
||||
|
||||
|
||||
[CASE values_and_values_list_some_dynamic_fields]
|
||||
from django.db import models
|
||||
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
|
||||
class Book(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
publisher = models.ForeignKey(to=Publisher, on_delete=models.CASCADE, related_name='books')
|
||||
|
||||
some_dynamic_field = 'publisher'
|
||||
|
||||
# Correct Tuple field types should be filled in when string literal is used, while Any is used for dynamic fields
|
||||
reveal_type(Publisher().books.values_list('name', some_dynamic_field)) # N: Revealed type is 'django.db.models.query.QuerySet[main.Book*, Tuple[builtins.str, Any]]'
|
||||
|
||||
# Flat with dynamic fields (there is only 1), means of course Any
|
||||
reveal_type(Publisher().books.values_list(some_dynamic_field, flat=True)) # N: Revealed type is 'django.db.models.query.QuerySet[main.Book*, Any]'
|
||||
|
||||
# A NamedTuple with a fallback to Any could be implemented, but for now that's unsupported, so all
|
||||
# fields on the NamedTuple are Any for now
|
||||
reveal_type(Publisher().books.values_list('name', some_dynamic_field, named=True).name) # N: Revealed type is 'Any'
|
||||
|
||||
# A TypedDict with a fallback to Any could be implemented, but for now that's unsupported,
|
||||
# so an ordinary Dict is used for now.
|
||||
reveal_type(Publisher().books.values(some_dynamic_field, 'name')) # N: Revealed type is 'django.db.models.query.QuerySet[main.Book*, builtins.dict[builtins.str, Any]]'
|
||||
@@ -1,319 +0,0 @@
|
||||
[CASE test_foreign_key_field_with_related_name]
|
||||
from django.db import models
|
||||
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(to=Publisher, on_delete=models.CASCADE,
|
||||
related_name='books')
|
||||
|
||||
book = Book()
|
||||
reveal_type(book.publisher) # N: Revealed type is 'main.Publisher*'
|
||||
|
||||
publisher = Publisher()
|
||||
reveal_type(publisher.books) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.Book]'
|
||||
|
||||
[CASE test_foreign_key_field_creates_attribute_with_underscore_id]
|
||||
from django.db import models
|
||||
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(to=Publisher, on_delete=models.CASCADE)
|
||||
owner = models.ForeignKey(db_column='model_id', to='db.Unknown', on_delete=models.CASCADE)
|
||||
|
||||
book = Book()
|
||||
reveal_type(book.publisher_id) # N: Revealed type is 'builtins.int'
|
||||
reveal_type(book.owner_id) # N: Revealed type is 'Any'
|
||||
|
||||
[CASE test_foreign_key_field_different_order_of_params]
|
||||
from django.db import models
|
||||
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(on_delete=models.CASCADE, to=Publisher,
|
||||
related_name='books')
|
||||
publisher2 = models.ForeignKey(to=Publisher, related_name='books2', on_delete=models.CASCADE)
|
||||
|
||||
book = Book()
|
||||
reveal_type(book.publisher) # N: Revealed type is 'main.Publisher*'
|
||||
reveal_type(book.publisher2) # N: Revealed type is 'main.Publisher*'
|
||||
|
||||
publisher = Publisher()
|
||||
reveal_type(publisher.books) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.Book]'
|
||||
reveal_type(publisher.books2) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.Book]'
|
||||
|
||||
[CASE test_to_parameter_as_string_with_application_name__model_imported]
|
||||
from django.db import models
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from myapp.models import Publisher
|
||||
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(to='myapp.Publisher', on_delete=models.CASCADE)
|
||||
|
||||
book = Book()
|
||||
reveal_type(book.publisher) # N: Revealed type is 'myapp.models.Publisher*'
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models.py]
|
||||
from django.db import models
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
|
||||
[CASE test_to_parameter_as_string_with_application_name_fallbacks_to_any_if_model_not_present_in_dependency_graph]
|
||||
from django.db import models
|
||||
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(to='myapp.Publisher', on_delete=models.CASCADE)
|
||||
|
||||
book = Book()
|
||||
reveal_type(book.publisher) # N: Revealed type is 'Any'
|
||||
reveal_type(book.publisher_id) # N: Revealed type is 'Any'
|
||||
Book(publisher_id=1)
|
||||
Book.objects.create(publisher_id=1)
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models.py]
|
||||
from django.db import models
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
|
||||
[CASE test_circular_dependency_in_imports_with_foreign_key]
|
||||
from django.db import models
|
||||
|
||||
class App(models.Model):
|
||||
def method(self) -> None:
|
||||
reveal_type(self.views) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.View]'
|
||||
reveal_type(self.members) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.Member]'
|
||||
reveal_type(self.sheets) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.Sheet]'
|
||||
reveal_type(self.profile) # N: Revealed type is 'main.Profile'
|
||||
class View(models.Model):
|
||||
app = models.ForeignKey(to=App, related_name='views', on_delete=models.CASCADE)
|
||||
class Member(models.Model):
|
||||
app = models.ForeignKey(related_name='members', on_delete=models.CASCADE, to=App)
|
||||
class Sheet(models.Model):
|
||||
app = models.ForeignKey(App, related_name='sheets', on_delete=models.CASCADE)
|
||||
class Profile(models.Model):
|
||||
app = models.OneToOneField(App, related_name='profile', on_delete=models.CASCADE)
|
||||
|
||||
[CASE test_circular_dependency_in_imports_with_string_based]
|
||||
from django.db import models
|
||||
from myapp.models import App
|
||||
class View(models.Model):
|
||||
app = models.ForeignKey(to=App, related_name='views', on_delete=models.CASCADE)
|
||||
|
||||
reveal_type(View().app.views) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.View]'
|
||||
reveal_type(View().app.unknown)
|
||||
[out]
|
||||
main:7: note: Revealed type is 'Any'
|
||||
main:7: error: "App" has no attribute "unknown"
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models.py]
|
||||
from django.db import models
|
||||
class App(models.Model):
|
||||
def method(self) -> None:
|
||||
reveal_type(self.views) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.View]'
|
||||
|
||||
[CASE models_related_managers_work_with_direct_model_inheritance_and_with_inheritance_from_other_model]
|
||||
from django.db.models import Model
|
||||
from django.db import models
|
||||
|
||||
class App(Model):
|
||||
pass
|
||||
|
||||
class View(Model):
|
||||
app = models.ForeignKey(to=App, on_delete=models.CASCADE, related_name='views')
|
||||
|
||||
class View2(View):
|
||||
app = models.ForeignKey(to=App, on_delete=models.CASCADE, related_name='views2')
|
||||
|
||||
reveal_type(App().views) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.View]'
|
||||
reveal_type(App().views2) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.View2]'
|
||||
[out]
|
||||
|
||||
[CASE models_imported_inside_init_file_foreign_key]
|
||||
[disable_cache]
|
||||
from django.db import models
|
||||
from myapp.models import App
|
||||
class View(models.Model):
|
||||
app = models.ForeignKey(to='myapp.App', related_name='views', on_delete=models.CASCADE)
|
||||
reveal_type(View().app.views) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.View]'
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models/__init__.py]
|
||||
from .app import App
|
||||
[file myapp/models/app.py]
|
||||
from django.db import models
|
||||
class App(models.Model):
|
||||
pass
|
||||
[/CASE]
|
||||
|
||||
[CASE models_imported_inside_init_file_one_to_one_field]
|
||||
[disable_cache]
|
||||
from django.db import models
|
||||
from myapp.models import User
|
||||
class Profile(models.Model):
|
||||
user = models.OneToOneField(to='myapp.User', related_name='profile', on_delete=models.CASCADE)
|
||||
reveal_type(Profile().user.profile) # N: Revealed type is 'main.Profile'
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models/__init__.py]
|
||||
from .user import User
|
||||
[file myapp/models/user.py]
|
||||
from django.db import models
|
||||
class User(models.Model):
|
||||
pass
|
||||
|
||||
[CASE models_triple_circular_reference]
|
||||
from myapp.models import App
|
||||
reveal_type(App().owner) # N: Revealed type is 'myapp.models.user.User'
|
||||
reveal_type(App().owner.profile) # N: Revealed type is 'myapp.models.profile.Profile'
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models/__init__.py]
|
||||
from .user import User
|
||||
from .profile import Profile
|
||||
from .app import App
|
||||
|
||||
[file myapp/models/user.py]
|
||||
from django.db import models
|
||||
class User(models.Model):
|
||||
pass
|
||||
|
||||
[file myapp/models/profile.py]
|
||||
from django.db import models
|
||||
from myapp.models import User
|
||||
class Profile(models.Model):
|
||||
user = models.OneToOneField(to='myapp.User', related_name='profile', on_delete=models.CASCADE)
|
||||
|
||||
[file myapp/models/app.py]
|
||||
from django.db import models
|
||||
class App(models.Model):
|
||||
owner = models.ForeignKey(to='myapp.User', on_delete=models.CASCADE, related_name='apps')
|
||||
[disable_cache]
|
||||
[/CASE]
|
||||
|
||||
[CASE many_to_many_field_converts_to_queryset_of_model_type]
|
||||
from django.db import models
|
||||
class App(models.Model):
|
||||
pass
|
||||
class Member(models.Model):
|
||||
apps = models.ManyToManyField(to=App, related_name='members')
|
||||
reveal_type(Member().apps) # N: Revealed type is 'django.db.models.manager.RelatedManager*[main.App]'
|
||||
reveal_type(App().members) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.Member]'
|
||||
[out]
|
||||
|
||||
[CASE many_to_many_works_with_string_if_imported]
|
||||
from django.db import models
|
||||
from myapp.models import App
|
||||
class Member(models.Model):
|
||||
apps = models.ManyToManyField(to='myapp.App', related_name='members')
|
||||
reveal_type(Member().apps) # N: Revealed type is 'django.db.models.manager.RelatedManager*[myapp.models.App]'
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models.py]
|
||||
from django.db import models
|
||||
class App(models.Model):
|
||||
pass
|
||||
[out]
|
||||
|
||||
[CASE foreign_key_with_self]
|
||||
from django.db import models
|
||||
class User(models.Model):
|
||||
parent = models.ForeignKey('self', on_delete=models.CASCADE)
|
||||
reveal_type(User().parent) # N: Revealed type is 'main.User*'
|
||||
[out]
|
||||
|
||||
[CASE many_to_many_with_self]
|
||||
from django.db import models
|
||||
class User(models.Model):
|
||||
friends = models.ManyToManyField('self')
|
||||
reveal_type(User().friends) # N: Revealed type is 'django.db.models.manager.RelatedManager*[main.User]'
|
||||
[out]
|
||||
|
||||
[CASE recursively_checking_for_base_model_in_to_parameter]
|
||||
from django.db import models
|
||||
|
||||
class BaseModel(models.Model):
|
||||
pass
|
||||
class ParkingSpot(BaseModel):
|
||||
pass
|
||||
class Booking(BaseModel):
|
||||
parking_spot = models.ForeignKey(to=ParkingSpot, null=True, on_delete=models.SET_NULL)
|
||||
[out]
|
||||
|
||||
[CASE if_no_related_name_is_passed_create_default_related_managers]
|
||||
from django.db import models
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(to=Publisher, on_delete=models.CASCADE)
|
||||
reveal_type(Publisher().book_set) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.Book]'
|
||||
|
||||
[CASE underscore_id_attribute_has_set_type_of_primary_key_if_explicit]
|
||||
from django.db import models
|
||||
import datetime
|
||||
class Publisher(models.Model):
|
||||
mypk = models.CharField(max_length=100, primary_key=True)
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(to=Publisher, on_delete=models.CASCADE)
|
||||
|
||||
reveal_type(Book().publisher_id) # N: Revealed type is 'builtins.str'
|
||||
Book(publisher_id=1)
|
||||
Book(publisher_id='hello')
|
||||
Book(publisher_id=datetime.datetime.now()) # E: Incompatible type for "publisher_id" of "Book" (got "datetime", expected "Union[str, int, Combinable, None]")
|
||||
Book.objects.create(publisher_id=1)
|
||||
Book.objects.create(publisher_id='hello')
|
||||
|
||||
class Publisher2(models.Model):
|
||||
mypk = models.IntegerField(primary_key=True)
|
||||
class Book2(models.Model):
|
||||
publisher = models.ForeignKey(to=Publisher2, on_delete=models.CASCADE)
|
||||
|
||||
reveal_type(Book2().publisher_id) # N: Revealed type is 'builtins.int'
|
||||
Book2(publisher_id=1)
|
||||
Book2(publisher_id=[]) # E: Incompatible type for "publisher_id" of "Book2" (got "List[Any]", expected "Union[float, int, str, Combinable, None]")
|
||||
Book2.objects.create(publisher_id=1)
|
||||
Book2.objects.create(publisher_id=[]) # E: Incompatible type for "publisher_id" of "Book2" (got "List[Any]", expected "Union[float, int, str, Combinable]")
|
||||
[out]
|
||||
|
||||
[CASE if_model_is_defined_as_name_of_the_class_look_for_it_in_the_same_file]
|
||||
from django.db import models
|
||||
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(to='Publisher', on_delete=models.CASCADE)
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
reveal_type(Book().publisher) # N: Revealed type is 'main.Publisher*'
|
||||
[out]
|
||||
|
||||
[CASE test_foreign_key_field_without_backwards_relation]
|
||||
from django.db import models
|
||||
|
||||
class Publisher(models.Model):
|
||||
pass
|
||||
|
||||
class Book(models.Model):
|
||||
publisher = models.ForeignKey(to=Publisher, on_delete=models.CASCADE,
|
||||
related_name='+')
|
||||
publisher2 = models.ForeignKey(to=Publisher, on_delete=models.CASCADE,
|
||||
related_name='books2')
|
||||
|
||||
book = Book()
|
||||
reveal_type(book.publisher) # N: Revealed type is 'main.Publisher*'
|
||||
|
||||
publisher = Publisher()
|
||||
reveal_type(publisher.books)
|
||||
reveal_type(publisher.books2) # N: Revealed type is 'django.db.models.manager.RelatedManager[main.Book]'
|
||||
[out]
|
||||
main:16: note: Revealed type is 'Any'
|
||||
main:16: error: "Publisher" has no attribute "books"; maybe "books2"?
|
||||
[/CASE]
|
||||
|
||||
@@ -1,99 +0,0 @@
|
||||
[CASE test_settings_are_parsed_into_django_conf_settings]
|
||||
[env DJANGO_SETTINGS_MODULE=mysettings]
|
||||
[disable_cache]
|
||||
from django.conf import settings
|
||||
|
||||
# standard settings
|
||||
reveal_type(settings.AUTH_USER_MODEL) # N: Revealed type is 'builtins.str'
|
||||
|
||||
reveal_type(settings.ROOT_DIR) # N: Revealed type is 'builtins.str'
|
||||
reveal_type(settings.APPS_DIR) # N: Revealed type is 'pathlib.Path'
|
||||
reveal_type(settings.OBJ) # N: Revealed type is 'django.utils.functional.LazyObject'
|
||||
reveal_type(settings.NUMBERS) # N: Revealed type is 'builtins.list[builtins.str*]'
|
||||
reveal_type(settings.DICT) # N: Revealed type is 'builtins.dict[Any, Any]'
|
||||
[file base.py]
|
||||
from pathlib import Path
|
||||
ROOT_DIR = '/etc'
|
||||
APPS_DIR = Path(ROOT_DIR)
|
||||
[file mysettings.py]
|
||||
from base import *
|
||||
SECRET_KEY = 112233
|
||||
NUMBERS = ['one', 'two']
|
||||
DICT = {} # type: ignore
|
||||
from django.utils.functional import LazyObject
|
||||
OBJ = LazyObject()
|
||||
[/CASE]
|
||||
|
||||
[CASE test_settings_could_be_defined_in_different_module_and_imported_with_star]
|
||||
[env DJANGO_SETTINGS_MODULE=mysettings]
|
||||
[disable_cache]
|
||||
from django.conf import settings
|
||||
|
||||
reveal_type(settings.ROOT_DIR) # N: Revealed type is 'pathlib.Path'
|
||||
reveal_type(settings.SETUP) # N: Revealed type is 'Union[builtins.int, None]'
|
||||
reveal_type(settings.DATABASES) # N: Revealed type is 'builtins.dict[builtins.str*, builtins.str*]'
|
||||
|
||||
reveal_type(settings.LOCAL_SETTING) # N: Revealed type is 'builtins.int'
|
||||
reveal_type(settings.BASE_SETTING) # N: Revealed type is 'builtins.int'
|
||||
|
||||
[file mysettings.py]
|
||||
from local import *
|
||||
from typing import Optional
|
||||
SETUP: Optional[int] = 3
|
||||
|
||||
[file local.py]
|
||||
from base import *
|
||||
SETUP: int = 3
|
||||
DATABASES = {'default': 'mydb'}
|
||||
|
||||
LOCAL_SETTING = 1
|
||||
|
||||
[file base.py]
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
SETUP: Any = None
|
||||
ROOT_DIR = Path(__file__)
|
||||
|
||||
BASE_SETTING = 1
|
||||
|
||||
[/CASE]
|
||||
|
||||
[CASE global_settings_are_always_loaded]
|
||||
from django.conf import settings
|
||||
|
||||
reveal_type(settings.AUTH_USER_MODEL) # N: Revealed type is 'builtins.str'
|
||||
reveal_type(settings.AUTHENTICATION_BACKENDS) # N: Revealed type is 'typing.Sequence[builtins.str]'
|
||||
[/CASE]
|
||||
|
||||
[CASE test_circular_dependency_in_settings_works_if_settings_have_annotations]
|
||||
[env DJANGO_SETTINGS_MODULE=mysettings]
|
||||
[disable_cache]
|
||||
from django.conf import settings
|
||||
class Class:
|
||||
pass
|
||||
reveal_type(settings.MYSETTING) # N: Revealed type is 'builtins.int'
|
||||
reveal_type(settings.REGISTRY) # N: Revealed type is 'Union[main.Class, None]'
|
||||
reveal_type(settings.LIST) # N: Revealed type is 'builtins.list[builtins.str]'
|
||||
|
||||
[file mysettings.py]
|
||||
from typing import TYPE_CHECKING, Optional, List
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from main import Class
|
||||
|
||||
MYSETTING = 1122
|
||||
REGISTRY: Optional['Class'] = None
|
||||
LIST: List[str] = ['1', '2']
|
||||
[/CASE]
|
||||
|
||||
[CASE fail_if_there_is_no_setting]
|
||||
from django.conf import settings
|
||||
reveal_type(settings.NOT_EXISTING)
|
||||
|
||||
[env DJANGO_SETTINGS_MODULE=mysettings2]
|
||||
[disable_cache]
|
||||
[file mysettings2.py]
|
||||
[out]
|
||||
main:2: note: Revealed type is 'Any'
|
||||
main:2: error: 'Settings' object has no attribute 'NOT_EXISTING'
|
||||
[/CASE]
|
||||
@@ -1,62 +0,0 @@
|
||||
[CASE get_object_or_404_returns_proper_types]
|
||||
from django.shortcuts import get_object_or_404, get_list_or_404
|
||||
from django.db import models
|
||||
|
||||
class MyModel(models.Model):
|
||||
pass
|
||||
reveal_type(get_object_or_404(MyModel)) # N: Revealed type is 'main.MyModel*'
|
||||
reveal_type(get_object_or_404(MyModel.objects)) # N: Revealed type is 'main.MyModel*'
|
||||
reveal_type(get_object_or_404(MyModel.objects.get_queryset())) # N: Revealed type is 'main.MyModel*'
|
||||
|
||||
reveal_type(get_list_or_404(MyModel)) # N: Revealed type is 'builtins.list[main.MyModel*]'
|
||||
reveal_type(get_list_or_404(MyModel.objects)) # N: Revealed type is 'builtins.list[main.MyModel*]'
|
||||
reveal_type(get_list_or_404(MyModel.objects.get_queryset())) # N: Revealed type is 'builtins.list[main.MyModel*]'
|
||||
[/CASE]
|
||||
|
||||
[CASE get_user_model_returns_proper_class]
|
||||
[env DJANGO_SETTINGS_MODULE=mysettings]
|
||||
[disable_cache]
|
||||
from typing import TYPE_CHECKING
|
||||
if TYPE_CHECKING:
|
||||
from myapp.models import MyUser
|
||||
from django.contrib.auth import get_user_model
|
||||
|
||||
UserModel = get_user_model()
|
||||
reveal_type(UserModel.objects) # N: Revealed type is 'django.db.models.manager.Manager[myapp.models.MyUser]'
|
||||
|
||||
[file mysettings.py]
|
||||
from basic import *
|
||||
INSTALLED_APPS = ('myapp',)
|
||||
|
||||
[file basic.py]
|
||||
AUTH_USER_MODEL = 'myapp.MyUser'
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models.py]
|
||||
from django.db import models
|
||||
class MyUser(models.Model):
|
||||
pass
|
||||
[/CASE]
|
||||
|
||||
[CASE return_type_model_and_show_error_if_model_not_yet_imported]
|
||||
[env DJANGO_SETTINGS_MODULE=mysettings]
|
||||
[disable_cache]
|
||||
from django.contrib.auth import get_user_model
|
||||
|
||||
UserModel = get_user_model()
|
||||
reveal_type(UserModel.objects)
|
||||
|
||||
[file mysettings.py]
|
||||
INSTALLED_APPS = ('myapp',)
|
||||
AUTH_USER_MODEL = 'myapp.MyUser'
|
||||
|
||||
[file myapp/__init__.py]
|
||||
[file myapp/models.py]
|
||||
from django.db import models
|
||||
class MyUser(models.Model):
|
||||
pass
|
||||
[out]
|
||||
main:3: error: "myapp.MyUser" model class is not imported so far. Try to import it (under if TYPE_CHECKING) at the beginning of the current file
|
||||
main:4: note: Revealed type is 'Any'
|
||||
main:4: error: "Type[Model]" has no attribute "objects"
|
||||
[/CASE]
|
||||
@@ -1,50 +0,0 @@
|
||||
[CASE test_transaction_atomic]
|
||||
|
||||
from django.db import transaction
|
||||
|
||||
with transaction.atomic():
|
||||
pass
|
||||
|
||||
with transaction.atomic(using="mydb"):
|
||||
pass
|
||||
|
||||
with transaction.atomic(using="mydb", savepoint=False):
|
||||
pass
|
||||
|
||||
@transaction.atomic()
|
||||
def decorated_func(param1: str, param2: int) -> bool:
|
||||
pass
|
||||
|
||||
# Ensure that the function's type is preserved
|
||||
reveal_type(decorated_func) # N: Revealed type is 'def (param1: builtins.str, param2: builtins.int) -> builtins.bool'
|
||||
|
||||
@transaction.atomic(using="mydb")
|
||||
def decorated_func_using(param1: str, param2: int) -> bool:
|
||||
pass
|
||||
|
||||
# Ensure that the function's type is preserved
|
||||
reveal_type(decorated_func_using) # N: Revealed type is 'def (param1: builtins.str, param2: builtins.int) -> builtins.bool'
|
||||
|
||||
class ClassWithAtomicMethod:
|
||||
# Bare decorator
|
||||
@transaction.atomic
|
||||
def atomic_method1(self, abc: int) -> str:
|
||||
pass
|
||||
|
||||
@transaction.atomic(savepoint=True)
|
||||
def atomic_method2(self):
|
||||
pass
|
||||
|
||||
@transaction.atomic(using="db", savepoint=True)
|
||||
def atomic_method3(self, myparam: str) -> int:
|
||||
pass
|
||||
|
||||
ClassWithAtomicMethod().atomic_method1("abc") # E: Argument 1 to "atomic_method1" of "ClassWithAtomicMethod" has incompatible type "str"; expected "int"
|
||||
|
||||
# Ensure that the method's type is preserved
|
||||
reveal_type(ClassWithAtomicMethod().atomic_method1) # N: Revealed type is 'def (abc: builtins.int) -> builtins.str'
|
||||
|
||||
# Ensure that the method's type is preserved
|
||||
reveal_type(ClassWithAtomicMethod().atomic_method3) # N: Revealed type is 'def (myparam: builtins.str) -> builtins.int'
|
||||
|
||||
[out]
|
||||
Reference in New Issue
Block a user