jaclang 0.6.2__py3-none-any.whl → 0.9.5__py3-none-any.whl

jaclang/vendor/typeshed/stubs/WTForms/@tests/test_cases/check_validators.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from wtforms import DateField, Field, Form, StringField
+from wtforms.validators import Email, Optional
+
+form = Form()
+# on form we should accept any validator mapping
+form.validate({"field": (Optional(),), "string_field": (Optional(), Email())})
+form.validate({"field": [Optional()], "string_field": [Optional(), Email()]})
+
+# both StringField validators and Field validators should be valid
+# as inputs on a StringField
+string_field = StringField(validators=(Optional(), Email()))
+string_field.validate(form, (Optional(), Email()))
+
+# but not on Field
+field = Field(validators=(Optional(), Email()))  # type: ignore
+field.validate(form, (Optional(), Email()))  # type: ignore
+
+# unless we only pass the Field validator
+Field(validators=(Optional(),))
+field.validate(form, (Optional(),))
+
+# DateField should accept Field validators but not StringField validators
+date_field = DateField(validators=(Optional(), Email()))  # type: ignore
+date_field.validate(form, (Optional(), Email()))  # type: ignore
+DateField(validators=(Optional(),))
+
+# for lists we can't be as strict so we won't get type errors here
+Field(validators=[Optional(), Email()])
+field.validate(form, [Optional(), Email()])
+DateField(validators=[Optional(), Email()])
+date_field.validate(form, [Optional(), Email()])

jaclang/vendor/typeshed/stubs/WTForms/@tests/test_cases/check_widgets.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from wtforms import Field, FieldList, Form, FormField, SelectField, StringField
+from wtforms.widgets import Input, ListWidget, Option, Select, TableWidget, TextArea
+
+# more specific widgets should only work on more specific fields
+Field(widget=Input())
+Field(widget=TextArea())  # type: ignore
+Field(widget=Select())  # type: ignore
+
+# less specific widgets are fine, even if they're often not what you want
+StringField(widget=Input())
+StringField(widget=TextArea())
+
+SelectField(widget=Input(), option_widget=Input())
+SelectField(widget=Select(), option_widget=Option())
+# a more specific type other than Option widget is not allowed
+SelectField(widget=Select(), option_widget=TextArea())  # type: ignore
+
+# we should be able to pass Field() even though it wants an unbound_field
+# this gets around __new__ not working in type checking
+FieldList(Field(), widget=Input())
+FieldList(Field(), widget=ListWidget())
+
+FormField(Form, widget=Input())
+FormField(Form, widget=TableWidget())

jaclang/vendor/typeshed/stubs/WTForms/wtforms/__init__.pyi

@@ -0,0 +1,85 @@
+from typing import Final
+
+from wtforms import validators as validators, widgets as widgets
+from wtforms.fields.choices import (
+    RadioField as RadioField,
+    SelectField as SelectField,
+    SelectFieldBase as SelectFieldBase,
+    SelectMultipleField as SelectMultipleField,
+)
+from wtforms.fields.core import Field as Field, Flags as Flags, Label as Label
+from wtforms.fields.datetime import (
+    DateField as DateField,
+    DateTimeField as DateTimeField,
+    DateTimeLocalField as DateTimeLocalField,
+    MonthField as MonthField,
+    TimeField as TimeField,
+    WeekField as WeekField,
+)
+from wtforms.fields.form import FormField as FormField
+from wtforms.fields.list import FieldList as FieldList
+from wtforms.fields.numeric import (
+    DecimalField as DecimalField,
+    DecimalRangeField as DecimalRangeField,
+    FloatField as FloatField,
+    IntegerField as IntegerField,
+    IntegerRangeField as IntegerRangeField,
+)
+from wtforms.fields.simple import (
+    BooleanField as BooleanField,
+    ColorField as ColorField,
+    EmailField as EmailField,
+    FileField as FileField,
+    HiddenField as HiddenField,
+    MultipleFileField as MultipleFileField,
+    PasswordField as PasswordField,
+    SearchField as SearchField,
+    StringField as StringField,
+    SubmitField as SubmitField,
+    TelField as TelField,
+    TextAreaField as TextAreaField,
+    URLField as URLField,
+)
+from wtforms.form import Form as Form
+from wtforms.validators import ValidationError as ValidationError
+
+__version__: Final[str]
+__all__ = [
+    "validators",
+    "widgets",
+    "Form",
+    "ValidationError",
+    "SelectField",
+    "SelectFieldBase",
+    "SelectMultipleField",
+    "RadioField",
+    "Field",
+    "Flags",
+    "Label",
+    "DateTimeField",
+    "DateField",
+    "TimeField",
+    "MonthField",
+    "DateTimeLocalField",
+    "WeekField",
+    "FormField",
+    "FieldList",
+    "IntegerField",
+    "DecimalField",
+    "FloatField",
+    "IntegerRangeField",
+    "DecimalRangeField",
+    "BooleanField",
+    "TextAreaField",
+    "PasswordField",
+    "FileField",
+    "MultipleFileField",
+    "HiddenField",
+    "SearchField",
+    "SubmitField",
+    "StringField",
+    "TelField",
+    "URLField",
+    "EmailField",
+    "ColorField",
+]

