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

jaclang/vendor/mypy/semanal_classprop.py

@@ -39,9 +39,7 @@ TYPE_PROMOTIONS: Final = {
 }
 
 
-def calculate_class_abstract_status(
-    typ: TypeInfo, is_stub_file: bool, errors: Errors
-) -> None:
+def calculate_class_abstract_status(typ: TypeInfo, is_stub_file: bool, errors: Errors) -> None:
     """Calculate abstract status of a class.
 
     Set is_abstract of the type to True if the type has an unimplemented
@@ -98,9 +96,7 @@ def calculate_class_abstract_status(
     # implement some methods.
     typ.abstract_attributes = sorted(abstract)
     if is_stub_file:
-        if typ.declared_metaclass and typ.declared_metaclass.type.has_base(
-            "abc.ABCMeta"
-        ):
+        if typ.declared_metaclass and typ.declared_metaclass.type.has_base("abc.ABCMeta"):
             return
         if typ.is_protocol:
             return
@@ -112,15 +108,12 @@ def calculate_class_abstract_status(
             attrs = ", ".join(f'"{attr}"' for attr, _ in sorted(abstract))
             report(f"Class {typ.fullname} has abstract attributes {attrs}", "error")
             report(
-                "If it is meant to be abstract, add 'abc.ABCMeta' as an explicit metaclass",
-                "note",
+                "If it is meant to be abstract, add 'abc.ABCMeta' as an explicit metaclass", "note"
             )
     if typ.is_final and abstract:
         attrs = ", ".join(f'"{attr}"' for attr, _ in sorted(abstract))
         errors.report(
-            typ.line,
-            typ.column,
-            f"Final class {typ.fullname} has abstract attributes {attrs}",
+            typ.line, typ.column, f"Final class {typ.fullname} has abstract attributes {attrs}"
         )
 
 
@@ -148,27 +141,15 @@ def calculate_class_vars(info: TypeInfo) -> None:
     """
     for name, sym in info.names.items():
         node = sym.node
-        if (
-            isinstance(node, Var)
-            and node.info
-            and node.is_inferred
-            and not node.is_classvar
-        ):
+        if isinstance(node, Var) and node.info and node.is_inferred and not node.is_classvar:
             for base in info.mro[1:]:
                 member = base.names.get(name)
-                if (
-                    member is not None
-                    and isinstance(member.node, Var)
-                    and member.node.is_classvar
-                ):
+                if member is not None and isinstance(member.node, Var) and member.node.is_classvar:
                     node.is_classvar = True
 
 
 def add_type_promotion(
-    info: TypeInfo,
-    module_names: SymbolTable,
-    options: Options,
-    builtin_names: SymbolTable,
+    info: TypeInfo, module_names: SymbolTable, options: Options, builtin_names: SymbolTable
 ) -> None:
     """Setup extra, ad-hoc subtyping relationships between classes (promotion).
 
@@ -185,15 +166,9 @@ def add_type_promotion(
     if not promote_targets:
         if defn.fullname in TYPE_PROMOTIONS:
             target_sym = module_names.get(TYPE_PROMOTIONS[defn.fullname])
-            if (
-                defn.fullname == "builtins.bytearray"
-                and options.disable_bytearray_promotion
-            ):
+            if defn.fullname == "builtins.bytearray" and options.disable_bytearray_promotion:
                 target_sym = None
-            elif (
-                defn.fullname == "builtins.memoryview"
-                and options.disable_memoryview_promotion
-            ):
+            elif defn.fullname == "builtins.memoryview" and options.disable_memoryview_promotion:
                 target_sym = None
             # With test stubs, the target may not exist.
             if target_sym:

jaclang/vendor/mypy/semanal_enum.py

@@ -149,23 +149,15 @@ class EnumCallAnalyzer:
         """
         args = call.args
         if not all(arg_kind in [ARG_POS, ARG_NAMED] for arg_kind in call.arg_kinds):
-            return self.fail_enum_call_arg(
-                f"Unexpected arguments to {class_name}()", call
-            )
+            return self.fail_enum_call_arg(f"Unexpected arguments to {class_name}()", call)
         if len(args) < 2:
-            return self.fail_enum_call_arg(
-                f"Too few arguments for {class_name}()", call
-            )
+            return self.fail_enum_call_arg(f"Too few arguments for {class_name}()", call)
         if len(args) > 6:
