basedpyright 1.25.0 → 1.26.0

package/dist/typeshed-fallback/stubs/django-import-export/import_export/formats/base_formats.pyi

@@ -0,0 +1,57 @@
+from _typeshed import Incomplete, ReadableBuffer
+from typing import IO, Any, ClassVar
+from typing_extensions import Self, TypeAlias
+
+Dataset: TypeAlias = Incomplete  # tablib.Dataset
+
+class Format:
+    def get_title(self) -> type[Self]: ...
+    def create_dataset(self, in_stream: str | bytes | IO[Any]) -> Dataset: ...
+    def export_data(self, dataset: Dataset, **kwargs: Any) -> Any: ...
+    def is_binary(self) -> bool: ...
+    def get_read_mode(self) -> str: ...
+    def get_extension(self) -> str: ...
+    def get_content_type(self) -> str: ...
+    @classmethod
+    def is_available(cls) -> bool: ...
+    def can_import(self) -> bool: ...
+    def can_export(self) -> bool: ...
+
+class TablibFormat(Format):
+    TABLIB_MODULE: ClassVar[str]
+    CONTENT_TYPE: ClassVar[str]
+    encoding: str | None
+    def __init__(self, encoding: str | None = None) -> None: ...
+    def get_format(self) -> type[Any]: ...
+    def get_title(self) -> str: ...  # type: ignore[override]
+    def create_dataset(self, in_stream: str | bytes | IO[Any], **kwargs: Any) -> Dataset: ...  # type: ignore[override]
+
+class TextFormat(TablibFormat): ...
+
+class CSV(TextFormat):
+    def export_data(self, dataset: Dataset, **kwargs: Any) -> str: ...
+
+class JSON(TextFormat):
+    def export_data(self, dataset: Dataset, **kwargs: Any) -> str: ...
+
+class YAML(TextFormat):
+    def export_data(self, dataset: Dataset, **kwargs: Any) -> str: ...
+
+class TSV(TextFormat):
+    def export_data(self, dataset: Dataset, **kwargs: Any) -> str: ...
+
+class ODS(TextFormat):
+    def export_data(self, dataset: Dataset, **kwargs: Any) -> bytes: ...
+
+class HTML(TextFormat):
+    def export_data(self, dataset: Dataset, **kwargs: Any) -> str: ...
+
+class XLS(TablibFormat):
+    def export_data(self, dataset: Dataset, **kwargs: Any) -> bytes: ...
+    def create_dataset(self, in_stream: bytes) -> Dataset: ...  # type: ignore[override]
+
+class XLSX(TablibFormat):
+    def export_data(self, dataset: Dataset, **kwargs: Any) -> bytes: ...
+    def create_dataset(self, in_stream: ReadableBuffer) -> Dataset: ...  # type: ignore[override]
+
+DEFAULT_FORMATS: list[type[Format]]

package/dist/typeshed-fallback/stubs/django-import-export/import_export/forms.pyi

@@ -0,0 +1,31 @@
+from typing import Any
+
+from django import forms
+from django.contrib.admin.helpers import ActionForm
+
+from .formats.base_formats import Format
+from .resources import Resource
+
+class ImportExportFormBase(forms.Form):
+    resource: forms.ChoiceField
+    def __init__(self, *args: Any, resources: list[type[Resource[Any]]] | None = None, **kwargs: Any) -> None: ...
+
+class ImportForm(ImportExportFormBase):
+    import_file: forms.FileField
+    input_format: forms.ChoiceField
+    def __init__(self, import_formats: list[Format], *args: Any, **kwargs: Any) -> None: ...
+    @property
+    def media(self) -> forms.Media: ...
+
+class ConfirmImportForm(forms.Form):
+    import_file_name: forms.CharField
+    original_file_name: forms.CharField
+    input_format: forms.CharField
+    resource: forms.CharField
+    def clean_import_file_name(self) -> str: ...
+
+class ExportForm(ImportExportFormBase):
+    file_format: forms.ChoiceField
+    def __init__(self, formats: list[Format], *args: Any, **kwargs: Any) -> None: ...
+
+def export_action_form_factory(formats: list[tuple[str, str]]) -> type[ActionForm]: ...