jaclang/vendor/typeshed/stubs/WTForms/wtforms/csrf/core.pyi

@@ -0,0 +1,41 @@
+from abc import abstractmethod
+from collections.abc import Callable, Sequence
+from typing import Any
+from typing_extensions import Self
+
+from wtforms.fields import HiddenField
+from wtforms.fields.core import UnboundField, _Filter, _FormT, _Validator, _Widget
+from wtforms.form import BaseForm
+from wtforms.meta import DefaultMeta, _SupportsGettextAndNgettext
+
+__all__ = ("CSRFTokenField", "CSRF")
+
+class CSRFTokenField(HiddenField):
+    current_token: str | None
+    csrf_impl: CSRF
+    def __init__(
+        self,
+        label: str | None = None,
+        validators: tuple[_Validator[_FormT, Self], ...] | list[Any] | None = None,
+        filters: Sequence[_Filter] = (),
+        description: str = "",
+        id: str | None = None,
+        default: str | Callable[[], str] | None = None,
+        widget: _Widget[Self] | None = None,
+        render_kw: dict[str, Any] | None = None,
+        name: str | None = None,
+        _form: BaseForm | None = None,
+        _prefix: str = "",
+        _translations: _SupportsGettextAndNgettext | None = None,
+        _meta: DefaultMeta | None = None,
+        *,
+        csrf_impl: CSRF,
+    ) -> None: ...
+
+class CSRF:
+    field_class: type[CSRFTokenField]
+    def setup_form(self, form: BaseForm) -> list[tuple[str, UnboundField[Any]]]: ...
+    @abstractmethod
+    def generate_csrf_token(self, csrf_token_field: CSRFTokenField) -> str: ...
+    @abstractmethod
+    def validate_csrf_token(self, form: BaseForm, field: CSRFTokenField) -> None: ...

jaclang/vendor/typeshed/stubs/WTForms/wtforms/csrf/session.pyi

@@ -0,0 +1,20 @@
+from _typeshed import SupportsItemAccess
+from datetime import datetime, timedelta
+from typing import Any
+
+from wtforms.csrf.core import CSRF, CSRFTokenField
+from wtforms.form import BaseForm
+from wtforms.meta import DefaultMeta
+
+__all__ = ("SessionCSRF",)
+
+class SessionCSRF(CSRF):
+    TIME_FORMAT: str
+    form_meta: DefaultMeta
+    def generate_csrf_token(self, csrf_token_field: CSRFTokenField) -> str: ...
+    def validate_csrf_token(self, form: BaseForm, field: CSRFTokenField) -> None: ...
+    def now(self) -> datetime: ...
+    @property
+    def time_limit(self) -> timedelta: ...
+    @property
+    def session(self) -> SupportsItemAccess[str, Any]: ...

