pycfmodel 2.0.0__tar.gz → 2.0.1__tar.gz

{pycfmodel-2.0.0/pycfmodel.egg-info → pycfmodel-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycfmodel
-Version: 2.0.0
+Version: 2.0.1
 Summary: A python model for Cloud Formation scripts
 Author-email: Skyscanner Security <security@skyscanner.net>
 Project-URL: Homepage, https://github.com/Skyscanner/pycfmodel

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/pycfmodel/cloudformation_actions.py

@@ -9473,6 +9473,10 @@ CLOUDFORMATION_ACTIONS = [
     "importexport:ListJobs",
     "importexport:UpdateJob",
     "inspector-scan:ScanSbom",
+    "inspector2-telemetry:NotifyHeartbeat",
+    "inspector2-telemetry:SendTelemetry",
+    "inspector2-telemetry:StartSession",
+    "inspector2-telemetry:StopSession",
     "inspector2:AssociateMember",
     "inspector2:BatchAssociateCodeSecurityScanConfiguration",
     "inspector2:BatchDisassociateCodeSecurityScanConfiguration",
@@ -10601,11 +10605,13 @@ CLOUDFORMATION_ACTIONS = [
     "kafka:CreateClusterV2",
     "kafka:CreateConfiguration",
     "kafka:CreateReplicator",
+    "kafka:CreateTopic",
     "kafka:CreateVpcConnection",
     "kafka:DeleteCluster",
     "kafka:DeleteClusterPolicy",
     "kafka:DeleteConfiguration",
     "kafka:DeleteReplicator",
+    "kafka:DeleteTopic",
     "kafka:DeleteVpcConnection",
     "kafka:DescribeCluster",
     "kafka:DescribeClusterOperation",
@@ -10651,6 +10657,7 @@ CLOUDFORMATION_ACTIONS = [
     "kafka:UpdateReplicationInfo",
     "kafka:UpdateSecurity",
     "kafka:UpdateStorage",
+    "kafka:UpdateTopic",
     "kafkaconnect:CreateConnector",
     "kafkaconnect:CreateCustomPlugin",
     "kafkaconnect:CreateWorkerConfiguration",

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/pycfmodel/model/resources/autoscaling_auto_scaling_group.py

@@ -403,6 +403,18 @@ class MixedInstancesPolicy(CustomModel):
 ResolvableMixedInstancesPolicy = ResolvableModel(MixedInstancesPolicy)
 
 
+# Pre-resolved list type to avoid class body name shadowing in AutoScalingAutoScalingGroupProperties.
+# The AutoScalingAutoScalingGroupProperties class has a field named "MetricsCollection" (default None) which shadows
+# the MetricsCollection class when Python evaluates List[MetricsCollection] inside the class body.
+_MetricsCollectionList = Resolvable[List[MetricsCollection]]
+
+
+# Pre-resolved list type to avoid class body name shadowing in AutoScalingAutoScalingGroupProperties.
+# The AutoScalingAutoScalingGroupProperties class has a field named "NotificationConfiguration" (default None) which shadows
+# the NotificationConfiguration class when Python evaluates List[NotificationConfiguration] inside the class body.
+_NotificationConfigurationList = Resolvable[List[NotificationConfiguration]]
+
+
 class AutoScalingAutoScalingGroupProperties(CustomModel):
     """
        Properties for AWS::AutoScaling::AutoScalingGroup.
@@ -419,6 +431,7 @@ class AutoScalingAutoScalingGroupProperties(CustomModel):
        - Cooldown: *Only needed if you use simple scaling policies.*
     The amount of time, in secon...
        - DefaultInstanceWarmup: The amount of time, in seconds, until a new instance is considered to have finis...
+       - DeletionProtection:
        - DesiredCapacity: The desired capacity is the initial capacity of the Auto Scaling group at the ti...
        - DesiredCapacityType: The unit of measurement for the value specified for desired capacity. Amazon EC2...
        - HealthCheckGracePeriod: The amount of time, in seconds, that Amazon EC2 Auto Scaling waits before checki...
@@ -465,6 +478,7 @@ class AutoScalingAutoScalingGroupProperties(CustomModel):
     Context: Optional[ResolvableStr] = None
     Cooldown: Optional[ResolvableStr] = None
     DefaultInstanceWarmup: Optional[ResolvableInt] = None
+    DeletionProtection: Optional[ResolvableStr] = None
     DesiredCapacity: Optional[ResolvableStr] = None
     DesiredCapacityType: Optional[ResolvableStr] = None
     HealthCheckGracePeriod: Optional[ResolvableInt] = None
@@ -477,11 +491,11 @@ class AutoScalingAutoScalingGroupProperties(CustomModel):
     LifecycleHookSpecificationList: Optional[Resolvable[List[LifecycleHookSpecification]]] = None
     LoadBalancerNames: Optional[Resolvable[List[ResolvableStr]]] = None
     MaxInstanceLifetime: Optional[ResolvableInt] = None
-    MetricsCollection: Optional[Resolvable[List[MetricsCollection]]] = None
+    MetricsCollection: Optional[_MetricsCollectionList] = None
     MixedInstancesPolicy: Optional[ResolvableMixedInstancesPolicy] = None
     NewInstancesProtectedFromScaleIn: Optional[ResolvableBool] = None
     NotificationConfiguration: Optional[ResolvableNotificationConfiguration] = None
-    NotificationConfigurations: Optional[Resolvable[List[NotificationConfiguration]]] = None
+    NotificationConfigurations: Optional[_NotificationConfigurationList] = None
     PlacementGroup: Optional[ResolvableStr] = None
     ServiceLinkedRoleARN: Optional[ResolvableStr] = None
     SkipZonalShiftValidation: Optional[ResolvableBool] = None

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/pycfmodel/model/resources/cloudwatch_alarm.py

@@ -7,6 +7,7 @@ Auto-generated from AWS CloudFormation schema for AWS::CloudWatch::Alarm.
 from typing import List, Literal, Optional
 
 from pycfmodel.model.base import CustomModel
+from pycfmodel.model.resources.properties.tag import Tag
 from pycfmodel.model.resources.resource import Resource
 from pycfmodel.model.types import Resolvable, ResolvableBool, ResolvableInt, ResolvableModel, ResolvableStr
 
@@ -67,18 +68,6 @@ class MetricDataQuery(CustomModel):
 ResolvableMetricDataQuery = ResolvableModel(MetricDataQuery)
 
 
-class Tag(CustomModel):
-    """
-    One of the key-value pairs associated with the alarm.
-    """
-
-    Key: ResolvableStr
-    Value: ResolvableStr
-
-
-ResolvableTag = ResolvableModel(Tag)
-
-
 class CloudWatchAlarmProperties(CustomModel):
     """
     Properties for AWS::CloudWatch::Alarm.

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/pycfmodel/model/resources/dynamodb_table.py

@@ -7,7 +7,7 @@ Auto-generated from AWS CloudFormation schema for AWS::DynamoDB::Table.
 from typing import List, Literal, Optional
 
 from pycfmodel.model.base import CustomModel
-from pycfmodel.model.generic import ResolvableGeneric
+from pycfmodel.model.resources.properties.tag import Tag
 from pycfmodel.model.resources.resource import Resource
 from pycfmodel.model.types import Resolvable, ResolvableBool, ResolvableInt, ResolvableModel, ResolvableStr
 
@@ -119,13 +119,19 @@ class Projection(CustomModel):
 ResolvableProjection = ResolvableModel(Projection)
 
 
+# Pre-resolved list type to avoid class body name shadowing in LocalSecondaryIndex.
+# The LocalSecondaryIndex class has a field named "KeySchema" (default None) which shadows
+# the KeySchema class when Python evaluates List[KeySchema] inside the class body.
+_KeySchemaList = Resolvable[List[KeySchema]]
+
+
 class LocalSecondaryIndex(CustomModel):
     """
     Represents the properties of a local secondary index.
     """
 
     IndexName: ResolvableStr
-    KeySchema: Resolvable[List[KeySchema]]
+    KeySchema: _KeySchemaList
     Projection: ResolvableProjection
 
 
@@ -149,7 +155,7 @@ class ResourcePolicy(CustomModel):
     Creates or updates a resource-based policy document that contains the permissions for DDB resources, such as a table, its indexes, and stream.
     """
 
-    PolicyDocument: ResolvableGeneric
+    PolicyDocument: Resolvable[dict]
 
 
 ResolvableResourcePolicy = ResolvableModel(ResourcePolicy)
@@ -207,18 +213,6 @@ class StreamSpecification(CustomModel):
 ResolvableStreamSpecification = ResolvableModel(StreamSpecification)
 
 
-class Tag(CustomModel):
-    """
-    Describes a tag.
-    """
-
-    Key: ResolvableStr
-    Value: ResolvableStr
-
-
-ResolvableTag = ResolvableModel(Tag)
-
-
 class TimeToLiveSpecification(CustomModel):
     """
     Represents the settings used to enable or disable Time to Live (TTL) for the specified table.
@@ -243,13 +237,19 @@ class WarmThroughput(CustomModel):
 ResolvableWarmThroughput = ResolvableModel(WarmThroughput)
 
 
+# Pre-resolved list type to avoid class body name shadowing in GlobalSecondaryIndex.
+# The GlobalSecondaryIndex class has a field named "KeySchema" (default None) which shadows
+# the KeySchema class when Python evaluates List[KeySchema] inside the class body.
+_KeySchemaList = Resolvable[List[KeySchema]]
+
+
 class GlobalSecondaryIndex(CustomModel):
     """
     Represents the properties of a global secondary index.
     """
 
     IndexName: ResolvableStr
-    KeySchema: Resolvable[List[KeySchema]]
+    KeySchema: _KeySchemaList
     Projection: ResolvableProjection
     ContributorInsightsSpecification: Optional[ResolvableContributorInsightsSpecification] = None
     OnDemandThroughput: Optional[ResolvableOnDemandThroughput] = None
@@ -260,6 +260,12 @@ class GlobalSecondaryIndex(CustomModel):
 ResolvableGlobalSecondaryIndex = ResolvableModel(GlobalSecondaryIndex)
 
 
+# Pre-resolved list type to avoid class body name shadowing in DynamoDBTableProperties.
+# The DynamoDBTableProperties class has a field named "KeySchema" (default None) which shadows
+# the KeySchema class when Python evaluates List[KeySchema] inside the class body.
+_KeySchemaList = Resolvable[List[KeySchema]]
+
+
 class DynamoDBTableProperties(CustomModel):
     """
        Properties for AWS::DynamoDB::Table.
@@ -293,7 +299,7 @@ class DynamoDBTableProperties(CustomModel):
        More info at [AWS Docs](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html)
     """
 
-    KeySchema: Resolvable[List[KeySchema]]
+    KeySchema: _KeySchemaList
     AttributeDefinitions: Optional[Resolvable[List[AttributeDefinition]]] = None
     BillingMode: Optional[ResolvableStr] = None
     ContributorInsightsSpecification: Optional[ResolvableContributorInsightsSpecification] = None

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/pycfmodel/model/resources/elbv2_target_group.py

@@ -7,6 +7,7 @@ Auto-generated from AWS CloudFormation schema for AWS::ElasticLoadBalancingV2::T
 from typing import List, Literal, Optional
 
 from pycfmodel.model.base import CustomModel
+from pycfmodel.model.resources.properties.tag import Tag
 from pycfmodel.model.resources.resource import Resource
 from pycfmodel.model.types import Resolvable, ResolvableBool, ResolvableInt, ResolvableModel, ResolvableStr
 
@@ -23,18 +24,6 @@ class Matcher(CustomModel):
 ResolvableMatcher = ResolvableModel(Matcher)
 
 
-class Tag(CustomModel):
-    """
-    Tag configuration.
-    """
-
-    Key: ResolvableStr
-    Value: ResolvableStr
-
-
-ResolvableTag = ResolvableModel(Tag)
-
-
 class TargetDescription(CustomModel):
     """
     TargetDescription configuration.
@@ -125,4 +114,4 @@ class ELBv2TargetGroup(Resource):
     """
 
     Type: Literal["AWS::ElasticLoadBalancingV2::TargetGroup"]
-    Properties: Optional[Resolvable[ELBv2TargetGroupProperties]] = None
+    Properties: Resolvable[ELBv2TargetGroupProperties] = ELBv2TargetGroupProperties()

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/pycfmodel/model/resources/iam_group.py

@@ -35,7 +35,7 @@ class IAMGroup(Resource):
     """
 
     Type: Literal["AWS::IAM::Group"]
-    Properties: Optional[Resolvable[IAMGroupProperties]] = None
+    Properties: Resolvable[IAMGroupProperties] = IAMGroupProperties()
 
     @property
     def policy_documents(self) -> List[OptionallyNamedPolicyDocument]:

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/pycfmodel/model/resources/iam_user.py

@@ -59,7 +59,7 @@ class IAMUser(Resource):
     """
 
     Type: Literal["AWS::IAM::User"]
-    Properties: Optional[Resolvable[IAMUserProperties]] = None
+    Properties: Resolvable[IAMUserProperties] = IAMUserProperties()
 
     def has_hardcoded_credentials(self) -> bool:
         """Returns True if login profile password contains a hardcoded string, otherwise False."""

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/pycfmodel/model/resources/s3_bucket.py

@@ -814,6 +814,18 @@ class Transition(CustomModel):
 ResolvableTransition = ResolvableModel(Transition)
 
 
+# Pre-resolved list type to avoid class body name shadowing in Rule.
+# The Rule class has a field named "NoncurrentVersionTransition" (default None) which shadows
+# the NoncurrentVersionTransition class when Python evaluates List[NoncurrentVersionTransition] inside the class body.
+_NoncurrentVersionTransitionList = Resolvable[List[NoncurrentVersionTransition]]
+
+
+# Pre-resolved list type to avoid class body name shadowing in Rule.
+# The Rule class has a field named "Transition" (default None) which shadows
+# the Transition class when Python evaluates List[Transition] inside the class body.
+_TransitionList = Resolvable[List[Transition]]
+
+
 class Rule(CustomModel):
     """
     Specifies lifecycle rules for an Amazon S3 bucket.
@@ -828,13 +840,13 @@ class Rule(CustomModel):
     NoncurrentVersionExpiration: Optional[ResolvableNoncurrentVersionExpiration] = None
     NoncurrentVersionExpirationInDays: Optional[ResolvableInt] = None
     NoncurrentVersionTransition: Optional[ResolvableNoncurrentVersionTransition] = None
-    NoncurrentVersionTransitions: Optional[Resolvable[List[NoncurrentVersionTransition]]] = None
+    NoncurrentVersionTransitions: Optional[_NoncurrentVersionTransitionList] = None
     ObjectSizeGreaterThan: Optional[ResolvableStr] = None
     ObjectSizeLessThan: Optional[ResolvableStr] = None
     Prefix: Optional[ResolvableStr] = None
     TagFilters: Optional[Resolvable[List[TagFilter]]] = None
     Transition: Optional[ResolvableTransition] = None
-    Transitions: Optional[Resolvable[List[Transition]]] = None
+    Transitions: Optional[_TransitionList] = None
 
 
 ResolvableRule = ResolvableModel(Rule)
@@ -923,4 +935,4 @@ class S3Bucket(Resource):
     """
 
     Type: Literal["AWS::S3::Bucket"]
-    Properties: Optional[Resolvable[S3BucketProperties]] = None
+    Properties: Resolvable[S3BucketProperties] = S3BucketProperties()

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/pycfmodel/model/resources/sns_topic.py

@@ -7,6 +7,7 @@ Auto-generated from AWS CloudFormation schema for AWS::SNS::Topic.
 from typing import List, Literal, Optional
 
 from pycfmodel.model.base import CustomModel
+from pycfmodel.model.resources.properties.tag import Tag
 from pycfmodel.model.resources.resource import Resource
 from pycfmodel.model.types import Resolvable, ResolvableBool, ResolvableModel, ResolvableStr
 
@@ -37,16 +38,10 @@ class Subscription(CustomModel):
 ResolvableSubscription = ResolvableModel(Subscription)
 
 
-class Tag(CustomModel):
-    """
-    The list of tags to be added to the specified topic.
-    """
-
-    Key: ResolvableStr
-    Value: ResolvableStr
-
-
-ResolvableTag = ResolvableModel(Tag)
+# Pre-resolved list type to avoid class body name shadowing in SNSTopicProperties.
+# The SNSTopicProperties class has a field named "Subscription" (default None) which shadows
+# the Subscription class when Python evaluates List[Subscription] inside the class body.
+_SubscriptionList = Resolvable[List[Subscription]]
 
 
 class SNSTopicProperties(CustomModel):
@@ -85,7 +80,7 @@ class SNSTopicProperties(CustomModel):
     FifoTopic: Optional[ResolvableBool] = None
     KmsMasterKeyId: Optional[ResolvableStr] = None
     SignatureVersion: Optional[ResolvableStr] = None
-    Subscription: Optional[Resolvable[List[Subscription]]] = None
+    Subscription: Optional[_SubscriptionList] = None
     Tags: Optional[Resolvable[List[Tag]]] = None
     TopicName: Optional[ResolvableStr] = None
     TracingConfig: Optional[ResolvableStr] = None
@@ -103,4 +98,4 @@ class SNSTopic(Resource):
     """
 
     Type: Literal["AWS::SNS::Topic"]
-    Properties: Optional[Resolvable[SNSTopicProperties]] = None
+    Properties: Resolvable[SNSTopicProperties] = SNSTopicProperties()

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/pycfmodel/model/resources/sqs_queue.py

@@ -7,18 +7,9 @@ Auto-generated from AWS CloudFormation schema for AWS::SQS::Queue.
 from typing import List, Literal, Optional
 
 from pycfmodel.model.base import CustomModel
+from pycfmodel.model.resources.properties.tag import Tag
 from pycfmodel.model.resources.resource import Resource
-from pycfmodel.model.types import Resolvable, ResolvableBool, ResolvableInt, ResolvableModel, ResolvableStr
-
-
-class Tag(CustomModel):
-    """ """
-
-    Key: ResolvableStr
-    Value: ResolvableStr
-
-
-ResolvableTag = ResolvableModel(Tag)
+from pycfmodel.model.types import Resolvable, ResolvableBool, ResolvableInt, ResolvableStr
 
 
 class SQSQueueProperties(CustomModel):
@@ -77,4 +68,4 @@ class SQSQueue(Resource):
     """
 
     Type: Literal["AWS::SQS::Queue"]
-    Properties: Optional[Resolvable[SQSQueueProperties]] = None
+    Properties: Resolvable[SQSQueueProperties] = SQSQueueProperties()

{pycfmodel-2.0.0 → pycfmodel-2.0.1/pycfmodel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycfmodel
-Version: 2.0.0
+Version: 2.0.1
 Summary: A python model for Cloud Formation scripts
 Author-email: Skyscanner Security <security@skyscanner.net>
 Project-URL: Homepage, https://github.com/Skyscanner/pycfmodel

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/scripts/generate_resource_from_schema.py

@@ -279,37 +279,64 @@ class CodeGenerator:
         # Handle anyOf/oneOf
         if "anyOf" in prop_schema or "oneOf" in prop_schema:
             variants = prop_schema.get("anyOf") or prop_schema.get("oneOf", [])
-            # Check if any variant is an array
-            for variant in variants:
-                if variant.get("type") == "array":
-                    items = variant.get("items", {})
-                    item_type = self._get_item_type(items)
-                    self.imports.add("from typing import List")
-                    return f"Resolvable[List[{item_type}]]"
-            # Check for $ref in variants
-            for variant in variants:
-                if "$ref" in variant:
-                    ref = variant["$ref"]
-                    if ref.startswith("#/definitions/"):
-                        def_name = ref.split("/")[-1]
-                        definition = self.definitions.get(def_name, {})
-                        if definition.get("type") == "object" or definition.get("properties"):
-                            # Generate a nested model class and use ResolvableModel
-                            self.needed_definitions.add(def_name)
-                            self.imports.add("from pycfmodel.model.types import ResolvableModel")
-                            return f"Resolvable{def_name}"
-                        else:
-                            # Fall back to inline handling
-                            return self.get_type_for_schema(variant, is_required, context)
-            return "Resolvable[dict]"
+
+            # Skip variants that are only relationshipRef metadata (not real type info).
+            # If all variants are just relationshipRef, fall through to the "type" field.
+            typed_variants = [v for v in variants if not (set(v.keys()) <= {"relationshipRef"})]
+
+            if typed_variants:
+                # Check if any variant is an array
+                for variant in typed_variants:
+                    if variant.get("type") == "array":
+                        items = variant.get("items", {})
+                        item_type = self._get_item_type(items)
+                        self.imports.add("from typing import List")
+                        return f"Resolvable[List[{item_type}]]"
+                # Check for $ref in variants
+                for variant in typed_variants:
+                    if "$ref" in variant:
+                        ref = variant["$ref"]
+                        if ref.startswith("#/definitions/"):
+                            def_name = ref.split("/")[-1]
+                            definition = self.definitions.get(def_name, {})
+                            if definition.get("type") == "object" or definition.get("properties"):
+                                # Generate a nested model class and use ResolvableModel
+                                self.needed_definitions.add(def_name)
+                                self.imports.add("from pycfmodel.model.types import ResolvableModel")
+                                return f"Resolvable{def_name}"
+                            else:
+                                # Fall back to inline handling
+                                return self.get_type_for_schema(variant, is_required, context)
+                return "Resolvable[dict]"
+            # All variants were relationshipRef only — fall through to use the "type" field
 
         json_type = prop_schema.get("type")
 
         if json_type is None:
             return "Resolvable[dict]"
 
-        # Handle multiple types (e.g., ["string", "object"])
+        # Handle multiple types (e.g., ["string", "object"]).
+        # If "object" is present, use Resolvable[dict] since it accepts both dicts and strings.
+        # Otherwise, use the first recognized primitive type.
         if isinstance(json_type, list):
+            if "object" in json_type:
+                return "Resolvable[dict]"
+            type_map = {
+                "string": "ResolvableStr",
+                "integer": "ResolvableInt",
+                "number": "ResolvableInt",
+                "boolean": "ResolvableBool",
+            }
+            for t in json_type:
+                if t in type_map:
+                    type_str = type_map[t]
+                    if type_str == "ResolvableStr":
+                        self.imports.add("from pycfmodel.model.types import ResolvableStr")
+                    elif type_str == "ResolvableInt":
+                        self.imports.add("from pycfmodel.model.types import ResolvableInt")
+                    elif type_str == "ResolvableBool":
+                        self.imports.add("from pycfmodel.model.types import ResolvableBool")
+                    return type_str
             return "Resolvable[dict]"
 
         # Handle array types
@@ -464,6 +491,59 @@ class CodeGenerator:
             return True
         return False
 
+    def _detect_field_name_shadowing(self, fields: List[Tuple[str, str, str, bool]]) -> Dict[str, str]:
+        """
+        Detect fields whose names shadow class names used in List[] annotations of sibling fields.
+
+        When a class has a field like `Transition: Optional[...] = None` and another field
+        `Transitions: Optional[Resolvable[List[Transition]]] = None`, Python evaluates the
+        List[Transition] annotation inside the class body where `Transition` has already been
+        set to None (the default value), causing List[Transition] to resolve to List[NoneType].
+
+        Returns a dict mapping class names to their pre-resolved type alias names.
+        """
+        field_names = {name for name, _, _, _ in fields}
+        aliases = {}
+
+        for _, type_annotation, _, _ in fields:
+            # Find all List[ClassName] patterns in the annotation
+            match = re.search(r"Resolvable\[List\[(\w+)\]\]", type_annotation)
+            if match:
+                class_name = match.group(1)
+                if class_name in field_names and class_name not in aliases:
+                    alias_name = f"_{class_name}List"
+                    aliases[class_name] = alias_name
+
+        return aliases
+
+    def _apply_shadowing_aliases(
+        self, fields: List[Tuple[str, str, str, bool]], aliases: Dict[str, str]
+    ) -> List[Tuple[str, str, str, bool]]:
+        """Replace Resolvable[List[ClassName]] with the pre-resolved alias in field annotations."""
+        if not aliases:
+            return fields
+
+        result = []
+        for name, type_annotation, default, is_required in fields:
+            for class_name, alias_name in aliases.items():
+                type_annotation = type_annotation.replace(f"Resolvable[List[{class_name}]]", alias_name)
+            result.append((name, type_annotation, default, is_required))
+        return result
+
+    def _generate_shadowing_alias_lines(self, aliases: Dict[str, str], class_name: str) -> List[str]:
+        """Generate module-level type alias lines to avoid class body name shadowing."""
+        lines = []
+        for original_class, alias_name in sorted(aliases.items()):
+            lines.append(f"# Pre-resolved list type to avoid class body name shadowing in {class_name}.")
+            lines.append(f'# The {class_name} class has a field named "{original_class}" (default None) which shadows')
+            lines.append(
+                f"# the {original_class} class when Python evaluates List[{original_class}] inside the class body."
+            )
+            lines.append(f"{alias_name} = Resolvable[List[{original_class}]]")
+            lines.append("")
+            lines.append("")
+        return lines
+
     def generate_definition_class(self, def_name: str) -> List[str]:
         """Generate a class for a schema definition."""
         if def_name in self.generated_definitions:
@@ -482,15 +562,6 @@ class CodeGenerator:
         required = set(definition.get("required", []))
         desc = definition.get("description", f"{def_name} configuration.")
 
-        lines = []
-        lines.append(f"class {def_name}(CustomModel):")
-        lines.append('    """')
-        # Truncate description to first sentence or 200 chars
-        short_desc = desc.split(".")[0] + "." if "." in desc else desc[:200]
-        lines.append(f"    {short_desc}")
-        lines.append('    """')
-        lines.append("")
-
         # Generate fields
         fields = []
         for prop_name, prop_schema in sorted(props.items()):
@@ -504,6 +575,23 @@ class CodeGenerator:
             default = "" if is_required else " = None"
             fields.append((prop_name, type_annotation, default, is_required))
 
+        # Detect and fix field name shadowing in List[] annotations
+        aliases = self._detect_field_name_shadowing(fields)
+        fields = self._apply_shadowing_aliases(fields, aliases)
+
+        lines = []
+
+        # Emit module-level type aliases before the class to avoid shadowing
+        lines.extend(self._generate_shadowing_alias_lines(aliases, def_name))
+
+        lines.append(f"class {def_name}(CustomModel):")
+        lines.append('    """')
+        # Truncate description to first sentence or 200 chars
+        short_desc = desc.split(".")[0] + "." if "." in desc else desc[:200]
+        lines.append(f"    {short_desc}")
+        lines.append('    """')
+        lines.append("")
+
         # Sort: required first, then optional
         required_fields = [(n, t, d) for n, t, d, r in fields if r]
         optional_fields = [(n, t, d) for n, t, d, r in fields if not r]
@@ -591,6 +679,19 @@ class CodeGenerator:
         # Each class is immediately followed by its ResolvableX type alias
         lines.extend(definition_code_lines)
 
+        # Detect and fix field name shadowing in Properties class List[] annotations
+        props_fields_for_shadowing = [(n, t, d, r) for n, t, d, _, r in property_fields]
+        props_aliases = self._detect_field_name_shadowing(props_fields_for_shadowing)
+        if props_aliases:
+            property_fields = [
+                (n, t_new, d, desc, r)
+                for (n, _, d, desc, r), (_, t_new, _, _) in zip(
+                    property_fields,
+                    self._apply_shadowing_aliases(props_fields_for_shadowing, props_aliases),
+                )
+            ]
+            lines.extend(self._generate_shadowing_alias_lines(props_aliases, self.props_class_name))
+
         # Properties class
         lines.append(f"class {self.props_class_name}(CustomModel):")
         lines.append('    """')
@@ -641,12 +742,13 @@ class CodeGenerator:
         lines.append("")
         lines.append(f'    Type: Literal["{self.resource_type}"]')
 
-        # Determine if Properties should be Optional
+        # When no properties are required, default to an empty properties object
+        # so that accessing Properties.SomeField returns None instead of raising AttributeError.
         has_required_props = any(r for _, _, _, _, r in property_fields)
         if has_required_props:
             lines.append(f"    Properties: Resolvable[{self.props_class_name}]")
         else:
-            lines.append(f"    Properties: Optional[Resolvable[{self.props_class_name}]] = None")
+            lines.append(f"    Properties: Resolvable[{self.props_class_name}] = {self.props_class_name}()")
 
         lines.append("")
 

{pycfmodel-2.0.0 → pycfmodel-2.0.1}/tests/resources/test_autoscaling_auto_scaling_group.py

@@ -174,6 +174,41 @@ def test_autoscaling_group_with_notification():
     assert asg.Properties.NotificationConfiguration.TopicARN == "arn:aws:sns:us-east-1:123456789012:my-topic"
 
 
+def test_autoscaling_group_with_notification_configurations():
+    """
+    Regression test: NotificationConfigurations must be parsed correctly as
+    List[NotificationConfiguration], not as List[NoneType] due to field name
+    shadowing from the singular NotificationConfiguration field in the class body.
+    """
+    asg = AutoScalingAutoScalingGroup(
+        **{
+            "Type": "AWS::AutoScaling::AutoScalingGroup",
+            "Properties": {
+                "MinSize": "1",
+                "MaxSize": "5",
+                "LaunchTemplate": {
+                    "LaunchTemplateId": "lt-123",
+                    "Version": "$Latest",
+                },
+                "VPCZoneIdentifier": ["subnet-123"],
+                "NotificationConfigurations": [
+                    {
+                        "TopicARN": "arn:aws:sns:us-east-1:123456789012:launch-topic",
+                        "NotificationTypes": ["autoscaling:EC2_INSTANCE_LAUNCH"],
+                    },
+                    {
+                        "TopicARN": "arn:aws:sns:us-east-1:123456789012:terminate-topic",
+                        "NotificationTypes": ["autoscaling:EC2_INSTANCE_TERMINATE"],
+                    },
+                ],
+            },
+        }
+    )
+    assert len(asg.Properties.NotificationConfigurations) == 2
+    assert asg.Properties.NotificationConfigurations[0].TopicARN == "arn:aws:sns:us-east-1:123456789012:launch-topic"
+    assert asg.Properties.NotificationConfigurations[1].TopicARN == "arn:aws:sns:us-east-1:123456789012:terminate-topic"
+
+
 def test_autoscaling_group_with_tags():
     asg = AutoScalingAutoScalingGroup(
         **{