Mark unsafe TypedDicts in ServicePackageParser

mypy_boto3_builder/generators/base_generator.py

@@ -202,6 +202,7 @@ def _process_service(
         templates_path: Path,
     ) -> ServicePackage:
         service_package = self._parse_service_package(service_name, version, package_data)
+        ServicePackageParser.mark_unsafe_typed_dicts(service_package)
 
         self.logger.debug(f"Writing {service_name.boto3_name}")
         self.package_writer.write_service_package(

mypy_boto3_builder/parsers/service_package_parser.py

@@ -20,6 +20,8 @@
 from mypy_boto3_builder.structures.waiter import Waiter
 from mypy_boto3_builder.type_annotations.type_def_sortable import TypeDefSortable
 from mypy_boto3_builder.type_maps.typed_dicts import CloudwatchEventTypeDef
+from mypy_boto3_builder.utils.strings import RESERVED_NAMES, is_reserved
+from mypy_boto3_builder.utils.type_checks import is_typed_dict
 from mypy_boto3_builder.utils.type_def_sorter import TypeDefSorter
 
 
@@ -85,6 +87,30 @@ def parse(self) -> ServicePackage:
 
         return result
 
+    @staticmethod
+    def mark_unsafe_typed_dicts(service_package: ServicePackage) -> None:
+        """
+        Mark TypedDicts that can't be rendered as classes safely.
+
+        TypedDict cannot be rendered as class if its name or any attribute is a reserver word,
+        or if any argument is names as another TypeDef.
+        """
+        unsafe_keys = {
+            *RESERVED_NAMES,
+            *(type_def.name for type_def in service_package.type_defs),
+            *(literal.name for literal in service_package.literals),
+        }
+        for type_def in service_package.type_defs:
+            if not is_typed_dict(type_def):
+                continue
+            type_def.is_safe_as_class = True
+            if is_reserved(type_def.name):
+                type_def.is_safe_as_class = False
+                continue
+            if any(attribute.name in unsafe_keys for attribute in type_def.children):
+                type_def.is_safe_as_class = False
+                continue
+
     def _parse_service_package(self) -> ServicePackage:
         client = parse_client(self.session, self.service_name, self.shape_parser)
         service_resource_parser = ServiceResourceParser(

mypy_boto3_builder/type_annotations/type_typed_dict.py

@@ -17,7 +17,6 @@
 from mypy_boto3_builder.type_annotations.type_parent import TypeParent
 from mypy_boto3_builder.type_annotations.type_subscript import TypeSubscript
 from mypy_boto3_builder.utils.jinja2 import render_jinja2_template
-from mypy_boto3_builder.utils.strings import is_reserved
 
 
 class TypedDictAttribute:
@@ -109,6 +108,7 @@ def __init__(
         self.children = list(children)
         self.docstring = docstring
         self._stringify = stringify
+        self.is_safe_as_class = True
 
     def is_stringified(self) -> bool:
         """
@@ -146,20 +146,13 @@ def render(self) -> str:
 
         return self.name
 
-    def _is_safe_as_class(self) -> bool:
-        """
-        Whether type annotation can be safely rendered as a class.
-        """
-        names = (self.name, *(child.name for child in self.children))
-        return not any(is_reserved(name) for name in names)
-
     def render_definition(self) -> str:
         """
         Render type annotation definition.
         """
         template = (
             Path("common/typed_dict_class.py.jinja2")
-            if self._is_safe_as_class()
+            if self.is_safe_as_class
             else Path("common/typed_dict.py.jinja2")
         )
         return render_jinja2_template(template, {"type_def": self})

tests/type_annotations/test_type_typed_dict.py

@@ -60,6 +60,7 @@ def test_render_definition(self) -> None:
                 TypedDictAttribute("Type", Type.str, False),
             ],
         )
+        typed_dict.is_safe_as_class = False
         assert (
             typed_dict.render_definition()
             == 'MyDict = TypedDict("MyDict", {"required": str, "Type": NotRequired[str], })'
@@ -175,6 +176,7 @@ def test_replace_self_references(self) -> None:
                 TypedDictAttribute("required", Type.str, True),
             ],
         )
+        typed_dict.is_safe_as_class = False
         typed_dict.add_attribute("self_one", typed_dict, True)
         typed_dict.add_attribute("Type", typed_dict, False)
         assert typed_dict.replace_self_references(Type.DictStrAny)