jaclang/vendor/typeshed/stubs/WTForms/wtforms/fields/__init__.pyi

@@ -0,0 +1,77 @@
+from wtforms.fields.choices import (
+    RadioField as RadioField,
+    SelectField as SelectField,
+    SelectFieldBase as SelectFieldBase,
+    SelectMultipleField as SelectMultipleField,
+)
+from wtforms.fields.core import Field as Field, Flags as Flags, Label as Label
+from wtforms.fields.datetime import (
+    DateField as DateField,
+    DateTimeField as DateTimeField,
+    DateTimeLocalField as DateTimeLocalField,
+    MonthField as MonthField,
+    TimeField as TimeField,
+    WeekField as WeekField,
+)
+from wtforms.fields.form import FormField as FormField
+from wtforms.fields.list import FieldList as FieldList
+from wtforms.fields.numeric import (
+    DecimalField as DecimalField,
+    DecimalRangeField as DecimalRangeField,
+    FloatField as FloatField,
+    IntegerField as IntegerField,
+    IntegerRangeField as IntegerRangeField,
+)
+from wtforms.fields.simple import (
+    BooleanField as BooleanField,
+    ColorField as ColorField,
+    EmailField as EmailField,
+    FileField as FileField,
+    HiddenField as HiddenField,
+    MultipleFileField as MultipleFileField,
+    PasswordField as PasswordField,
+    SearchField as SearchField,
+    StringField as StringField,
+    SubmitField as SubmitField,
+    TelField as TelField,
+    TextAreaField as TextAreaField,
+    URLField as URLField,
+)
+from wtforms.utils import unset_value as _unset_value
+
+__all__ = [
+    "Field",
+    "Flags",
+    "Label",
+    "SelectField",
+    "SelectFieldBase",
+    "SelectMultipleField",
+    "RadioField",
+    "DateTimeField",
+    "DateField",
+    "TimeField",
+    "MonthField",
+    "DateTimeLocalField",
+    "WeekField",
+    "FormField",
+    "IntegerField",
+    "DecimalField",
+    "FloatField",
+    "IntegerRangeField",
+    "DecimalRangeField",
+    "BooleanField",
+    "TextAreaField",
+    "PasswordField",
+    "FileField",
+    "MultipleFileField",
+    "HiddenField",
+    "SearchField",
+    "SubmitField",
+    "StringField",
+    "TelField",
+    "URLField",
+    "EmailField",
+    "ColorField",
+    "FieldList",
+    "_unset_value",
+]

jaclang/vendor/typeshed/stubs/WTForms/wtforms/fields/choices.pyi

