python
diff --git a/‎mypy/plugins/attrs.py‎
Lines changed: 15 additions & 12 deletions b/‎mypy/plugins/attrs.py‎
Lines changed: 15 additions & 12 deletions
diff --git a/‎test-data/unit/check-plugin-attrs.test‎
Lines changed: 41 additions & 0 deletions b/‎test-data/unit/check-plugin-attrs.test‎
Lines changed: 41 additions & 0 deletions
@@ -424,13 +424,14 @@ def _get_frozen(ctx: mypy.plugin.ClassDefContext, frozen_default: bool) -> bool:
 
 
 def _analyze_class(
-    ctx: mypy.plugin.ClassDefContext, auto_attribs: bool | None, kw_only: bool
+    ctx: mypy.plugin.ClassDefContext, auto_attribs: bool | None, class_kw_only: bool
 ) -> list[Attribute]:
     """Analyze the class body of an attr maker, its parents, and return the Attributes found.
 
     auto_attribs=True means we'll generate attributes from type annotations also.
     auto_attribs=None means we'll detect which mode to use.
-    kw_only=True means that all attributes created here will be keyword only args in __init__.
+    class_kw_only=True means that all attributes created here will be keyword only args by
+        default in __init__.
     """
     own_attrs: dict[str, Attribute] = {}
     if auto_attribs is None:
@@ -439,7 +440,7 @@ def _analyze_class(
     # Walk the body looking for assignments and decorators.
     for stmt in ctx.cls.defs.body:
         if isinstance(stmt, AssignmentStmt):
-            for attr in _attributes_from_assignment(ctx, stmt, auto_attribs, kw_only):
+            for attr in _attributes_from_assignment(ctx, stmt, auto_attribs, class_kw_only):
                 # When attrs are defined twice in the same body we want to use the 2nd definition
                 # in the 2nd location. So remove it from the OrderedDict.
                 # Unless it's auto_attribs in which case we want the 2nd definition in the
@@ -537,7 +538,7 @@ def _detect_auto_attribs(ctx: mypy.plugin.ClassDefContext) -> bool:
 
 
 def _attributes_from_assignment(
-    ctx: mypy.plugin.ClassDefContext, stmt: AssignmentStmt, auto_attribs: bool, kw_only: bool
+    ctx: mypy.plugin.ClassDefContext, stmt: AssignmentStmt, auto_attribs: bool, class_kw_only: bool
 ) -> Iterable[Attribute]:
     """Return Attribute objects that are created by this assignment.
 
@@ -565,11 +566,13 @@ def _attributes_from_assignment(
                 and isinstance(rvalue.callee, RefExpr)
                 and rvalue.callee.fullname in attr_attrib_makers
             ):
-                attr = _attribute_from_attrib_maker(ctx, auto_attribs, kw_only, lhs, rvalue, stmt)
+                attr = _attribute_from_attrib_maker(
+                    ctx, auto_attribs, class_kw_only, lhs, rvalue, stmt
+                )
                 if attr:
                     yield attr
             elif auto_attribs and stmt.type and stmt.new_syntax and not is_class_var(lhs):
-                yield _attribute_from_auto_attrib(ctx, kw_only, lhs, rvalue, stmt)
+                yield _attribute_from_auto_attrib(ctx, class_kw_only, lhs, rvalue, stmt)
 
 
 def _cleanup_decorator(stmt: Decorator, attr_map: dict[str, Attribute]) -> None:
@@ -604,7 +607,7 @@ def _cleanup_decorator(stmt: Decorator, attr_map: dict[str, Attribute]) -> None:
 
 def _attribute_from_auto_attrib(
     ctx: mypy.plugin.ClassDefContext,
-    kw_only: bool,
+    class_kw_only: bool,
     lhs: NameExpr,
     rvalue: Expression,
     stmt: AssignmentStmt,
@@ -615,13 +618,13 @@ def _attribute_from_auto_attrib(
     has_rhs = not isinstance(rvalue, TempNode)
     sym = ctx.cls.info.names.get(name)
     init_type = sym.type if sym else None
-    return Attribute(name, None, ctx.cls.info, has_rhs, True, kw_only, None, stmt, init_type)
+    return Attribute(name, None, ctx.cls.info, has_rhs, True, class_kw_only, None, stmt, init_type)
 
 
 def _attribute_from_attrib_maker(
     ctx: mypy.plugin.ClassDefContext,
     auto_attribs: bool,
-    kw_only: bool,
+    class_kw_only: bool,
     lhs: NameExpr,
     rvalue: CallExpr,
     stmt: AssignmentStmt,
@@ -642,9 +645,9 @@ def _attribute_from_attrib_maker(
 
     # Read all the arguments from the call.
     init = _get_bool_argument(ctx, rvalue, "init", True)
-    # Note: If the class decorator says kw_only=True the attribute is ignored.
-    # See https://github.com/python-attrs/attrs/issues/481 for explanation.
-    kw_only |= _get_bool_argument(ctx, rvalue, "kw_only", False)
+    # The class decorator kw_only value can be overridden by the attribute value
+    # See https://github.com/python-attrs/attrs/pull/1457
+    kw_only = _get_bool_argument(ctx, rvalue, "kw_only", class_kw_only)
 
     # TODO: Check for attr.NOTHING
     attr_has_default = bool(_get_argument(rvalue, "default"))
 
@@ -1324,6 +1324,47 @@ D(b=17)
 [builtins fixtures/plugin_attrs.pyi]
 
 
+[case testAttrsKwOnlyClassAttributeFalse]
+from attrs import define, field
+@define(kw_only=True)
+class A:
+    a: int = field(kw_only=False)
+    b: int = 1
+A(0)
+A(1, b=3)
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testAttrsKwOnlyClassAttributeFalseSubclass]
+from attrs import define, field
+@define(kw_only
8B92
=True)
+class A:
+    a: int = field(kw_only=False)
+    b: int = 1
+@define(kw_only=True)
+class B(A):
+    c: int = field(kw_only=False)
+    d: int = 3
+
+B(0, 1)
+B(0, 1, b=3, d=4)
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testAttrsKwOnlyClassAttributeFalseSubclassOnly]
+from attrs import define, field
+@define
+class A:
+    a: int
+    b: int = field(kw_only=True, default=1)
+@define(kw_only=True)
+class B(A):
+    c: int = field(kw_only=False)
+    d: int = 3
+
+B(0, 1)
+B(0, 1, b=3, d=4)
+[builtins fixtures/plugin_attrs.pyi]
+
+
 [case testAttrsKwOnlySubclass]
 import attr
 @attr.s