-            return self.fail_enum_call_arg(
-                f"Too many arguments for {class_name}()", call
-            )
+            return self.fail_enum_call_arg(f"Too many arguments for {class_name}()", call)
         valid_name = [None, "value", "names", "module", "qualname", "type", "start"]
         for arg_name in call.arg_names:
             if arg_name not in valid_name:
-                self.fail_enum_call_arg(
-                    f'Unexpected keyword argument "{arg_name}"', call
-                )
+                self.fail_enum_call_arg(f'Unexpected keyword argument "{arg_name}"', call)
         value, names = None, None
         for arg_name, arg in zip(call.arg_names, args):
             if arg_name == "value":
@@ -204,16 +196,14 @@ class EnumCallAnalyzer:
                     values.append(value)
             else:
                 return self.fail_enum_call_arg(
-                    "%s() with tuple or list expects strings or (name, value) pairs"
-                    % class_name,
+                    "%s() with tuple or list expects strings or (name, value) pairs" % class_name,
                     call,
                 )
         elif isinstance(names, DictExpr):
             for key, value in names.items:
                 if not isinstance(key, StrExpr):
                     return self.fail_enum_call_arg(
-                        f"{class_name}() with dict literal requires string literals",
-                        call,
+                        f"{class_name}() with dict literal requires string literals", call
                     )
                 items.append(key.value)
                 values.append(value)
@@ -245,9 +235,7 @@ class EnumCallAnalyzer:
                 call,
             )
         if not items:
-            return self.fail_enum_call_arg(
-                f"{class_name}() needs at least one item", call
-            )
+            return self.fail_enum_call_arg(f"{class_name}() needs at least one item", call)
         if not values:
             values = [None] * len(items)
         assert len(items) == len(values)

jaclang/vendor/mypy/semanal_infer.py

@@ -75,9 +75,7 @@ def is_identity_signature(sig: Type) -> bool:
     """Is type a callable of form T -> T (where T is a type variable)?"""
     sig = get_proper_type(sig)
     if isinstance(sig, CallableType) and sig.arg_kinds == [ARG_POS]:
-        if isinstance(sig.arg_types[0], TypeVarType) and isinstance(
-            sig.ret_type, TypeVarType
-        ):
+        if isinstance(sig.arg_types[0], TypeVarType) and isinstance(sig.ret_type, TypeVarType):
             return sig.arg_types[0].id == sig.ret_type.id
     return False
 

jaclang/vendor/mypy/semanal_main.py