@@ -0,0 +1,79 @@
+from collections.abc import Callable, Iterable, Iterator, Sequence
+from typing import Any
+from typing_extensions import Self, TypeAlias
+
+from wtforms.fields.core import Field, _Filter, _FormT, _Validator, _Widget
+from wtforms.form import BaseForm
+from wtforms.meta import DefaultMeta, _SupportsGettextAndNgettext
+
+__all__ = ("SelectField", "SelectMultipleField", "RadioField")
+
+# technically this allows a list, but we're more strict for type safety
+_Choice: TypeAlias = tuple[Any, str] | tuple[Any, str, dict[str, Any]]
+# it's too difficult to get type safety here due to to nested partially invariant collections
+_GroupedChoices: TypeAlias = dict[str, Any]  # Any should be Collection[_Choice]
+_FullChoice: TypeAlias = tuple[Any, str, bool, dict[str, Any]]  # value, label, selected, render_kw
+_FullGroupedChoices: TypeAlias = tuple[str, Iterable[_FullChoice]]
+_Option: TypeAlias = SelectFieldBase._Option
+
+class SelectFieldBase(Field):
+    option_widget: _Widget[_Option]
+    def __init__(
+        self,
+        label: str | None = None,
+        validators: tuple[_Validator[_FormT, Self], ...] | list[Any] | None = None,
+        option_widget: _Widget[_Option] | None = None,
+        *,
+        filters: Sequence[_Filter] = (),
+        description: str = "",
+        id: str | None = None,
+        default: object | None = None,
+        widget: _Widget[Self] | None = None,
+        render_kw: dict[str, Any] | None = None,
+        name: str | None = None,
+        _form: BaseForm | None = None,
+        _prefix: str = "",
+        _translations: _SupportsGettextAndNgettext | None = None,
+        _meta: DefaultMeta | None = None,
+    ) -> None: ...
+    def iter_choices(self) -> Iterator[_FullChoice]: ...
+    def has_groups(self) -> bool: ...
+    def iter_groups(self) -> Iterator[_FullGroupedChoices]: ...
+    def __iter__(self) -> Iterator[_Option]: ...
+
+    class _Option(Field):
+        checked: bool
+
+class SelectField(SelectFieldBase):
+    coerce: Callable[[Any], Any]
+    choices: list[_Choice] | _GroupedChoices
+    validate_choice: bool
+    def __init__(
+        self,
+        label: str | None = None,
+        validators: tuple[_Validator[_FormT, Self], ...] | list[Any] | None = None,
+        coerce: Callable[[Any], Any] = ...,
+        choices: Iterable[_Choice] | _GroupedChoices | Callable[[], Iterable[_Choice] | _GroupedChoices] | None = None,
+        validate_choice: bool = True,
+        *,
+        filters: Sequence[_Filter] = (),
+        description: str = "",
+        id: str | None = None,
+        default: object | None = None,
+        widget: _Widget[Self] | None = None,
+        option_widget: _Widget[_Option] | None = None,
+        render_kw: dict[str, Any] | None = None,
+        name: str | None = None,
+        _form: BaseForm | None = None,
+        _prefix: str = "",
+        _translations: _SupportsGettextAndNgettext | None = None,
+        _meta: DefaultMeta | None = None,
+    ) -> None: ...
+    def iter_choices(self) -> Iterator[_FullChoice]: ...
+    def has_groups(self) -> bool: ...
+    def iter_groups(self) -> Iterator[_FullGroupedChoices]: ...
+
+class SelectMultipleField(SelectField):
+    data: list[Any] | None
+
+class RadioField(SelectField): ...

jaclang/vendor/typeshed/stubs/WTForms/wtforms/fields/core.pyi