package/dist/typeshed-fallback/stubs/django-import-export/import_export/instance_loaders.pyi

@@ -0,0 +1,23 @@
+from _typeshed import Incomplete
+from typing import Any
+from typing_extensions import TypeAlias
+
+from django.db.models import Model, QuerySet
+
+from .fields import Field
+from .resources import Resource
+
+Dataset: TypeAlias = Incomplete  # tablib.Dataset
+
+class BaseInstanceLoader:
+    resource: Resource[Any]
+    dataset: Dataset | None
+    def __init__(self, resource: Resource[Any], dataset: Dataset | None = None) -> None: ...
+    def get_instance(self, row: dict[str, Any]) -> Model | None: ...
+
+class ModelInstanceLoader(BaseInstanceLoader):
+    def get_queryset(self) -> QuerySet[Any]: ...
+
+class CachedInstanceLoader(ModelInstanceLoader):
+    pk_field: Field
+    all_instances: dict[Any, Model]

package/dist/typeshed-fallback/stubs/django-import-export/import_export/mixins.pyi

@@ -0,0 +1,66 @@
+from _typeshed import Incomplete, SupportsGetItem
+from logging import Logger
+from typing import Any, Generic, TypeVar
+from typing_extensions import TypeAlias
+
+from django.db.models import Model, QuerySet
+from django.forms import BaseForm, Form
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse
+from django.views.generic.edit import FormView
+
+from .formats.base_formats import Format
+from .resources import Resource
+
+Dataset: TypeAlias = Incomplete  # tablib.Dataset
+
+logger: Logger
+
+_ModelT = TypeVar("_ModelT", bound=Model)
+
+class BaseImportExportMixin(Generic[_ModelT]):
+    resource_class: type[Resource[_ModelT]]
+    resource_classes: SupportsGetItem[int, type[Resource[_ModelT]]]
+    @property
+    def formats(self) -> list[type[Format]]: ...
+    @property
+    def export_formats(self) -> list[type[Format]]: ...
+    @property
+    def import_formats(self) -> list[type[Format]]: ...
+    def check_resource_classes(self, resource_classes: SupportsGetItem[int, type[Resource[_ModelT]]]) -> None: ...
+    def get_resource_classes(self) -> list[type[Resource[_ModelT]]]: ...
+    def get_resource_kwargs(self, request: HttpRequest, *args: Any, **kwargs: Any) -> dict[str, Any]: ...
+    def get_resource_index(self, form: Form) -> int: ...
+
+class BaseImportMixin(BaseImportExportMixin[_ModelT]):
+    def get_import_resource_classes(self) -> list[type[Resource[_ModelT]]]: ...
+    def get_import_formats(self) -> list[Format]: ...
+    def get_import_resource_kwargs(self, request: HttpRequest, *args: Any, **kwargs: Any) -> dict[str, Any]: ...
+    def choose_import_resource_class(self, form: Form) -> type[Resource[_ModelT]]: ...
+
+class BaseExportMixin(BaseImportExportMixin[_ModelT]):
+    model: Model
+    escape_exported_data: bool
+    escape_html: bool
+    escape_formulae: bool
+    @property
+    def should_escape_html(self) -> bool: ...
+    @property
+    def should_escape_formulae(self) -> bool: ...
+    def get_export_formats(self) -> list[Format]: ...
+    def get_export_resource_classes(self) -> list[Resource[_ModelT]]: ...
+    def choose_export_resource_class(self, form: Form) -> Resource[_ModelT]: ...
+    def get_export_resource_kwargs(self, request: HttpRequest, *args: Any, **kwargs: Any) -> dict[str, Any]: ...
+    def get_data_for_export(self, request: HttpRequest, queryset: QuerySet[_ModelT], *args: Any, **kwargs: Any) -> Dataset: ...
+    def get_export_filename(self, file_format: Format) -> str: ...
+
+class ExportViewMixin(BaseExportMixin[_ModelT]):
+    form_class: type[BaseForm] = ...
+    def get_export_data(self, file_format: Format, queryset: QuerySet[_ModelT], *args: Any, **kwargs: Any) -> str | bytes: ...
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]: ...
+    def get_form_kwargs(self) -> dict[str, Any]: ...
+
+_FormT = TypeVar("_FormT", bound=BaseForm)
+
+class ExportViewFormMixin(ExportViewMixin[_ModelT], FormView[_FormT]):  # type: ignore[misc]
+    def form_valid(self, form: _FormT) -> HttpResponse: ...

