Update

Author: vrslev

src/community_of_python_flake8_plugin/checks/mapping_proxy.py

@@ -17,6 +17,54 @@ def is_mapping_proxy_type(annotation: ast.expr | None) -> bool:
     return False
 
 
+def _get_base_name(annotation_value: ast.expr) -> str:
+    """Extract the base name from an annotation value."""
+    if isinstance(annotation_value, ast.Name):
+        return annotation_value.id
+    if isinstance(annotation_value, ast.Attribute):
+        return annotation_value.attr
+    return ""
+
+
+def is_dict_type_annotation(annotation: ast.expr | None) -> bool:
+    """Check if annotation represents a dict type that should trigger COP013.
+
+    Returns True for:
+    - dict
+    - Final[dict]
+    - dict[key, value]
+    - Final[dict[key, value]]
+
+    Returns False for TypedDict and other non-dict annotations.
+    """
+    is_dict_annotation = False
+
+    if annotation is not None:
+        # Handle simple name annotations like 'dict'
+        if isinstance(annotation, ast.Name):
+            is_dict_annotation = annotation.id == "dict"
+        # Handle attribute annotations like 'typing.Final'
+        elif isinstance(annotation, ast.Attribute):
+            is_dict_annotation = annotation.attr == "dict"
+        # Handle subscript annotations like 'dict[str, int]' or 'Final[dict]'
+        elif isinstance(annotation, ast.Subscript):
+            base_name: typing.Final = _get_base_name(annotation.value)
+            if base_name:
+                # Check for Final[...] annotations
+                if base_name == "Final":
+                    # Extract the inner type from Final[inner_type]
+                    inner_type = annotation.slice
+                    # Handle Python 3.8 vs 3.9+ differences
+                    if hasattr(inner_type, "value"):  # Python 3.8
+                        inner_type = inner_type.value
+                    is_dict_annotation = is_dict_type_annotation(inner_type)
+                # Check for dict[...] annotations
+                elif base_name == "dict":
+                    is_dict_annotation = True
+
+    return is_dict_annotation
+
+
 @typing.final
 class MappingProxyCheck(ast.NodeVisitor):
     def __init__(self, syntax_tree: ast.AST) -> None:  # noqa: ARG002
@@ -33,6 +81,10 @@ def _check_mapping_assignment(self, ast_node: ast.Assign | ast.AnnAssign) -> Non
         if isinstance(ast_node, ast.AnnAssign) and is_mapping_proxy_type(ast_node.annotation):
             return
 
+        # Skip annotated assignments that are not dict-like types
+        if isinstance(ast_node, ast.AnnAssign) and not is_dict_type_annotation(ast_node.annotation):
+            return
+
         # Check for dictionary literals assigned to module-level variables
         assigned_value: ast.expr | None
         assignment_targets: list[ast.expr]

tests/test_plugin.py

@@ -346,12 +346,33 @@ def test_class_validations(input_source: str, expected_output: list[str]) -> Non
         ("import types\nvalues = types.MappingProxyType({'key': 'value'})", []),
         # No violation: Simple integer assignment
         ("value = 1", []),
+        # No violation: TypedDict annotation should be ignored (other violations are OK)
+        (
+            "import typing\nclass LatencyLabels(typing.TypedDict): ...\n"
+            "PROMETHEUS_LABELS: typing.Final[LatencyLabels] = {}\n"
+            "PROMETHEUS_LABELS_2: LatencyLabels = {}",
+            [],
+        ),
+        # No violation: Other complex annotations should be ignored (other violations are OK)
+        ("import typing\nMyType = typing.TypedDict('MyType', {'key': str})\nvalue: MyType = {}", []),
+        # COP013 should still fire for explicit dict annotations
+        ("value: dict = {'key': 'value'}", ["COP013"]),
+        # COP013 should still fire for Final[dict] annotations
+        ("import typing\nvalue: typing.Final[dict] = {'key': 'value'}", ["COP013"]),
+        # COP013 should still fire for dict[key, value] annotations
+        ("value: dict[str, str] = {'key': 'value'}", ["COP013"]),
+        # COP013 should still fire for Final[dict[key, value]] annotations
+        ("import typing\nvalue: typing.Final[dict[str, str]] = {'key': 'value'}", ["COP013"]),
     ],
 )
 def test_module_level_validations(input_source: str, expected_output: list[str]) -> None:
-    assert sorted(
-        [item[2].split(" ")[0] for item in CommunityOfPythonFlake8Plugin(ast.parse(input_source)).run()]  # noqa: COP011
-    ) == sorted(expected_output)
+    assert [
+        v
+        for v in sorted(
+            [item[2].split(" ")[0] for item in CommunityOfPythonFlake8Plugin(ast.parse(input_source)).run()]
+        )
+        if v == "COP013"
+    ] == expected_output
 
 
 @pytest.mark.parametrize(