@@ -0,0 +1,134 @@
+from builtins import type as _type  # type is being shadowed in Field
+from collections.abc import Callable, Iterable, Sequence
+from typing import Any, Generic, Protocol, TypeVar, overload, type_check_only
+from typing_extensions import Self, TypeAlias
+
+from markupsafe import Markup
+from wtforms.form import BaseForm
+from wtforms.meta import DefaultMeta, _MultiDictLikeWithGetlist, _SupportsGettextAndNgettext
+
+_FormT = TypeVar("_FormT", bound=BaseForm)
+_FieldT = TypeVar("_FieldT", bound=Field)
+_FormT_contra = TypeVar("_FormT_contra", bound=BaseForm, contravariant=True)
+_FieldT_contra = TypeVar("_FieldT_contra", bound=Field, contravariant=True)
+# It would be nice to annotate this as invariant, i.e. input type and output type
+# needs to be the same, but it will probably be too annoying to use, for now we
+# trust, that people won't use it to change the type of data in a field...
+_Filter: TypeAlias = Callable[[Any], Any]
+
+@type_check_only
+class _Validator(Protocol[_FormT_contra, _FieldT_contra]):
+    def __call__(self, form: _FormT_contra, field: _FieldT_contra, /) -> object: ...
+
+@type_check_only
+class _Widget(Protocol[_FieldT_contra]):
+    def __call__(self, field: _FieldT_contra, **kwargs: Any) -> Markup: ...
+
+class Field:
+    errors: Sequence[str]
+    process_errors: Sequence[str]
+    raw_data: list[Any] | None
+    object_data: Any
+    data: Any
+    validators: Sequence[_Validator[Any, Self]]
+    # even though this could be None on the base class, this should
+    # never actually be None in a real field
+    widget: _Widget[Self]
+    do_not_call_in_templates: bool
+    meta: DefaultMeta
+    default: Any | None
+    description: str
+    render_kw: dict[str, Any]
+    filters: Sequence[_Filter]
+    flags: Flags
+    name: str
+    short_name: str
+    id: str
+    type: str
+    label: Label
+    # technically this can return UnboundField, but that is not allowed
+    # by type checkers, so we use a descriptor hack to get around this
+    # limitation instead
+    def __new__(cls, *args: Any, **kwargs: Any) -> Self: ...
+    def __init__(
+        self,
+        label: str | None = None,
+        # for tuple we can be a bit more type safe and only accept validators
+        # that would work on this or a less specific field, but in general it
+        # would be too annoying to restrict to Sequence[_Validator], since mypy
+        # will infer a list of mixed validators as list[object], since that is
+        # the common base class between all validators
+        validators: tuple[_Validator[_FormT, Self], ...] | list[Any] | None = None,
+        filters: Sequence[_Filter] = (),
+        description: str = "",
+        id: str | None = None,
+        default: object | None = None,
+        widget: _Widget[Self] | None = None,
+        render_kw: dict[str, Any] | None = None,
+        name: str | None = None,
+        _form: BaseForm | None = None,
+        _prefix: str = "",
+        _translations: _SupportsGettextAndNgettext | None = None,
+        _meta: DefaultMeta | None = None,
+    ) -> None: ...
+    def __html__(self) -> str: ...
+    def __call__(self, **kwargs: object) -> Markup: ...
+    @classmethod
+    def check_validators(cls, validators: Iterable[_Validator[_FormT, Self]] | None) -> None: ...
+    def gettext(self, string: str) -> str: ...
+    def ngettext(self, singular: str, plural: str, n: int) -> str: ...
+    def validate(self, form: BaseForm, extra_validators: tuple[_Validator[_FormT, Self], ...] | list[Any] = ()) -> bool: ...
+    def pre_validate(self, form: BaseForm) -> None: ...
+    def post_validate(self, form: BaseForm, validation_stopped: bool) -> None: ...
+    def process(
+        self, formdata: _MultiDictLikeWithGetlist | None, data: Any = ..., extra_filters: Sequence[_Filter] | None = None
+    ) -> None: ...
+    def process_data(self, value: Any) -> None: ...
+    def process_formdata(self, valuelist: list[Any]) -> None: ...
+    def populate_obj(self, obj: object, name: str) -> None: ...
+
+    # this is a workaround for what is essentially illegal in static type checking
+    # Field.__new__ would return an UnboundField, unless the _form parameter is
+    # specified. We can't really work around it by making UnboundField a subclass
+    # of Field, since all subclasses of Field still need to return an UnboundField
+    # and we can't expect third parties to add a __new__ method to every field
+    # they define...
+    # This workaround only works for Form, not BaseForm, but we take what we can get
+    # BaseForm shouldn't really be used anyways
+    @overload
+    def __get__(self, obj: None, owner: _type[object] | None = None) -> UnboundField[Self]: ...
+    @overload
+    def __get__(self, obj: object, owner: _type[object] | None = None) -> Self: ...
+
+class UnboundField(Generic[_FieldT]):
+    creation_counter: int
+    field_class: type[_FieldT]
+    name: str | None
+    args: tuple[Any, ...]
+    kwargs: dict[str, Any]
+    def __init__(self, field_class: type[_FieldT], *args: object, name: str | None = None, **kwargs: object) -> None: ...
+    def bind(
+        self,
+        form: BaseForm,
+        name: str,
+        prefix: str = "",
+        translations: _SupportsGettextAndNgettext | None = None,
+        **kwargs: object,
+    ) -> _FieldT: ...
+
+class Flags:
+    # the API for this is a bit loosey goosey, the intention probably
+    # was that the values should always be boolean, but __contains__
+    # just returns the same thing as __getattr__ and in the widgets
+    # there are fields that could accept numeric values from Flags
+    def __getattr__(self, name: str) -> Any | None: ...
+    def __setattr__(self, name: str, value: object) -> None: ...
+    def __delattr__(self, name: str) -> None: ...
+    def __contains__(self, name: str) -> Any | None: ...
+
+class Label:
+    field_id: str
+    text: str
+    def __init__(self, field_id: str, text: str) -> None: ...
+    def __html__(self) -> str: ...
+    def __call__(self, text: str | None = None, **kwargs: Any) -> Markup: ...