package/dist/typeshed-fallback/stubs/django-import-export/import_export/resources.pyi

@@ -0,0 +1,232 @@
+import _typeshed
+from collections import OrderedDict
+from collections.abc import Iterator, Sequence
+from functools import partial
+from logging import Logger
+from typing import Any, ClassVar, Generic, Literal, NoReturn, TypeVar, overload
+from typing_extensions import TypeAlias, deprecated
+
+from django.db.models import Field as DjangoField, ForeignObjectRel, Model, QuerySet
+from django.utils.safestring import SafeString
+
+from .fields import Field
+from .instance_loaders import BaseInstanceLoader
+from .results import Error, Result, RowResult
+from .widgets import ForeignKeyWidget, ManyToManyWidget, Widget
+
+Dataset: TypeAlias = _typeshed.Incomplete  # tablib.Dataset
+logger: Logger
+
+@overload
+def get_related_model(field: ForeignObjectRel) -> Model: ...
+@overload
+def get_related_model(field: DjangoField[Any, Any]) -> Model | None: ...
+def has_natural_foreign_key(model: Model) -> bool: ...
+
+class ResourceOptions(Generic[_ModelT]):
+    model: _ModelT
+    fields: Sequence[str] | None
+    exclude: Sequence[str] | None
+    instance_loader_class: type[BaseInstanceLoader] | None
+    import_id_fields: Sequence[str]
+    export_order: Sequence[str] | None
+    widgets: dict[str, Any] | None
+    use_transactions: bool | None
+    skip_unchanged: bool
+    report_skipped: bool
+    clean_model_instances: bool
+    chunk_size: int | None
+    skip_diff: bool
+    skip_html_diff: bool
+    use_bulk: bool
+    batch_size: int
+    force_init_instance: bool
+    using_db: str | None
+    store_row_values: bool
+    store_instance: bool
+    use_natural_foreign_keys: bool
+
+class DeclarativeMetaclass(type):
+    def __new__(cls: type[_typeshed.Self], name: str, bases: tuple[type[Any], ...], attrs: dict[str, Any]) -> _typeshed.Self: ...
+
+class Diff:
+    left: list[str]
+    right: list[str]
+    new: bool
+    def __init__(self, resource: Resource[_ModelT], instance: _ModelT, new: bool) -> None: ...
+    def compare_with(self, resource: Resource[_ModelT], instance: _ModelT, dry_run: bool = False) -> None: ...
+    def as_html(self) -> list[SafeString]: ...
+
+_ModelT = TypeVar("_ModelT", bound=Model)
+
+class Resource(Generic[_ModelT], metaclass=DeclarativeMetaclass):
+    _meta: ResourceOptions[_ModelT]
+    fields: OrderedDict[str, Field]
+    create_instances: list[_ModelT]
+    update_instances: list[_ModelT]
+    delete_instances: list[_ModelT]
+    def __init__(self, **kwargs: Any) -> None: ...
+    @classmethod
+    def get_result_class(self) -> type[Result]: ...
+    @classmethod
+    def get_row_result_class(self) -> type[RowResult]: ...
+    @classmethod
+    def get_error_result_class(self) -> type[Error]: ...
+    @classmethod
+    def get_diff_class(self) -> type[Diff]: ...
+    @classmethod
+    def get_db_connection_name(self) -> str: ...
+    def get_use_transactions(self) -> bool: ...
+    def get_chunk_size(self) -> int: ...
+    def get_fields(self, **kwargs: Any) -> list[Field]: ...
+    def get_field_name(self, field: Field) -> str: ...
+    def init_instance(self, row: dict[str, Any] | None = None) -> _ModelT: ...
+    def get_instance(self, instance_loader: BaseInstanceLoader, row: dict[str, Any]) -> _ModelT | None: ...
+    def get_or_init_instance(self, instance_loader: BaseInstanceLoader, row: dict[str, Any]) -> tuple[_ModelT | None, bool]: ...
+    def get_import_id_fields(self) -> Sequence[str]: ...
+    def get_bulk_update_fields(self) -> list[str]: ...
+    def bulk_create(
+        self,
+        using_transactions: bool,
+        dry_run: bool,
+        raise_errors: bool,
+        batch_size: int | None = None,
+        result: Result | None = None,
+    ) -> None: ...
+    def bulk_update(
+        self,
+        using_transactions: bool,
+        dry_run: bool,
+        raise_errors: bool,
+        batch_size: int | None = None,
+        result: Result | None = None,
+    ) -> None: ...
+    def bulk_delete(self, using_transactions: bool, dry_run: bool, raise_errors: bool, result: Result | None = None) -> None: ...
+    def validate_instance(
+        self, instance: _ModelT, import_validation_errors: dict[str, Any] | None = None, validate_unique: bool = True
+    ) -> None: ...
+    def save_instance(
+        self, instance: _ModelT, is_create: bool, using_transactions: bool = True, dry_run: bool = False
+    ) -> None: ...
+    def before_save_instance(self, instance: _ModelT, using_transactions: bool, dry_run: bool) -> None: ...
+    def after_save_instance(self, instance: _ModelT, using_transactions: bool, dry_run: bool) -> None: ...
+    def delete_instance(self, instance: _ModelT, using_transactions: bool = True, dry_run: bool = False) -> None: ...
+    def before_delete_instance(self, instance: _ModelT, dry_run: bool) -> None: ...
+    def after_delete_instance(self, instance: _ModelT, dry_run: bool) -> None: ...
+    def import_field(self, field: Field, obj: _ModelT, data: dict[str, Any], is_m2m: bool = False, **kwargs: Any) -> None: ...
+    def get_import_fields(self) -> list[Field]: ...
+    def import_obj(self, obj: _ModelT, data: dict[str, Any], dry_run: bool, **kwargs: Any) -> None: ...
+    def save_m2m(self, obj: _ModelT, data: dict[str, Any], using_transactions: bool, dry_run: bool) -> None: ...
+    def for_delete(self, row: dict[str, Any], instance: _ModelT) -> bool: ...
+    def skip_row(
+        self, instance: _ModelT, original: _ModelT, row: dict[str, Any], import_validation_errors: dict[str, Any] | None = None
+    ) -> bool: ...
+    def get_diff_headers(self) -> list[str]: ...
+    def before_import(self, dataset: Dataset, using_transactions: bool, dry_run: bool, **kwargs: Any) -> None: ...
+    def after_import(self, dataset: Dataset, result: Result, using_transactions: bool, dry_run: bool, **kwargs: Any) -> None: ...
+    def before_import_row(self, row: dict[str, Any], row_number: int | None = None, **kwargs: Any) -> None: ...
+    def after_import_row(
+        self, row: dict[str, Any], row_result: RowResult, row_number: int | None = None, **kwargs: Any
+    ) -> None: ...
+    def after_import_instance(self, instance: _ModelT, new: bool, row_number: int | None = None, **kwargs: Any) -> None: ...
+    @overload
+    def handle_import_error(self, result: Result, error: Exception, raise_errors: Literal[True]) -> NoReturn: ...
+    @overload
+    def handle_import_error(self, result: Result, error: Exception, raise_errors: Literal[False] = ...) -> None: ...
+    @overload
+    @deprecated("raise_errors argument is deprecated and will be removed in a future release.")
+    def import_row(
+        self,
+        row: dict[str, Any],
+        instance_loader: BaseInstanceLoader,
+        using_transactions: bool = True,
+        dry_run: bool = False,
+        *,
+        raise_errors: bool,
+        **kwargs: Any,
+    ) -> RowResult: ...
+    @overload
+    def import_row(
+        self,
+        row: dict[str, Any],
+        instance_loader: BaseInstanceLoader,
+        using_transactions: bool = True,
+        dry_run: bool = False,
+        raise_errors: None = None,
+        **kwargs: Any,
+    ) -> RowResult: ...
+    def import_data(
+        self,
+        dataset: Dataset,
+        dry_run: bool = False,
+        raise_errors: bool = False,
+        use_transactions: bool | None = None,
+        collect_failed_rows: bool = False,
+        rollback_on_validation_errors: bool = False,
+        **kwargs: Any,
+    ) -> Result: ...
+    @overload
+    @deprecated("rollback_on_validation_errors argument is deprecated and will be removed in a future release.")
+    def import_data_inner(
+        self,
+        dataset: Dataset,
+        dry_run: bool,
+        raise_errors: bool,
+        using_transactions: bool,
+        collect_failed_rows: bool,
+        rollback_on_validation_errors: bool,
+        **kwargs: Any,
+    ) -> Result: ...
+    @overload
+    def import_data_inner(
+        self,
+        dataset: Dataset,
+        dry_run: bool,
+        raise_errors: bool,
+        using_transactions: bool,
+        collect_failed_rows: bool,
+        rollback_on_validation_errors: None = None,
+        **kwargs: Any,
+    ) -> Result: ...
+    def get_export_order(self) -> tuple[str, ...]: ...
+    def before_export(self, queryset: QuerySet[_ModelT], *args: Any, **kwargs: Any) -> None: ...
+    def after_export(self, queryset: QuerySet[_ModelT], data: Dataset, *args: Any, **kwargs: Any) -> None: ...
+    def filter_export(self, queryset: QuerySet[_ModelT], *args: Any, **kwargs: Any) -> QuerySet[_ModelT]: ...
+    def export_field(self, field: Field, obj: _ModelT) -> str: ...
+    def get_export_fields(self) -> list[Field]: ...
+    def export_resource(self, obj: _ModelT) -> list[str]: ...
+    def get_export_headers(self) -> list[str]: ...
+    def get_user_visible_headers(self) -> list[str]: ...
+    def get_user_visible_fields(self) -> list[str]: ...
+    def iter_queryset(self, queryset: QuerySet[_ModelT]) -> Iterator[_ModelT]: ...
+    def export(self, *args: Any, queryset: QuerySet[_ModelT] | None = None, **kwargs: Any) -> Dataset: ...
+
+class ModelDeclarativeMetaclass(DeclarativeMetaclass):
+    def __new__(cls: type[_typeshed.Self], name: str, bases: tuple[type[Any], ...], attrs: dict[str, Any]) -> _typeshed.Self: ...
+
+class ModelResource(Resource[_ModelT], metaclass=ModelDeclarativeMetaclass):
+    DEFAULT_RESOURCE_FIELD: ClassVar[type[Field]] = ...
+    WIDGETS_MAP: ClassVar[dict[str, type[Widget]]]
+    @classmethod
+    def get_m2m_widget(cls, field: DjangoField[Any, Any]) -> partial[ManyToManyWidget[Any]]: ...
+    @classmethod
+    def get_fk_widget(cls, field: DjangoField[Any, Any]) -> partial[ForeignKeyWidget[Any]]: ...
+    @classmethod
+    def widget_from_django_field(cls, f: DjangoField[Any, Any], default: type[Widget] = ...) -> type[Widget]: ...
+    @classmethod
+    def widget_kwargs_for_field(self, field_name: str) -> dict[str, Any]: ...
+    @classmethod
+    def field_from_django_field(cls, field_name: str, django_field: DjangoField[Any, Any], readonly: bool) -> Field: ...
+    def get_queryset(self) -> QuerySet[_ModelT]: ...
+    def init_instance(self, row: dict[str, Any] | None = None) -> _ModelT: ...
+    def after_import(self, dataset: Dataset, result: Result, using_transactions: bool, dry_run: bool, **kwargs: Any) -> None: ...
+    @classmethod
+    def get_display_name(cls) -> str: ...
+
+_ResourceT = TypeVar("_ResourceT", bound=Resource[Any])
+
+# HK Type Vars could help type the first overload:
+@overload
+def modelresource_factory(model: Model, resource_class: type[_ResourceT]) -> _ResourceT: ...
+@overload
+def modelresource_factory(model: _ModelT) -> ModelResource[_ModelT]: ...

