jaclang 0.6.1__py3-none-any.whl → 0.6.5__py3-none-any.whl

jaclang/vendor/mypy/plugins/dataclasses.py

@@ -24,6 +24,7 @@ from mypy.nodes import (
     Context,
     DataclassTransformSpec,
     Decorator,
+    EllipsisExpr,
     Expression,
     FuncDef,
     FuncItem,
@@ -41,11 +42,7 @@ from mypy.nodes import (
     TypeVarExpr,
     Var,
 )
-from mypy.plugin import (
-    ClassDefContext,
-    FunctionSigContext,
-    SemanticAnalyzerPluginInterface,
-)
+from mypy.plugin import ClassDefContext, FunctionSigContext, SemanticAnalyzerPluginInterface
 from mypy.plugins.common import (
     _get_callee_type,
     _get_decorator_bool_argument,
@@ -53,10 +50,7 @@ from mypy.plugins.common import (
     add_method_to_class,
     deserialize_and_fixup_type,
 )
-from mypy.semanal_shared import (
-    find_dataclass_transform_spec,
-    require_bool_literal_argument,
-)
+from mypy.semanal_shared import find_dataclass_transform_spec, require_bool_literal_argument
 from mypy.server.trigger import make_wildcard_trigger
 from mypy.state import state
 from mypy.typeops import map_type_from_supertype, try_getting_literals_from_type
@@ -127,10 +121,7 @@ class DataclassAttribute:
         self._api = api
 
     def to_argument(
-        self,
-        current_info: TypeInfo,
-        *,
-        of: Literal["__init__", "replace", "__post_init__"],
+        self, current_info: TypeInfo, *, of: Literal["__init__", "replace", "__post_init__"]
     ) -> Argument:
         if of == "__init__":
             arg_kind = ARG_POS
@@ -141,11 +132,7 @@ class DataclassAttribute:
             elif not self.kw_only and self.has_default:
                 arg_kind = ARG_OPT
         elif of == "replace":
-            arg_kind = (
-                ARG_NAMED
-                if self.is_init_var and not self.has_default
-                else ARG_NAMED_OPT
-            )
+            arg_kind = ARG_NAMED if self.is_init_var and not self.has_default else ARG_NAMED_OPT
         elif of == "__post_init__":
             # We always use `ARG_POS` without a default value, because it is practical.
             # Consider this case:
@@ -163,13 +150,13 @@ class DataclassAttribute:
         return Argument(
             variable=self.to_var(current_info),
             type_annotation=self.expand_type(current_info),
-            initializer=None,
+            initializer=EllipsisExpr() if self.has_default else None,  # Only used by stubgen
             kind=arg_kind,
         )
 
     def expand_type(self, current_info: TypeInfo) -> Type | None:
         if self.type is not None and self.info.self_type is not None:
-            # In general, it is not safe to call `expand_type()` during semantic analyzis,
+            # In general, it is not safe to call `expand_type()` during semantic analysis,
             # however this plugin is called very late, so all types should be fully ready.
             # Also, it is tricky to avoid eager expansion of Self types here (e.g. because
             # we serialize attributes).
@@ -266,9 +253,7 @@ class DataclassTransformer:
         # then the object default __init__ with an empty signature will be present anyway.
         if (
             decorator_arguments["init"]
-            and (
-                "__init__" not in info.names or info.names["__init__"].plugin_generated
-            )
+            and ("__init__" not in info.names or info.names["__init__"].plugin_generated)
             and attributes
         ):
             args = [
@@ -285,13 +270,17 @@ class DataclassTransformer:
                     if arg.kind == ARG_POS:
                         arg.kind = ARG_OPT
 
-                nameless_var = Var("")
+                existing_args_names = {arg.variable.name for arg in args}
+                gen_args_name = "generated_args"
+                while gen_args_name in existing_args_names:
+                    gen_args_name += "_"
+                gen_kwargs_name = "generated_kwargs"
+                while gen_kwargs_name in existing_args_names:
+                    gen_kwargs_name += "_"
                 args = [
-                    Argument(nameless_var, AnyType(TypeOfAny.explicit), None, ARG_STAR),
+                    Argument(Var(gen_args_name), AnyType(TypeOfAny.explicit), None, ARG_STAR),
                     *args,
-                    Argument(
-                        nameless_var, AnyType(TypeOfAny.explicit), None, ARG_STAR2
-                    ),
+                    Argument(Var(gen_kwargs_name), AnyType(TypeOfAny.explicit), None, ARG_STAR2),
                 ]
 
             add_method_to_class(
@@ -333,9 +322,7 @@ class DataclassTransformer:
                 )
                 order_return_type = self._api.named_type("builtins.bool")
                 order_args = [
-                    Argument(
-                        Var("other", order_tvar_def), order_tvar_def, None, ARG_POS
-                    )
+                    Argument(Var("other", order_tvar_def), order_tvar_def, None, ARG_POS)
                 ]
 
                 existing_method = info.get(method_name)
@@ -368,16 +355,12 @@ class DataclassTransformer:
 
         if decorator_arguments["frozen"]:
             if any(not parent["frozen"] for parent in parent_decorator_arguments):
-                self._api.fail(
-                    "Cannot inherit frozen dataclass from a non-frozen one", info
-                )
+                self._api.fail("Cannot inherit frozen dataclass from a non-frozen one", info)
             self._propertize_callables(attributes, settable=False)
             self._freeze(attributes)
         else:
             if any(parent["frozen"] for parent in parent_decorator_arguments):
-                self._api.fail(
-                    "Cannot inherit non-frozen dataclass from a frozen one", info
-                )
+                self._api.fail("Cannot inherit non-frozen dataclass from a frozen one", info)
             self._propertize_callables(attributes)
 
         if decorator_arguments["slots"]:
@@ -388,23 +371,16 @@ class DataclassTransformer:
         if (
             decorator_arguments["match_args"]
             and (
-                "__match_args__" not in info.names
-                or info.names["__match_args__"].plugin_generated
+                "__match_args__" not in info.names or info.names["__match_args__"].plugin_generated
             )
             and py_version >= (3, 10)
         ):
             str_type = self._api.named_type("builtins.str")
             literals: list[Type] = [
-                LiteralType(attr.name, str_type)
-                for attr in attributes
-                if attr.is_in_init
+                LiteralType(attr.name, str_type) for attr in attributes if attr.is_in_init
             ]
-            match_args_type = TupleType(
-                literals, self._api.named_type("builtins.tuple")
-            )
-            add_attribute_to_class(
-                self._api, self._cls, "__match_args__", match_args_type
-            )
+            match_args_type = TupleType(literals, self._api.named_type("builtins.tuple"))
+            add_attribute_to_class(self._api, self._cls, "__match_args__", match_args_type)
 
         self._add_dataclass_fields_magic_attribute()
         self._add_internal_replace_method(attributes)
@@ -418,9 +394,7 @@ class DataclassTransformer:
 
         return True
 
-    def _add_internal_replace_method(
-        self, attributes: list[DataclassAttribute]
-    ) -> None:
+    def _add_internal_replace_method(self, attributes: list[DataclassAttribute]) -> None:
         """
         Stashes the signature of 'dataclasses.replace(...)' for this specific dataclass
         to be used later whenever 'dataclasses.replace' is called for this dataclass.
@@ -429,16 +403,12 @@ class DataclassTransformer:
             self._api,
             self._cls,
             _INTERNAL_REPLACE_SYM_NAME,
-            args=[
-                attr.to_argument(self._cls.info, of="replace") for attr in attributes
-            ],
+            args=[attr.to_argument(self._cls.info, of="replace") for attr in attributes],
             return_type=NoneType(),
             is_staticmethod=True,
         )
 
-    def _add_internal_post_init_method(
-        self, attributes: list[DataclassAttribute]
-    ) -> None:
+    def _add_internal_post_init_method(self, attributes: list[DataclassAttribute]) -> None:
         add_method_to_class(
             self._api,
             self._cls,
@@ -452,11 +422,7 @@ class DataclassTransformer:
         )
 
     def add_slots(
-        self,
-        info: TypeInfo,
-        attributes: list[DataclassAttribute],
-        *,
-        correct_version: bool,
+        self, info: TypeInfo, attributes: list[DataclassAttribute], *, correct_version: bool
     ) -> None:
         if not correct_version:
             # This means that version is lower than `3.10`,
@@ -498,9 +464,7 @@ class DataclassTransformer:
         )
         add_attribute_to_class(self._api, self._cls, "__slots__", slots_type)
 
-    def reset_init_only_vars(
-        self, info: TypeInfo, attributes: list[DataclassAttribute]
-    ) -> None:
+    def reset_init_only_vars(self, info: TypeInfo, attributes: list[DataclassAttribute]) -> None:
         """Remove init-only vars from the class and reset init var declarations."""
         for attr in attributes:
             if attr.is_init_var:
@@ -526,9 +490,7 @@ class DataclassTransformer:
         if stmt.else_body is not None and not stmt.else_body.is_unreachable:
             yield from self._get_assignment_statements_from_block(stmt.else_body)
 
-    def _get_assignment_statements_from_block(
-        self, block: Block
-    ) -> Iterator[AssignmentStmt]:
+    def _get_assignment_statements_from_block(self, block: Block) -> Iterator[AssignmentStmt]:
         for stmt in block.body:
             if isinstance(stmt, AssignmentStmt):
                 yield stmt
@@ -614,9 +576,7 @@ class DataclassTransformer:
 
             if isinstance(node, TypeAlias):
                 self._api.fail(
-                    (
-                        "Type aliases inside dataclass definitions are not supported at runtime"
-                    ),
+                    ("Type aliases inside dataclass definitions are not supported at runtime"),
                     node,
                 )
                 # Skip processing this node. This doesn't match the runtime behaviour,
@@ -651,9 +611,7 @@ class DataclassTransformer:
 
             is_in_init_param = field_args.get("init")
             if is_in_init_param is None:
-                is_in_init = self._get_default_init_value_for_field_specifier(
-                    stmt.rvalue
-                )
+                is_in_init = self._get_default_init_value_for_field_specifier(stmt.rvalue)
             else:
                 is_in_init = bool(self._api.parse_bool(is_in_init_param))
 
@@ -689,9 +647,7 @@ class DataclassTransformer:
                 if value is not None:
                     is_kw_only = value
                 else:
-                    self._api.fail(
-                        '"kw_only" argument must be a boolean literal', stmt.rvalue
-                    )
+                    self._api.fail('"kw_only" argument must be a boolean literal', stmt.rvalue)
 
             if sym.type is None and node.is_final and node.is_inferred:
                 # This is a special case, assignment like x: Final = 42 is classified
@@ -752,20 +708,14 @@ class DataclassTransformer:
             # If we find any attribute that is_in_init, not kw_only, and that
             # doesn't have a default after one that does have one,
             # then that's an error.
-            if (
-                found_default
-                and attr.is_in_init
-                and not attr.has_default
-                and not attr.kw_only
-            ):
+            if found_default and attr.is_in_init and not attr.has_default and not attr.kw_only:
                 # If the issue comes from merging different classes, report it
                 # at the class definition point.
                 context: Context = cls
                 if attr.name in current_attr_names:
                     context = Context(line=attr.line, column=attr.column)
                 self._api.fail(
-                    "Attributes without a default cannot follow attributes with one",
-                    context,
+                    "Attributes without a default cannot follow attributes with one", context
                 )
 
             found_default = found_default or (attr.has_default and attr.is_in_init)
@@ -774,8 +724,7 @@ class DataclassTransformer:
                 if attr.name in current_attr_names:
                     context = Context(line=attr.line, column=attr.column)
                 self._api.fail(
-                    "There may not be more than one field with the KW_ONLY type",
-                    context,
+                    "There may not be more than one field with the KW_ONLY type", context
                 )
             found_kw_sentinel = found_kw_sentinel or self._is_kw_only_type(attr.type)
         return all_attrs
@@ -844,10 +793,7 @@ class DataclassTransformer:
         # In either case, we're aiming to match the Typeshed stub for `is_dataclass`, which expects
         # the instance to have a `__dataclass_fields__` attribute of type `dict[str, Field[Any]]`.
         if self._spec is _TRANSFORM_SPEC_FOR_DATACLASSES:
-            field_type = (
-                self._api.named_type_or_none("dataclasses.Field", [any_type])
-                or any_type
-            )
+            field_type = self._api.named_type_or_none("dataclasses.Field", [any_type]) or any_type
         else:
             field_type = any_type
         attr_type = self._api.named_type(
@@ -861,9 +807,7 @@ class DataclassTransformer:
             kind=MDEF, node=var, plugin_generated=True
         )
 
-    def _collect_field_args(
-        self, expr: Expression
-    ) -> tuple[bool, dict[str, Expression]]:
+    def _collect_field_args(self, expr: Expression) -> tuple[bool, dict[str, Expression]]:
         """Returns a tuple where the first value represents whether or not
         the expression is a call to dataclass.field and the second is a
         dictionary of the keyword arguments that field() was called with.
@@ -973,8 +917,7 @@ class DataclassTransformer:
                     return expand_type_by_instance(setter_type.arg_types[2], t)
                 else:
                     self._api.fail(
-                        f'Unsupported signature for "__set__" in "{t.type.name}"',
-                        context,
+                        f'Unsupported signature for "__set__" in "{t.type.name}"', context
                     )
             else:
                 self._api.fail(f'Unsupported "__set__" in "{t.type.name}"', context)
@@ -1040,10 +983,7 @@ def _has_direct_dataclass_transform_metaclass(info: TypeInfo) -> bool:
 
 
 def _get_expanded_dataclasses_fields(
-    ctx: FunctionSigContext,
-    typ: ProperType,
-    display_typ: ProperType,
-    parent_typ: ProperType,
+    ctx: FunctionSigContext, typ: ProperType, display_typ: ProperType, parent_typ: ProperType
 ) -> list[CallableType] | None:
     """
     For a given type, determine what dataclasses it can be: for each class, return the field types.
@@ -1085,9 +1025,7 @@ def _meet_replace_sigs(sigs: list[CallableType]) -> CallableType:
     """
     args = {
         name: (typ, kind)
-        for name, typ, kind in zip(
-            sigs[0].arg_names, sigs[0].arg_types, sigs[0].arg_kinds
-        )
+        for name, typ, kind in zip(sigs[0].arg_names, sigs[0].arg_types, sigs[0].arg_kinds)
     }
 
     for sig in sigs[1:]:
@@ -1117,10 +1055,7 @@ def replace_function_sig_callback(ctx: FunctionSigContext) -> CallableType:
     """
     if len(ctx.args) != 2:
         # Ideally the name and context should be callee's, but we don't have it in FunctionSigContext.
-        ctx.api.fail(
-            f'"{ctx.default_signature.name}" has unexpected type annotation',
-            ctx.context,
-        )
+        ctx.api.fail(f'"{ctx.default_signature.name}" has unexpected type annotation', ctx.context)
         return ctx.default_signature
 
     if len(ctx.args[0]) != 1:

jaclang/vendor/mypy/plugins/default.py

@@ -40,9 +40,7 @@ from mypy.types import (
 class DefaultPlugin(Plugin):
     """Type checker plugin that is enabled by default."""
 
-    def get_function_hook(
-        self, fullname: str
-    ) -> Callable[[FunctionContext], Type] | None:
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
         from mypy.plugins import ctypes, singledispatch
 
         if fullname == "_ctypes.Array":
@@ -102,6 +100,8 @@ class DefaultPlugin(Plugin):
             return int_pow_callback
         elif fullname == "builtins.int.__neg__":
             return int_neg_callback
+        elif fullname == "builtins.int.__pos__":
+            return int_pos_callback
         elif fullname in ("builtins.tuple.__mul__", "builtins.tuple.__rmul__"):
             return tuple_mul_callback
         elif fullname in {n + ".setdefault" for n in TPDICT_FB_NAMES}:
@@ -120,9 +120,7 @@ class DefaultPlugin(Plugin):
             return singledispatch.call_singledispatch_function_after_register_argument
         return None
 
-    def get_attribute_hook(
-        self, fullname: str
-    ) -> Callable[[AttributeContext], Type] | None:
+    def get_attribute_hook(self, fullname: str) -> Callable[[AttributeContext], Type] | None:
         from mypy.plugins import ctypes, enums
 
         if fullname == "_ctypes.Array.value":
@@ -135,9 +133,7 @@ class DefaultPlugin(Plugin):
             return enums.enum_value_callback
         return None
 
-    def get_class_decorator_hook(
-        self, fullname: str
-    ) -> Callable[[ClassDefContext], None] | None:
+    def get_class_decorator_hook(self, fullname: str) -> Callable[[ClassDefContext], None] | None:
         from mypy.plugins import attrs, dataclasses
 
         # These dataclass and attrs hooks run in the main semantic analysis pass
@@ -171,15 +167,11 @@ class DefaultPlugin(Plugin):
             return partial(attrs.attr_class_maker_callback, auto_attribs_default=True)
         elif fullname in attrs.attr_frozen_makers:
             return partial(
-                attrs.attr_class_maker_callback,
-                auto_attribs_default=None,
-                frozen_default=True,
+                attrs.attr_class_maker_callback, auto_attribs_default=None, frozen_default=True
             )
         elif fullname in attrs.attr_define_makers:
             return partial(
-                attrs.attr_class_maker_callback,
-                auto_attribs_default=None,
-                slots_default=True,
+                attrs.attr_class_maker_callback, auto_attribs_default=None, slots_default=True
             )
 
         return None
@@ -219,10 +211,7 @@ def typed_dict_get_signature_callback(ctx: MethodSigContext) -> CallableType:
             tv = signature.variables[0]
             assert isinstance(tv, TypeVarType)
             return signature.copy_modified(
-                arg_types=[
-                    signature.arg_types[0],
-                    make_simplified_union([value_type, tv]),
-                ],
+                arg_types=[signature.arg_types[0], make_simplified_union([value_type, tv])],
                 ret_type=ret_type,
             )
     return signature
@@ -247,11 +236,7 @@ def typed_dict_get_callback(ctx: MethodContext) -> Type:
 
             if len(ctx.arg_types) == 1:
                 output_types.append(value_type)
-            elif (
-                len(ctx.arg_types) == 2
-                and len(ctx.arg_types[1]) == 1
-                and len(ctx.args[1]) == 1
-            ):
+            elif len(ctx.arg_types) == 2 and len(ctx.arg_types[1]) == 1 and len(ctx.args[1]) == 1:
                 default_arg = ctx.args[1][0]
                 if (
                     isinstance(default_arg, DictExpr)
@@ -331,11 +316,7 @@ def typed_dict_pop_callback(ctx: MethodContext) -> Type:
 
         if len(ctx.args[1]) == 0:
             return make_simplified_union(value_types)
-        elif (
-            len(ctx.arg_types) == 2
-            and len(ctx.arg_types[1]) == 1
-            and len(ctx.args[1]) == 1
-        ):
+        elif len(ctx.arg_types) == 2 and len(ctx.arg_types[1]) == 1 and len(ctx.args[1]) == 1:
             return make_simplified_union([*value_types, ctx.arg_types[1][0]])
     return ctx.default_return_type
 
@@ -476,19 +457,11 @@ def int_pow_callback(ctx: MethodContext) -> Type:
     """Infer a more precise return type for int.__pow__."""
     # int.__pow__ has an optional modulo argument,
     # so we expect 2 argument positions
-    if (
-        len(ctx.arg_types) == 2
-        and len(ctx.arg_types[0]) == 1
-        and len(ctx.arg_types[1]) == 0
-    ):
+    if len(ctx.arg_types) == 2 and len(ctx.arg_types[0]) == 1 and len(ctx.arg_types[1]) == 0:
         arg = ctx.args[0][0]
         if isinstance(arg, IntExpr):
             exponent = arg.value
-        elif (
-            isinstance(arg, UnaryExpr)
-            and arg.op == "-"
-            and isinstance(arg.expr, IntExpr)
-        ):
+        elif isinstance(arg, UnaryExpr) and arg.op == "-" and isinstance(arg.expr, IntExpr):
             exponent = -arg.expr.value
         else:
             # Right operand not an int literal or a negated literal -- give up.
@@ -500,22 +473,22 @@ def int_pow_callback(ctx: MethodContext) -> Type:
     return ctx.default_return_type
 
 
-def int_neg_callback(ctx: MethodContext) -> Type:
-    """Infer a more precise return type for int.__neg__.
+def int_neg_callback(ctx: MethodContext, multiplier: int = -1) -> Type:
+    """Infer a more precise return type for int.__neg__ and int.__pos__.
 
     This is mainly used to infer the return type as LiteralType
-    if the original underlying object is a LiteralType object
+    if the original underlying object is a LiteralType object.
     """
     if isinstance(ctx.type, Instance) and ctx.type.last_known_value is not None:
         value = ctx.type.last_known_value.value
         fallback = ctx.type.last_known_value.fallback
         if isinstance(value, int):
             if is_literal_type_like(ctx.api.type_context[-1]):
-                return LiteralType(value=-value, fallback=fallback)
+                return LiteralType(value=multiplier * value, fallback=fallback)
             else:
                 return ctx.type.copy_modified(
                     last_known_value=LiteralType(
-                        value=-value,
+                        value=multiplier * value,
                         fallback=ctx.type,
                         line=ctx.type.line,
                         column=ctx.type.column,
@@ -525,10 +498,18 @@ def int_neg_callback(ctx: MethodContext) -> Type:
         value = ctx.type.value
         fallback = ctx.type.fallback
         if isinstance(value, int):
-            return LiteralType(value=-value, fallback=fallback)
+            return LiteralType(value=multiplier * value, fallback=fallback)
     return ctx.default_return_type
 
 
+def int_pos_callback(ctx: MethodContext) -> Type:
+    """Infer a more precise return type for int.__pos__.
+
+    This is identical to __neg__, except the value is not inverted.
+    """
+    return int_neg_callback(ctx, +1)
+
+
 def tuple_mul_callback(ctx: MethodContext) -> Type:
     """Infer a more precise return type for tuple.__mul__ and tuple.__rmul__.
 

jaclang/vendor/mypy/plugins/enums.py

@@ -20,14 +20,7 @@ from mypy.nodes import TypeInfo
 from mypy.semanal_enum import ENUM_BASES
 from mypy.subtypes import is_equivalent
 from mypy.typeops import fixup_partial_type, make_simplified_union
-from mypy.types import (
-    CallableType,
-    Instance,
-    LiteralType,
-    ProperType,
-    Type,
-    get_proper_type,
-)
+from mypy.types import CallableType, Instance, LiteralType, ProperType, Type, get_proper_type
 
 ENUM_NAME_ACCESS: Final = {f"{prefix}.name" for prefix in ENUM_BASES} | {
     f"{prefix}._name_" for prefix in ENUM_BASES
@@ -85,9 +78,7 @@ def _infer_value_type_with_auto_fallback(
     if proper_type is None:
         return None
     proper_type = get_proper_type(fixup_partial_type(proper_type))
-    if not (
-        isinstance(proper_type, Instance) and proper_type.type.fullname == "enum.auto"
-    ):
+    if not (isinstance(proper_type, Instance) and proper_type.type.fullname == "enum.auto"):
         return proper_type
     assert isinstance(ctx.type, Instance), "An incorrect ctx.type was passed."
     info = ctx.type.type
@@ -96,9 +87,7 @@ def _infer_value_type_with_auto_fallback(
     # `_generate_next_value_` is `Any`.  In reality the default `auto()`
     # returns an `int` (presumably the `Any` in typeshed is to make it
     # easier to subclass and change the returned type).
-    type_with_gnv = _first(
-        ti for ti in info.mro if ti.names.get("_generate_next_value_")
-    )
+    type_with_gnv = _first(ti for ti in info.mro if ti.names.get("_generate_next_value_"))
     if type_with_gnv is None:
         return ctx.default_attr_type
 
@@ -234,9 +223,7 @@ def enum_value_callback(ctx: mypy.plugin.AttributeContext) -> Type:
     if stnode is None:
         return ctx.default_attr_type
 
-    underlying_type = _infer_value_type_with_auto_fallback(
-        ctx, get_proper_type(stnode.type)
-    )
+    underlying_type = _infer_value_type_with_auto_fallback(ctx, get_proper_type(stnode.type))
     if underlying_type is None:
         return ctx.default_attr_type
 

jaclang/vendor/mypy/plugins/functools.py

@@ -7,14 +7,7 @@ from typing import Final, NamedTuple
 import mypy.plugin
 from mypy.nodes import ARG_POS, ARG_STAR2, Argument, FuncItem, Var
 from mypy.plugins.common import add_method_to_class
-from mypy.types import (
-    AnyType,
-    CallableType,
-    Type,
-    TypeOfAny,
-    UnboundType,
-    get_proper_type,
-)
+from mypy.types import AnyType, CallableType, Type, TypeOfAny, UnboundType, get_proper_type
 
 functools_total_ordering_makers: Final = {"functools.total_ordering"}
 
@@ -103,9 +96,7 @@ def _analyze_class(ctx: mypy.plugin.ClassDefContext) -> dict[str, _MethodInfo |
                 if isinstance(node, Var):
                     proper_type = get_proper_type(node.type)
                     if isinstance(proper_type, CallableType):
-                        comparison_methods[name] = _MethodInfo(
-                            node.is_staticmethod, proper_type
-                        )
+                        comparison_methods[name] = _MethodInfo(node.is_staticmethod, proper_type)
                         continue
 
                 comparison_methods[name] = None

jaclang/vendor/mypy/plugins/proper_plugin.py

@@ -42,9 +42,7 @@ class ProperTypePlugin(Plugin):
     all these became dangerous because typ may be e.g. an alias to union.
     """
 
-    def get_function_hook(
-        self, fullname: str
-    ) -> Callable[[FunctionContext], Type] | None:
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
         if fullname == "builtins.isinstance":
             return isinstance_proper_hook
         if fullname == "mypy.types.get_proper_type":
@@ -122,9 +120,7 @@ def is_improper_type(typ: Type) -> bool:
     typ = get_proper_type(typ)
     if isinstance(typ, Instance):
         info = typ.type
-        return info.has_base("mypy.types.Type") and not info.has_base(
-            "mypy.types.ProperType"
-        )
+        return info.has_base("mypy.types.Type") and not info.has_base("mypy.types.ProperType")
     if isinstance(typ, UnionType):
         return any(is_improper_type(t) for t in typ.items)
     return False