jaclang/vendor/typeshed/stubs/WTForms/wtforms/fields/datetime.pyi

@@ -0,0 +1,138 @@
+from collections.abc import Callable, Sequence
+from datetime import date, datetime, time
+from typing import Any
+from typing_extensions import Self
+
+from wtforms.fields.core import Field, _Filter, _FormT, _Validator, _Widget
+from wtforms.form import BaseForm
+from wtforms.meta import DefaultMeta, _SupportsGettextAndNgettext
+
+__all__ = ("DateTimeField", "DateField", "TimeField", "MonthField", "DateTimeLocalField", "WeekField")
+
+class DateTimeField(Field):
+    format: list[str]
+    strptime_format: list[str]
+    data: datetime | None
+    default: datetime | Callable[[], datetime] | None
+    def __init__(
+        self,
+        label: str | None = None,
+        validators: tuple[_Validator[_FormT, Self], ...] | list[Any] | None = None,
+        format: str | list[str] = "%Y-%m-%d %H:%M:%S",
+        *,
+        filters: Sequence[_Filter] = (),
+        description: str = "",
+        id: str | None = None,
+        default: datetime | Callable[[], datetime] | None = None,
+        widget: _Widget[Self] | None = None,
+        render_kw: dict[str, Any] | None = None,
+        name: str | None = None,
+        _form: BaseForm | None = None,
+        _prefix: str = "",
+        _translations: _SupportsGettextAndNgettext | None = None,
+        _meta: DefaultMeta | None = None,
+    ) -> None: ...
+
+class DateField(DateTimeField):
+    data: date | None  # type: ignore[assignment]
+    default: date | Callable[[], date] | None  # type: ignore[assignment]
+    def __init__(
+        self,
+        label: str | None = None,
+        validators: tuple[_Validator[_FormT, Self], ...] | list[Any] | None = None,
+        format: str | list[str] = "%Y-%m-%d",
+        *,
+        filters: Sequence[_Filter] = (),
+        description: str = "",
+        id: str | None = None,
+        default: date | Callable[[], date] | None = None,
+        widget: _Widget[Self] | None = None,
+        render_kw: dict[str, Any] | None = None,
+        name: str | None = None,
+        _form: BaseForm | None = None,
+        _prefix: str = "",
+        _translations: _SupportsGettextAndNgettext | None = None,
+        _meta: DefaultMeta | None = None,
+    ) -> None: ...
+
+class TimeField(DateTimeField):
+    data: time | None  # type: ignore[assignment]
+    default: time | Callable[[], time] | None  # type: ignore[assignment]
+    def __init__(
+        self,
+        label: str | None = None,
+        validators: tuple[_Validator[_FormT, Self], ...] | list[Any] | None = None,
+        format: str | list[str] = "%H:%M",
+        *,
+        filters: Sequence[_Filter] = (),
+        description: str = "",
+        id: str | None = None,
+        default: time | Callable[[], time] | None = None,
+        widget: _Widget[Self] | None = None,
+        render_kw: dict[str, Any] | None = None,
+        name: str | None = None,
+        _form: BaseForm | None = None,
+        _prefix: str = "",
+        _translations: _SupportsGettextAndNgettext | None = None,
+        _meta: DefaultMeta | None = None,
+    ) -> None: ...
+
+class MonthField(DateField):
+    def __init__(
+        self,
+        label: str | None = None,
+        validators: tuple[_Validator[_FormT, Self], ...] | list[Any] | None = None,
+        format: str | list[str] = "%Y-%m",
+        *,
+        filters: Sequence[_Filter] = (),
+        description: str = "",
+        id: str | None = None,
+        default: time | Callable[[], time] | None = None,
+        widget: _Widget[Self] | None = None,
+        render_kw: dict[str, Any] | None = None,
+        name: str | None = None,
+        _form: BaseForm | None = None,
+        _prefix: str = "",
+        _translations: _SupportsGettextAndNgettext | None = None,
+        _meta: DefaultMeta | None = None,
+    ) -> None: ...
+
+class WeekField(DateField):
+    def __init__(
+        self,
+        label: str | None = None,
+        validators: tuple[_Validator[_FormT, Self], ...] | list[Any] | None = None,
+        format: str | list[str] = "%Y-W%W",  # only difference is the default value
+        *,
+        filters: Sequence[_Filter] = (),
+        description: str = "",
+        id: str | None = None,
+        default: time | Callable[[], time] | None = None,
+        widget: _Widget[Self] | None = None,
+        render_kw: dict[str, Any] | None = None,
+        name: str | None = None,
+        _form: BaseForm | None = None,
+        _prefix: str = "",
+        _translations: _SupportsGettextAndNgettext | None = None,
+        _meta: DefaultMeta | None = None,
+    ) -> None: ...
+
+class DateTimeLocalField(DateTimeField):
+    def __init__(
+        self,
+        label: str | None = None,
+        validators: tuple[_Validator[_FormT, Self], ...] | list[Any] | None = None,
+        format: str | list[str] = ...,
+        *,
+        filters: Sequence[_Filter] = (),
+        description: str = "",
+        id: str | None = None,
+        default: time | Callable[[], time] | None = None,
+        widget: _Widget[Self] | None = None,
+        render_kw: dict[str, Any] | None = None,
+        name: str | None = None,
+        _form: BaseForm | None = None,
+        _prefix: str = "",
+        _translations: _SupportsGettextAndNgettext | None = None,
+        _meta: DefaultMeta | None = None,
+    ) -> None: ...