package/dist/typeshed-fallback/stubs/django-import-export/import_export/results.pyi

@@ -0,0 +1,73 @@
+from _typeshed import Incomplete
+from collections import OrderedDict
+from collections.abc import Iterator
+from typing import Any, ClassVar, Literal
+from typing_extensions import TypeAlias
+
+from django.core.exceptions import ValidationError
+from django.db.models import Model
+
+Dataset: TypeAlias = Incomplete  # tablib.Dataset
+
+class Error:
+    error: Exception
+    traceback: str
+    row: dict[str, Any]
+    def __init__(self, error: Exception, traceback: str | None = None, row: dict[str, Any] | None = None) -> None: ...
+
+_ImportType: TypeAlias = Literal["update", "new", "delete", "skip", "error", "invalid"]
+
+class RowResult:
+    IMPORT_TYPE_UPDATE: ClassVar[Literal["update"]]
+    IMPORT_TYPE_NEW: ClassVar[Literal["new"]]
+    IMPORT_TYPE_DELETE: ClassVar[Literal["delete"]]
+    IMPORT_TYPE_SKIP: ClassVar[Literal["skip"]]
+    IMPORT_TYPE_ERROR: ClassVar[Literal["error"]]
+    IMPORT_TYPE_INVALID: ClassVar[Literal["invalid"]]
+    valid_import_types: frozenset[_ImportType]
+    errors: list[Error]
+    validation_error: ValidationError | None
+    diff: list[str] | None
+    import_type: _ImportType
+    row_values: dict[str, Any]
+    object_id: Any | None
+    object_repr: str | None
+    instance: Model
+    original: Model
+    new_record: bool | None
+    def __init__(self) -> None: ...
+    def add_instance_info(self, instance: Model) -> None: ...
+
+class InvalidRow:
+    number: int
+    error: ValidationError
+    values: tuple[Any, ...]
+    error_dict: dict[str, list[str]]
+    def __init__(self, number: int, validation_error: ValidationError, values: tuple[Any, ...]) -> None: ...
+    @property
+    def field_specific_errors(self) -> dict[str, list[str]]: ...
+    @property
+    def non_field_specific_errors(self) -> list[str]: ...
+    @property
+    def error_count(self) -> int: ...
+
+class Result:
+    base_errors: list[Error]
+    diff_headers: list[str]
+    rows: list[RowResult]
+    invalid_rows: list[InvalidRow]
+    failed_dataset: Dataset
+    totals: OrderedDict[_ImportType, int]
+    total_rows: int
+    def __init__(self) -> None: ...
+    def valid_rows(self) -> list[RowResult]: ...
+    def append_row_result(self, row_result: RowResult) -> None: ...
+    def append_base_error(self, error: Error) -> None: ...
+    def add_dataset_headers(self, headers: list[str] | None) -> None: ...
+    def append_failed_row(self, row: dict[str, Any], error: Exception) -> None: ...
+    def append_invalid_row(self, number: int, row: dict[str, Any], validation_error: ValidationError) -> None: ...
+    def increment_row_result_total(self, row_result: RowResult) -> None: ...
+    def row_errors(self) -> list[tuple[int, Any]]: ...
+    def has_errors(self) -> bool: ...
+    def has_validation_errors(self) -> bool: ...
+    def __iter__(self) -> Iterator[RowResult]: ...