@@ -119,10 +119,7 @@ def cleanup_builtin_scc(state: State) -> None:
 
 
 def semantic_analysis_for_targets(
-    state: State,
-    nodes: list[FineGrainedDeferredNode],
-    graph: Graph,
-    saved_attrs: SavedAttributes,
+    state: State, nodes: list[FineGrainedDeferredNode], graph: Graph, saved_attrs: SavedAttributes
 ) -> None:
     """Semantically analyze only selected nodes in a given module.
 
@@ -145,13 +142,7 @@ def semantic_analysis_for_targets(
             # Already done above.
             continue
         process_top_level_function(
-            analyzer,
-            state,
-            state.id,
-            n.node.fullname,
-            n.node,
-            n.active_typeinfo,
-            patches,
+            analyzer, state, state.id, n.node.fullname, n.node, n.active_typeinfo, patches
         )
     apply_semantic_analyzer_patches(patches)
     apply_class_plugin_hooks(graph, [state.id], state.manager.errors)
@@ -417,11 +408,7 @@ def check_type_arguments_in_targets(
                 func: FuncDef | OverloadedFuncDef | None = None
                 if isinstance(target.node, (FuncDef, OverloadedFuncDef)):
                     func = target.node
-                saved = (
-                    state.id,
-                    target.active_typeinfo,
-                    func,
-                )  # module, class, function
+                saved = (state.id, target.active_typeinfo, func)  # module, class, function
                 with errors.scope.saved_scope(saved) if errors.scope else nullcontext():
                     analyzer.recurse_into_functions = func is not None
                     target.node.accept(analyzer)
@@ -496,12 +483,7 @@ def apply_hooks_to_class(
         with self.file_context(file_node, options, info):
             # We can't use the normal hook because reason = defn, and ClassDefContext only accepts
             # an Expression for reason
-            ok = (
-                ok
-                and dataclasses_plugin.DataclassTransformer(
-                    defn, defn, spec, self
-                ).transform()
-            )
+            ok = ok and dataclasses_plugin.DataclassTransformer(defn, defn, spec, self).transform()
 
     return ok
 
@@ -515,9 +497,7 @@ def calculate_class_properties(graph: Graph, scc: list[str], errors: Errors) ->
         assert tree
         for _, node, _ in tree.local_definitions():
             if isinstance(node.node, TypeInfo):
-                with state.manager.semantic_analyzer.file_context(
-                    tree, state.options, node.node
-                ):
+                with state.manager.semantic_analyzer.file_context(tree, state.options, node.node):
                     calculate_class_abstract_status(node.node, tree.is_stub, errors)
                     check_protocol_status(node.node, errors)
                     calculate_class_vars(node.node)

jaclang/vendor/mypy/semanal_namedtuple.py

@@ -157,8 +157,7 @@ class NamedTupleAnalyzer:
             if not isinstance(stmt, AssignmentStmt):
                 # Still allow pass or ... (for empty namedtuples).
                 if isinstance(stmt, PassStmt) or (
-                    isinstance(stmt, ExpressionStmt)
-                    and isinstance(stmt.expr, EllipsisExpr)
+                    isinstance(stmt, ExpressionStmt) and isinstance(stmt.expr, EllipsisExpr)
                 ):
                     continue
                 # Also allow methods, including decorated ones.
@@ -197,30 +196,22 @@ class NamedTupleAnalyzer:
                 # ...despite possible minor failures that allow further analyzis.
                 if name.startswith("_"):
                     self.fail(
-                        f"NamedTuple field name cannot start with an underscore: {name}",
-                        stmt,
+                        f"NamedTuple field name cannot start with an underscore: {name}", stmt
                     )
-                if (
-                    stmt.type is None
-                    or hasattr(stmt, "new_syntax")
-                    and not stmt.new_syntax
-                ):
+                if stmt.type is None or hasattr(stmt, "new_syntax") and not stmt.new_syntax:
                     self.fail(NAMEDTUP_CLASS_ERROR, stmt)
                 elif isinstance(stmt.rvalue, TempNode):
                     # x: int assigns rvalue to TempNode(AnyType())
                     if default_items:
                         self.fail(
-                            "Non-default NamedTuple fields cannot follow default fields",
-                            stmt,
+                            "Non-default NamedTuple fields cannot follow default fields", stmt
                         )
                 else:
                     default_items[name] = stmt.rvalue
         if defn.keywords:
             for_function = ' for "__init_subclass__" of "NamedTuple"'
             for key in defn.keywords:
-                self.msg.unexpected_keyword_argument_for_function(
-                    for_function, key, defn
-                )
+                self.msg.unexpected_keyword_argument_for_function(for_function, key, defn)
         return items, types, default_items, statements
 
     def check_namedtuple(
@@ -295,8 +286,7 @@ class NamedTupleAnalyzer:
             name += "@" + str(call.line)
         if defaults:
             default_items = {
-                arg_name: default
-                for arg_name, default in zip(items[-len(defaults) :], defaults)
+                arg_name: default for arg_name, default in zip(items[-len(defaults) :], defaults)
             }
         else:
             default_items = {}
@@ -342,9 +332,7 @@ class NamedTupleAnalyzer:
 
     def parse_namedtuple_args(
         self, call: CallExpr, fullname: str
-    ) -> None | (
-        tuple[list[str], list[Type], list[Expression], str, list[TypeVarLikeType], bool]
-    ):
+    ) -> None | (tuple[list[str], list[Type], list[Expression], str, list[TypeVarLikeType], bool]):
         """Parse a namedtuple() call into data needed to construct a type.
 
         Returns a 6-tuple:
@@ -387,9 +375,7 @@ class NamedTupleAnalyzer:
             self.fail(f'Unexpected arguments to "{type_name}()"', call)
             return None
         if not isinstance(args[0], StrExpr):
-            self.fail(
-                f'"{type_name}()" expects a string literal as the first argument', call
-            )
+            self.fail(f'"{type_name}()" expects a string literal as the first argument', call)
             return None
         typename = args[0].value
         types: list[Type] = []
@@ -464,9 +450,7 @@ class NamedTupleAnalyzer:
                     self.fail('Invalid "NamedTuple()" field name', item)
                     return None
                 try:
-                    type = expr_to_unanalyzed_type(
-                        type_node, self.options, self.api.is_stub_file
-                    )
+                    type = expr_to_unanalyzed_type(type_node, self.options, self.api.is_stub_file)
                 except TypeTranslationError:
                     self.fail("Invalid field type", type_node)
                     return None
@@ -517,10 +501,7 @@ class NamedTupleAnalyzer:
         tuple_base = TupleType(types, fallback)
         if info.special_alias and has_placeholder(info.special_alias.target):
             self.api.process_placeholder(
-                None,
-                "NamedTuple item",
-                info,
-                force_progress=tuple_base != info.tuple_type,
+                None, "NamedTuple item", info, force_progress=tuple_base != info.tuple_type
             )
         info.update_tuple_type(tuple_base)
         info.line = line
@@ -561,9 +542,7 @@ class NamedTupleAnalyzer:
         add_field(Var("__annotations__", ordereddictype), is_initialized_in_class=True)
         add_field(Var("__doc__", strtype), is_initialized_in_class=True)
         if self.options.python_version >= (3, 10):
-            add_field(
-                Var("__match_args__", match_args_type), is_initialized_in_class=True
-            )
+            add_field(Var("__match_args__", match_args_type), is_initialized_in_class=True)
 
         assert info.tuple_type is not None  # Set by update_tuple_type() above.
         tvd = TypeVarType(
@@ -584,11 +563,7 @@ class NamedTupleAnalyzer:
             is_new: bool = False,
         ) -> None:
             if is_classmethod or is_new:
-                first = [
-                    Argument(
-                        Var("_cls"), TypeType.make_normalized(selftype), None, ARG_POS
-                    )
-                ]
+                first = [Argument(Var("_cls"), TypeType.make_normalized(selftype), None, ARG_POS)]
             else:
                 first = [Argument(Var("_self"), selftype, None, ARG_POS)]
             args = first + args
@@ -597,9 +572,7 @@ class NamedTupleAnalyzer:
             items = [arg.variable.name for arg in args]
             arg_kinds = [arg.kind for arg in args]
             assert None not in types
-            signature = CallableType(
-                cast(List[Type], types), arg_kinds, items, ret, function_type
-            )
+            signature = CallableType(cast(List[Type], types), arg_kinds, items, ret, function_type)
             signature.variables = [tvd]
             func = FuncDef(funcname, args, Block([]))
             func.info = info
@@ -624,9 +597,7 @@ class NamedTupleAnalyzer:
         add_method(
             "_replace",
             ret=selftype,
-            args=[
-                Argument(var, var.type, EllipsisExpr(), ARG_NAMED_OPT) for var in vars
-            ],
+            args=[Argument(var, var.type, EllipsisExpr(), ARG_NAMED_OPT) for var in vars],
         )
 
         def make_init_arg(var: Var) -> Argument:
@@ -634,20 +605,13 @@ class NamedTupleAnalyzer:
             kind = ARG_POS if default is None else ARG_OPT
             return Argument(var, var.type, default, kind)
 
-        add_method(
-            "__new__",
-            ret=selftype,
-            args=[make_init_arg(var) for var in vars],
-            is_new=True,
-        )
+        add_method("__new__", ret=selftype, args=[make_init_arg(var) for var in vars], is_new=True)
         add_method("_asdict", args=[], ret=ordereddictype)
         add_method(
             "_make",
             ret=selftype,
             is_classmethod=True,
-            args=[
-                Argument(Var("iterable", iterable_type), iterable_type, None, ARG_POS)
-            ],
+            args=[Argument(Var("iterable", iterable_type), iterable_type, None, ARG_POS)],
         )
 
         self_tvar_expr = TypeVarExpr(
@@ -691,10 +655,7 @@ class NamedTupleAnalyzer:
                 if key == "__doc__":
                     continue
                 sym = named_tuple_info.names[key]
-                if (
-                    isinstance(sym.node, (FuncBase, Decorator))
-                    and not sym.plugin_generated
-                ):
+                if isinstance(sym.node, (FuncBase, Decorator)) and not sym.plugin_generated:
                     # Keep user-defined methods as is.
                     continue
                 # Keep existing (user-provided) definitions under mangled names, so they

jaclang/vendor/mypy/semanal_newtype.py

@@ -72,11 +72,7 @@ class NewTypeAnalyzer:
             name += "@" + str(s.line)
         fullname = self.api.qualified_name(name)
 
-        if (
-            not call.analyzed
-            or isinstance(call.analyzed, NewTypeExpr)
-            and not call.analyzed.info
-        ):
+        if not call.analyzed or isinstance(call.analyzed, NewTypeExpr) and not call.analyzed.info:
             # Start from labeling this as a future class, as we do for normal ClassDefs.
             placeholder = PlaceholderNode(fullname, s, s.line, becomes_typeinfo=True)
             self.api.add_symbol(var_name, placeholder, s, can_defer=False)
@@ -84,9 +80,7 @@ class NewTypeAnalyzer:
         old_type, should_defer = self.check_newtype_args(var_name, call, s)
         old_type = get_proper_type(old_type)
         if not isinstance(call.analyzed, NewTypeExpr):
-            call.analyzed = NewTypeExpr(
-                var_name, old_type, line=call.line, column=call.column
-            )
+            call.analyzed = NewTypeExpr(var_name, old_type, line=call.line, column=call.column)
         else:
             call.analyzed.old_type = old_type
         if old_type is None:
@@ -128,12 +122,8 @@ class NewTypeAnalyzer:
             old_type, self.options, self.api.is_typeshed_stub_file, self.msg, context=s
         )
 