jaclang/vendor/typeshed/stubs/WTForms/wtforms/fields/form.pyi

@@ -0,0 +1,40 @@
+from collections.abc import Iterator
+from typing import Any, Generic, TypeVar
+
+from wtforms.fields.core import Field, _Widget
+from wtforms.form import BaseForm, _FormErrors
+from wtforms.meta import DefaultMeta, _SupportsGettextAndNgettext
+
+__all__ = ("FormField",)
+
+_BoundFormT = TypeVar("_BoundFormT", bound=BaseForm)
+
+class FormField(Field, Generic[_BoundFormT]):
+    form_class: type[_BoundFormT]
+    form: _BoundFormT
+    separator: str
+    def __init__(
+        self: FormField[_BoundFormT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        form_class: type[_BoundFormT],
+        label: str | None = None,
+        validators: None = None,
+        separator: str = "-",
+        *,
+        description: str = "",
+        id: str | None = None,
+        default: object | None = None,
+        widget: _Widget[FormField[_BoundFormT]] | None = None,
+        render_kw: dict[str, Any] | None = None,
+        name: str | None = None,
+        _form: BaseForm | None = None,
+        _prefix: str = "",
+        _translations: _SupportsGettextAndNgettext | None = None,
+        _meta: DefaultMeta | None = None,
+    ) -> None: ...
+    def __iter__(self) -> Iterator[Field]: ...
+    def __getitem__(self, name: str) -> Field: ...
+    def __getattr__(self, name: str) -> Field: ...
+    @property
+    def data(self) -> dict[str, Any]: ...
+    @property
+    def errors(self) -> _FormErrors: ...  # type: ignore[override]