package/dist/typeshed-fallback/stubs/django-import-export/import_export/signals.pyi

@@ -0,0 +1,4 @@
+from django.dispatch import Signal
+
+post_export: Signal
+post_import: Signal

package/dist/typeshed-fallback/stubs/django-import-export/import_export/templatetags/import_export_tags.pyi

@@ -0,0 +1,8 @@
+from typing_extensions import LiteralString
+
+from django.template import Library
+
+register: Library
+
+# @register.simple_tag  # commented out for pytype
+def compare_values(value1: str, value2: str) -> LiteralString: ...

package/dist/typeshed-fallback/stubs/django-import-export/import_export/tmp_storages.pyi

@@ -0,0 +1,34 @@
+from abc import abstractmethod
+from typing import IO, Any, ClassVar
+
+class BaseStorage:
+    name: str | None
+    read_mode: str
+    encoding: str | None
+    def __init__(self, *, name: str | None = None, read_mode: str = "", encoding: str | None = None) -> None: ...
+    @abstractmethod
+    def save(self, data: Any) -> None: ...
+    @abstractmethod
+    def read(self) -> Any: ...  # `Any` because `read` returns things from `save`
+    @abstractmethod
+    def remove(self) -> None: ...
+
+class TempFolderStorage(BaseStorage):
+    def save(self, data: Any) -> None: ...
+    def read(self) -> Any: ...
+    def remove(self) -> None: ...
+    def get_full_path(self) -> str: ...
+
+class CacheStorage(BaseStorage):
+    CACHE_LIFETIME: int
+    CACHE_PREFIX: str
+    def save(self, data: Any) -> None: ...
+    def read(self) -> Any: ...
+    def remove(self) -> None: ...
+
+class MediaStorage(BaseStorage):
+    MEDIA_FOLDER: ClassVar[str]
+    def save(self, data: IO[Any]) -> None: ...
+    def read(self) -> Any: ...
+    def remove(self) -> None: ...
+    def get_full_path(self) -> str: ...