-        if self.options.disallow_any_unimported and has_any_from_unimported_type(
-            old_type
-        ):
-            self.msg.unimported_type_becomes_any(
-                "Argument 2 to NewType(...)", old_type, s
-            )
+        if self.options.disallow_any_unimported and has_any_from_unimported_type(old_type):
+            self.msg.unimported_type_becomes_any("Argument 2 to NewType(...)", old_type, s)
 
         # If so, add it to the symbol table.
         assert isinstance(call.analyzed, NewTypeExpr)
@@ -149,9 +139,7 @@ class NewTypeAnalyzer:
         newtype_class_info.line = s.line
         return True
 
-    def analyze_newtype_declaration(
-        self, s: AssignmentStmt
-    ) -> tuple[str | None, CallExpr | None]:
+    def analyze_newtype_declaration(self, s: AssignmentStmt) -> tuple[str | None, CallExpr | None]:
         """Return the NewType call expression if `s` is a newtype declaration or None otherwise."""
         name, call = None, None
         if (
@@ -159,10 +147,7 @@ class NewTypeAnalyzer:
             and isinstance(s.lvalues[0], NameExpr)
             and isinstance(s.rvalue, CallExpr)
             and isinstance(s.rvalue.callee, RefExpr)
-            and (
-                s.rvalue.callee.fullname
-                in ("typing.NewType", "typing_extensions.NewType")
-            )
+            and (s.rvalue.callee.fullname in ("typing.NewType", "typing_extensions.NewType"))
         ):
             name = s.lvalues[0].name
 
@@ -211,9 +196,7 @@ class NewTypeAnalyzer:
         # Check second argument
         msg = "Argument 2 to NewType(...) must be a valid type"
         try:
-            unanalyzed_type = expr_to_unanalyzed_type(
-                args[1], self.options, self.api.is_stub_file
-            )
+            unanalyzed_type = expr_to_unanalyzed_type(args[1], self.options, self.api.is_stub_file)
         except TypeTranslationError:
             self.fail(msg, context)
             return None, False
@@ -278,9 +261,7 @@ class NewTypeAnalyzer:
         info.names["__init__"] = SymbolTableNode(MDEF, init_func)
 
         if has_placeholder(old_type):
-            self.api.process_placeholder(
-                None, "NewType base", info, force_progress=updated
-            )
+            self.api.process_placeholder(None, "NewType base", info, force_progress=updated)
         return info
 
     # Helpers

jaclang/vendor/mypy/semanal_pass1.py