package/dist/typeshed-fallback/stubs/django-import-export/import_export/utils.pyi

@@ -0,0 +1,18 @@
+from collections.abc import Callable
+from types import TracebackType
+from typing import Any, TypeVar
+
+from django.db.transaction import Atomic
+
+_C = TypeVar("_C", bound=Callable[..., Any])
+
+class atomic_if_using_transaction:
+    using_transactions: bool
+    context_manager: Atomic
+    def __init__(self, using_transactions: bool, using: str | None) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+
+def original(method: _C) -> _C: ...

package/dist/typeshed-fallback/stubs/django-import-export/import_export/widgets.pyi

@@ -0,0 +1,66 @@
+from collections.abc import Mapping
+from datetime import datetime
+from typing import Any, ClassVar, Generic, TypeVar
+
+from django.db.models import Model, QuerySet
+
+def format_datetime(value: datetime, datetime_format: str) -> str: ...
+
+class Widget:
+    def clean(self, value: Any, row: Mapping[str, Any] | None = None, **kwargs: Any) -> Any: ...
+    def render(self, value: Any, obj: Model | None = None) -> Any: ...
+
+class NumberWidget(Widget):
+    coerce_to_string: bool
+    def __init__(self, coerce_to_string: bool = False) -> None: ...
+    def is_empty(self, value: Any) -> bool: ...
+    def render(self, value: Any, obj: Model | None = None) -> Any: ...
+
+class FloatWidget(NumberWidget): ...
+class IntegerWidget(NumberWidget): ...
+class DecimalWidget(NumberWidget): ...
+
+class CharWidget(Widget):
+    coerce_to_string: bool
+    allow_blank: bool
+    def __init__(self, coerce_to_string: bool = False, allow_blank: bool = False) -> None: ...
+
+class BooleanWidget(Widget):
+    TRUE_VALUES: ClassVar[list[str | int | bool]]
+    FALSE_VALUES: ClassVar[list[str | int | bool]]
+    NULL_VALUES: ClassVar[list[str | None]]
+
+class DateWidget(Widget):
+    formats: tuple[str, ...]
+    def __init__(self, format: str | None = None) -> None: ...
+
+class DateTimeWidget(Widget):
+    formats: tuple[str, ...]
+    def __init__(self, format: str | None = None) -> None: ...
+
+class TimeWidget(Widget):
+    formats: tuple[str, ...]
+    def __init__(self, format: str | None = None) -> None: ...
+
+class DurationWidget(Widget): ...
+
+class SimpleArrayWidget(Widget):
+    separator: str
+    def __init__(self, separator: str | None = None) -> None: ...
+
+class JSONWidget(Widget): ...
+
+_ModelT = TypeVar("_ModelT", bound=Model)
+
+class ForeignKeyWidget(Widget, Generic[_ModelT]):
+    model: _ModelT
+    field: str
+    use_natural_foreign_keys: bool
+    def __init__(self, model: _ModelT, field: str = "pk", use_natural_foreign_keys: bool = False, **kwargs: Any) -> None: ...
+    def get_queryset(self, value: Any, row: Mapping[str, Any], *args: Any, **kwargs: Any) -> QuerySet[_ModelT]: ...
+
+class ManyToManyWidget(Widget, Generic[_ModelT]):
+    model: _ModelT
+    separator: str
+    field: str
+    def __init__(self, model: _ModelT, separator: str | None = None, field: str | None = None, **kwargs: Any) -> None: ...

package/dist/typeshed-fallback/stubs/docker/docker/models/containers.pyi

@@ -35,7 +35,7 @@ class Container(Model):
     def diff(self): ...
     def exec_run(
         self,
-        cmd,
+        cmd: str | list[str],
         stdout: bool = True,
         stderr: bool = True,
         stdin: bool = False,
@@ -51,7 +51,7 @@ class Container(Model):
     ) -> ExecResult: ...
     def export(self, chunk_size: int | None = 2097152) -> str: ...
     def get_archive(
-        self, path, chunk_size: int | None = 2097152, encode_stream: bool = False
+        self, path: str, chunk_size: int | None = 2097152, encode_stream: bool = False
     ) -> tuple[Incomplete, Incomplete]: ...
     def kill(self, signal: Incomplete | None = None): ...
     @overload

package/dist/typeshed-fallback/stubs/flake8-bugbear/METADATA.toml

@@ -1,4 +1,4 @@
-version = "24.10.31"
+version = "24.12.12"
 upstream_repository = "https://github.com/PyCQA/flake8-bugbear"
 partial_stub = true
 

package/dist/typeshed-fallback/stubs/fpdf2/METADATA.toml

@@ -1,4 +1,4 @@
-version = "2.8.1"
+version = "2.8.2"
 upstream_repository = "https://github.com/PyFPDF/fpdf2"
 requires = ["Pillow>=10.3.0"]
 

package/dist/typeshed-fallback/stubs/fpdf2/fpdf/__init__.pyi

@@ -6,6 +6,7 @@ from .fpdf import FPDF as FPDF, FPDFException as FPDFException, TitleStyle as Ti
 from .html import HTML2FPDF as HTML2FPDF, HTMLMixin as HTMLMixin
 from .prefs import ViewerPreferences as ViewerPreferences
 from .template import FlexTemplate as FlexTemplate, Template as Template
+from .util import get_scale_factor as get_scale_factor
 
 __license__: str
 __version__: str
@@ -31,4 +32,5 @@ __all__ = [
     "HTML2FPDF",
     "FPDF_VERSION",
     "FPDF_FONT_DIR",
+    "get_scale_factor",
 ]