@@ -55,9 +55,7 @@ class SemanticAnalyzerPreAnalysis(TraverserVisitor):
     shouldn't be processed in Python 3 mode, even if the module happens to exist.
     """
 
-    def visit_file(
-        self, file: MypyFile, fnam: str, mod_id: str, options: Options
-    ) -> None:
+    def visit_file(self, file: MypyFile, fnam: str, mod_id: str, options: Options) -> None:
         self.platform = options.platform
         self.cur_mod_id = mod_id
         self.cur_mod_node = file
@@ -75,9 +73,7 @@ class SemanticAnalyzerPreAnalysis(TraverserVisitor):
                     next_def, last = file.defs[i + 1], file.defs[-1]
                     if last.end_line is not None:
                         # We are on a Python version recent enough to support end lines.
-                        self.skipped_lines |= set(
-                            range(next_def.line, last.end_line + 1)
-                        )
+                        self.skipped_lines |= set(range(next_def.line, last.end_line + 1))
                 del file.defs[i + 1 :]
                 break
         file.skipped_lines = self.skipped_lines

jaclang/vendor/mypy/semanal_shared.py

@@ -108,9 +108,7 @@ class SemanticAnalyzerCoreInterface:
         raise NotImplementedError
 
     @abstractmethod
-    def defer(
-        self, debug_context: Context | None = None, force_progress: bool = False
-    ) -> None:
+    def defer(self, debug_context: Context | None = None, force_progress: bool = False) -> None:
         raise NotImplementedError
 
     @abstractmethod
@@ -168,9 +166,7 @@ class SemanticAnalyzerInterface(SemanticAnalyzerCoreInterface):
         raise NotImplementedError
 
     @abstractmethod
-    def named_type_or_none(
-        self, fullname: str, args: list[Type] | None = None
-    ) -> Instance | None:
+    def named_type_or_none(self, fullname: str, args: list[Type] | None = None) -> Instance | None:
         raise NotImplementedError
 
     @abstractmethod
@@ -193,15 +189,11 @@ class SemanticAnalyzerInterface(SemanticAnalyzerCoreInterface):
         raise NotImplementedError
 
     @abstractmethod
-    def get_and_bind_all_tvars(
-        self, type_exprs: list[Expression]
-    ) -> list[TypeVarLikeType]:
+    def get_and_bind_all_tvars(self, type_exprs: list[Expression]) -> list[TypeVarLikeType]:
         raise NotImplementedError
 
     @abstractmethod
-    def basic_new_typeinfo(
-        self, name: str, basetype_or_fallback: Instance, line: int
-    ) -> TypeInfo:
+    def basic_new_typeinfo(self, name: str, basetype_or_fallback: Instance, line: int) -> TypeInfo:
         raise NotImplementedError
 
     @abstractmethod
@@ -316,9 +308,7 @@ def calculate_tuple_fallback(typ: TupleType) -> None:
 
 
 class _NamedTypeCallback(Protocol):
-    def __call__(
-        self, fully_qualified_name: str, args: list[Type] | None = None
-    ) -> Instance: ...
+    def __call__(self, fully_qualified_name: str, args: list[Type] | None = None) -> Instance: ...
 
 
 def paramspec_args(
@@ -336,9 +326,7 @@ def paramspec_args(
         fullname,
         id,
         flavor=ParamSpecFlavor.ARGS,
-        upper_bound=named_type_func(
-            "builtins.tuple", [named_type_func("builtins.object")]
-        ),
+        upper_bound=named_type_func("builtins.tuple", [named_type_func("builtins.object")]),
         default=AnyType(TypeOfAny.from_omitted_generics),
         line=line,
         column=column,
@@ -362,8 +350,7 @@ def paramspec_kwargs(
         id,
         flavor=ParamSpecFlavor.KWARGS,
         upper_bound=named_type_func(
-            "builtins.dict",
-            [named_type_func("builtins.str"), named_type_func("builtins.object")],
+            "builtins.dict", [named_type_func("builtins.str"), named_type_func("builtins.object")]
         ),
         default=AnyType(TypeOfAny.from_omitted_generics),
         line=line,
@@ -452,10 +439,7 @@ def find_dataclass_transform_spec(node: Node | None) -> DataclassTransformSpec |
         # The wording doesn't make this entirely explicit, but Pyright (the reference
         # implementation for this PEP) only handles directly-decorated metaclasses.
         metaclass_type = node.metaclass_type
-        if (
-            metaclass_type is not None
-            and metaclass_type.type.dataclass_transform_spec is not None
-        ):
+        if metaclass_type is not None and metaclass_type.type.dataclass_transform_spec is not None:
             return metaclass_type.type.dataclass_transform_spec
 
     return None
@@ -490,9 +474,7 @@ def require_bool_literal_argument(
     value = parse_bool(expression)
     if value is None:
         api.fail(
-            f'"{name}" argument must be a True or False literal',
-            expression,
-            code=LITERAL_REQ,
+            f'"{name}" argument must be a True or False literal', expression, code=LITERAL_REQ
         )
         return default