cdk-factory 0.8.8__tar.gz → 0.9.0__tar.gz

{cdk_factory-0.8.8 → cdk_factory-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.8.8
+Version: 0.9.0
 Summary: CDK Factory. A QuickStarter and best practices setup for CDK projects
 Author-email: Eric Wilson <eric.wilson@geekcafe.com>
 License: MIT License

{cdk_factory-0.8.8 → cdk_factory-0.9.0}/pyproject.toml

@@ -33,7 +33,7 @@ markers = [
 [project]
 
 name = "cdk_factory"
-version = "0.8.8"
+version = "0.9.0"
 authors = [
   { name="Eric Wilson", email="eric.wilson@geekcafe.com" }
 ]
@@ -54,4 +54,7 @@ dependencies = [
   "boto3_assist>=0.10.0",
   "PyYAML",
   "cdk_nag"
-]
+]
+
+[project.scripts]
+cdk-factory = "cdk_factory.cli:main"

cdk_factory-0.9.0/src/cdk_factory/app.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+import os
+from pathlib import Path
+import aws_cdk
+from aws_cdk.cx_api import CloudAssembly
+
+from cdk_factory.utilities.commandline_args import CommandlineArgs
+from cdk_factory.workload.workload_factory import WorkloadFactory
+from cdk_factory.utilities.configuration_loader import ConfigurationLoader
+from cdk_factory.version import __version__
+
+
+class CdkAppFactory:
+    """CDK App Wrapper"""
+
+    def __init__(
+        self,
+        args: CommandlineArgs | None = None,
+        runtime_directory: str | None = None,
+        config_path: str | None = None,
+        outdir: str | None = None,
+        add_env_context: bool = True,
+        auto_detect_project_root: bool = True,
+        is_pipeline: bool = False,
+    ) -> None:
+
+        self.args = args or CommandlineArgs()
+        self.runtime_directory = runtime_directory or str(Path(__file__).parent)
+        self.config_path: str | None = config_path
+        self.add_env_context = add_env_context
+        self._is_pipeline = is_pipeline
+        
+        # Auto-detect outdir for CodeBuild compatibility
+        if outdir is None and self.args.outdir is None and auto_detect_project_root:
+            # Always detect project root first
+            project_root = self._detect_project_root()
+            
+            # Check if we're in CodeBuild or building a pipeline
+            in_codebuild = bool(os.getenv('CODEBUILD_SRC_DIR'))
+            
+            # Auto-detect if this is a pipeline deployment by checking config
+            is_pipeline_deployment = is_pipeline or self._check_if_pipeline_deployment(config_path)
+            
+            if in_codebuild or is_pipeline_deployment:
+                # For pipelines, calculate relative path from runtime_directory to project_root/cdk.out
+                # This ensures cdk.out is always at project root, even when app.py is in subdirectory
+                runtime_path = Path(self.runtime_directory).resolve()
+                project_path = Path(project_root).resolve()
+                cdk_out_path = project_path / 'cdk.out'
+                
+                try:
+                    # Calculate relative path from runtime directory to project_root/cdk.out
+                    relative_path = os.path.relpath(cdk_out_path, runtime_path)
+                    self.outdir = relative_path
+                    if in_codebuild:
+                        print(f"📦 CodeBuild detected: using relative path '{relative_path}'")
+                    else:
+                        print(f"📦 Pipeline deployment detected: using relative path '{relative_path}'")
+                except ValueError:
+                    # If paths are on different drives (Windows), fallback to absolute
+                    self.outdir = str(cdk_out_path)
+            else:
+                # For local dev, use absolute path at project root
+                self.outdir = os.path.join(project_root, 'cdk.out')
+        else:
+            self.outdir = outdir or self.args.outdir
+        
+        self.app: aws_cdk.App = aws_cdk.App(outdir=self.outdir)
+
+    def synth(
+        self,
+        cdk_app_file: str | None = None,
+        paths: list[str] | None = None,
+        **kwargs,
+    ) -> CloudAssembly:
+        """
+        The AWS CDK Deployment pipeline is defined here
+        Returns:
+            CloudAssembly: CDK CloudAssembly
+        """
+
+        print(f"👋 Synthesizing CDK App from the cdk-factory version: {__version__}")
+
+        if not paths:
+            paths = []
+
+        paths.append(self.app.outdir)
+        paths.append(__file__)
+        if cdk_app_file:
+            paths.append(cdk_app_file)
+
+        self.config_path = ConfigurationLoader().get_runtime_config(
+            relative_config_path=self.config_path,
+            args=self.args,
+            app=self.app,
+            runtime_directory=self.runtime_directory,
+        )
+
+        print("config_path", self.config_path)
+        if not self.config_path:
+            raise Exception("No configuration file provided")
+        if not os.path.exists(self.config_path):
+            raise Exception("Configuration file does not exist: " + self.config_path)
+        workload: WorkloadFactory = WorkloadFactory(
+            app=self.app,
+            config_path=self.config_path,
+            cdk_app_file=cdk_app_file,
+            paths=paths,
+            runtime_directory=self.runtime_directory,
+            outdir=self.outdir,
+            add_env_context=self.add_env_context,
+        )
+
+        assembly: CloudAssembly = workload.synth()
+
+        print("☁️ cloud assembly dir", assembly.directory)
+
+        return assembly
+
+    def _detect_project_root(self) -> str:
+        """
+        Detect project root directory for proper cdk.out placement
+
+        Priority:
+        1. CODEBUILD_SRC_DIR (CodeBuild environment)
+        2. Find project markers (pyproject.toml, package.json, .git, etc.)
+        3. Assume devops/cdk-iac structure (go up 2 levels)
+        4. Fallback to runtime_directory
+
+        Returns:
+            str: Absolute path to project root
+        """
+        # Priority 1: CodeBuild environment (most reliable)
+        codebuild_src = os.getenv("CODEBUILD_SRC_DIR")
+        if codebuild_src:
+            return str(Path(codebuild_src).resolve())
+
+        # Priority 2: Look for project root markers
+        # CodeBuild often gets zip without .git, so check multiple markers
+        current = Path(self.runtime_directory).resolve()
+
+        # Walk up the directory tree looking for root markers
+        for parent in [current] + list(current.parents):
+            # Check for common project root indicators
+            root_markers = [
+                ".git",  # Git repo (local dev)
+                "pyproject.toml",  # Python project root
+                "package.json",  # Node project root
+                "Cargo.toml",  # Rust project root
+                ".gitignore",  # Often at root
+                "README.md",  # Often at root
+                "requirements.txt",  # Python dependencies
+            ]
+
+            # If we find multiple markers at this level, it's likely the root
+            markers_found = sum(
+                1 for marker in root_markers if (parent / marker).exists()
+            )
+            if markers_found >= 2 and parent != current:
+                return str(parent)
+
+        # Priority 3: Assume devops/cdk-iac structure
+        # If runtime_directory ends with devops/cdk-iac, go up 2 levels
+        parts = current.parts
+        if len(parts) >= 2 and parts[-2:] == ("devops", "cdk-iac"):
+            return str(current.parent.parent)
+
+        # Also try just 'cdk-iac' or 'devops'
+        if len(parts) >= 1 and parts[-1] in (
+            "cdk-iac",
+            "devops",
+            "infrastructure",
+            "iac",
+        ):
+            # Go up until we're not in these directories
+            potential_root = current.parent
+            while potential_root.name in ("devops", "cdk-iac", "infrastructure", "iac"):
+                potential_root = potential_root.parent
+            return str(potential_root)
+
+        # Priority 4: Fallback to runtime_directory
+        return str(current)
+
+    def _check_if_pipeline_deployment(self, config_path: str | None) -> bool:
+        """
+        Check if the configuration includes pipeline deployments with CI/CD enabled.
+        Returns True if pipelines are detected, False otherwise.
+        """
+        if not config_path or not os.path.exists(config_path):
+            return False
+        
+        try:
+            import json
+            with open(config_path, 'r') as f:
+                config = json.load(f)
+            
+            # Check for workload.deployments with CI/CD enabled
+            workload = config.get('workload', {})
+            deployments = workload.get('deployments', [])
+            
+            for deployment in deployments:
+                devops = deployment.get('devops', {})
+                ci_cd = devops.get('ci_cd', {})
+                if ci_cd.get('enabled', False):
+                    return True
+            
+            return False
+        except:
+            # If we can't read/parse the config, assume not a pipeline
+            return False
+
+
+if __name__ == "__main__":
+    # deploy_test()
+    cmd_args: CommandlineArgs = CommandlineArgs()
+    cdk_app: CdkAppFactory = CdkAppFactory(args=cmd_args)
+    cdk_app.synth()

cdk_factory-0.9.0/src/cdk_factory/cli.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""
+CDK Factory CLI
+
+Provides convenience commands for initializing and managing cdk-factory projects.
+"""
+
+import argparse
+import os
+import shutil
+from pathlib import Path
+from typing import Optional
+
+
+class CdkFactoryCLI:
+    """CLI for cdk-factory project management"""
+    
+    def __init__(self):
+        self.package_root = Path(__file__).parent.resolve()
+        self.templates_dir = self.package_root / "templates"
+        
+        # Verify templates directory exists
+        if not self.templates_dir.exists():
+            raise RuntimeError(
+                f"Templates directory not found at {self.templates_dir}. "
+                "Please ensure cdk-factory is properly installed."
+            )
+    
+    def init_project(
+        self,
+        target_dir: str,
+        workload_name: Optional[str] = None,
+        environment: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize a new cdk-factory project
+        
+        Args:
+            target_dir: Directory to initialize (e.g., devops/cdk-iac)
+            workload_name: Name of the workload (optional)
+            environment: Environment name (optional)
+        """
+        target_path = Path(target_dir).resolve()
+        
+        if not target_path.exists():
+            target_path.mkdir(parents=True, exist_ok=True)
+            print(f"✅ Created directory: {target_path}")
+        
+        # Copy app.py template
+        app_template = self.templates_dir / "app.py.template"
+        app_dest = target_path / "app.py"
+        
+        if app_dest.exists():
+            response = input(f"⚠️  {app_dest} already exists. Overwrite? (y/N): ")
+            if response.lower() != 'y':
+                print("Skipped app.py")
+            else:
+                shutil.copy(app_template, app_dest)
+                print(f"✅ Created {app_dest}")
+        else:
+            shutil.copy(app_template, app_dest)
+            print(f"✅ Created {app_dest}")
+        
+        # Copy cdk.json template
+        cdk_json_template = self.templates_dir / "cdk.json.template"
+        cdk_json_dest = target_path / "cdk.json"
+        
+        if cdk_json_dest.exists():
+            print(f"⚠️  {cdk_json_dest} already exists. Skipping.")
+        else:
+            shutil.copy(cdk_json_template, cdk_json_dest)
+            print(f"✅ Created {cdk_json_dest}")
+        
+        # Create minimal config.json
+        config_dest = target_path / "config.json"
+        if config_dest.exists():
+            print(f"⚠️  {config_dest} already exists. Skipping.")
+        else:
+            self._create_minimal_config(
+                config_dest,
+                workload_name=workload_name,
+                environment=environment
+            )
+            print(f"✅ Created {config_dest}")
+        
+        # Create .gitignore
+        gitignore_dest = target_path / ".gitignore"
+        if not gitignore_dest.exists():
+            gitignore_dest.write_text("cdk.out/\n*.swp\n.DS_Store\n__pycache__/\n")
+            print(f"✅ Created {gitignore_dest}")
+        
+        print("\n✨ Project initialized successfully!")
+        print(f"\nNext steps:")
+        print(f"1. cd {target_path}")
+        print(f"2. Edit config.json to configure your infrastructure")
+        print(f"3. Run: cdk synth")
+        print(f"4. Run: cdk deploy")
+    
+    def _create_minimal_config(
+        self,
+        path: Path,
+        workload_name: Optional[str] = None,
+        environment: Optional[str] = None
+    ) -> None:
+        """Create a minimal config.json template"""
+        config = {
+            "cdk": {
+                "parameters": [
+                    {
+                        "placeholder": "{{ENVIRONMENT}}",
+                        "env_var_name": "ENVIRONMENT",
+                        "cdk_parameter_name": "Environment"
+                    },
+                    {
+                        "placeholder": "{{WORKLOAD_NAME}}",
+                        "env_var_name": "WORKLOAD_NAME",
+                        "cdk_parameter_name": "WorkloadName"
+                    },
+                    {
+                        "placeholder": "{{AWS_ACCOUNT}}",
+                        "env_var_name": "AWS_ACCOUNT",
+                        "cdk_parameter_name": "AccountNumber"
+                    },
+                    {
+                        "placeholder": "{{AWS_REGION}}",
+                        "env_var_name": "AWS_REGION",
+                        "cdk_parameter_name": "AccountRegion"
+                    }
+                ]
+            },
+            "workload": {
+                "name": workload_name or "{{WORKLOAD_NAME}}",
+                "environment": environment or "{{ENVIRONMENT}}",
+                "deployments": []
+            }
+        }
+        
+        import json
+        path.write_text(json.dumps(config, indent=2))
+    
+    def list_templates(self) -> None:
+        """List available templates"""
+        print("Available templates:")
+        if self.templates_dir.exists():
+            for template in self.templates_dir.glob("*.template"):
+                print(f"  - {template.name}")
+        else:
+            print("  No templates found")
+
+
+def main():
+    """CLI entry point"""
+    parser = argparse.ArgumentParser(
+        description="CDK Factory CLI - Initialize and manage cdk-factory projects"
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    
+    # Init command
+    init_parser = subparsers.add_parser(
+        "init",
+        help="Initialize a new cdk-factory project"
+    )
+    init_parser.add_argument(
+        "directory",
+        help="Target directory (e.g., devops/cdk-iac)"
+    )
+    init_parser.add_argument(
+        "--workload-name",
+        help="Workload name"
+    )
+    init_parser.add_argument(
+        "--environment",
+        help="Environment (dev, prod, etc.)"
+    )
+    
+    # List templates command
+    subparsers.add_parser(
+        "list-templates",
+        help="List available templates"
+    )
+    
+    args = parser.parse_args()
+    
+    cli = CdkFactoryCLI()
+    
+    if args.command == "init":
+        cli.init_project(
+            args.directory,
+            workload_name=args.workload_name,
+            environment=args.environment
+        )
+    elif args.command == "list-templates":
+        cli.list_templates()
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

{cdk_factory-0.8.8 → cdk_factory-0.9.0}/src/cdk_factory/pipeline/pipeline_factory.py

@@ -3,6 +3,7 @@ Geek Cafe Pipeline
 """
 
 import os
+from pathlib import Path
 from typing import List, Dict, Any
 
 import aws_cdk as cdk
@@ -359,9 +360,17 @@ class PipelineFactoryStack(cdk.Stack):
         build_commands = self._get_build_commands()
 
         cdk_out_directory = self.workload.output_directory
+        
+        # CdkAppFactory already provides the correct path:
+        # - For pipelines: relative path (e.g., "../../cdk.out" or "cdk.out")
+        # - For local: absolute path (but this code only runs for pipelines)
+        # If somehow we get an absolute path, convert it to just the basename
+        if cdk_out_directory and os.path.isabs(cdk_out_directory):
+            # Fallback: just use the last component
+            cdk_out_directory = os.path.basename(cdk_out_directory)
 
         build_commands.append(f"echo 👉 cdk_directory: {cdk_directory}")
-        build_commands.append(f"echo 👉 cdk_out_directory: {cdk_out_directory}")
+        build_commands.append(f"echo 👉 cdk_out_directory (relative): {cdk_out_directory}")
         build_commands.append("echo 👉 PWD from synth shell step: ${PWD}")
 
         shell = pipelines.ShellStep(

cdk_factory-0.9.0/src/cdk_factory/templates/README.md

@@ -0,0 +1,99 @@
+# CDK Factory Templates
+
+This directory contains templates for initializing new cdk-factory projects.
+
+## Available Templates
+
+- **`app.py.template`** - Standard application entry point
+- **`cdk.json.template`** - CDK configuration file
+
+## Usage
+
+### Method 1: Using the CLI (Recommended)
+
+```bash
+# Install cdk-factory with CLI support
+pip install cdk-factory
+
+# Initialize a new project
+cdk-factory init devops/cdk-iac --workload-name my-app --environment dev
+
+# This creates:
+# - devops/cdk-iac/app.py
+# - devops/cdk-iac/cdk.json
+# - devops/cdk-iac/config.json (minimal template)
+# - devops/cdk-iac/.gitignore
+```
+
+### Method 2: Manual Copy
+
+```bash
+# Copy templates manually
+cp templates/app.py.template your-project/devops/cdk-iac/app.py
+cp templates/cdk.json.template your-project/devops/cdk-iac/cdk.json
+
+# Create config.json (see examples/)
+```
+
+## Template Variables
+
+The templates use minimal configuration. All settings are driven by:
+
+1. **Environment Variables** - `AWS_ACCOUNT`, `AWS_REGION`, `WORKLOAD_NAME`, etc.
+2. **CDK Context** - Pass via `-c` flag: `cdk deploy -c WorkloadName=my-app`
+3. **config.json** - Your infrastructure configuration
+
+## Project Structure
+
+After initialization, your project should look like:
+
+```
+your-project/
+├── devops/
+│   └── cdk-iac/
+│       ├── app.py           # Entry point (from template)
+│       ├── cdk.json         # CDK config (from template)
+│       ├── config.json      # Your infrastructure config
+│       ├── .gitignore       # Generated
+│       └── commands/        # Your build scripts (optional)
+│           ├── docker-build.sh
+│           └── docker-build.py
+├── src/                     # Your application code
+└── Dockerfile               # Your docker config
+```
+
+## Customization
+
+The templates are intentionally minimal. You can:
+
+1. ✅ Add custom environment variables
+2. ✅ Modify config.json structure
+3. ✅ Add project-specific initialization in app.py
+4. ❌ Don't modify core path resolution logic (it's environment-agnostic)
+
+## Integration with pyproject.toml
+
+To enable the CLI, update `pyproject.toml`:
+
+```toml
+[project.scripts]
+cdk-factory = "cdk_factory.cli:main"
+```
+
+Or in `setup.py`:
+
+```python
+entry_points={
+    'console_scripts': [
+        'cdk-factory=cdk_factory.cli:main',
+    ],
+}
+```
+
+## Benefits
+
+✅ **No boilerplate** - Standard entry point across all projects  
+✅ **Environment-agnostic** - Works locally and in CI/CD  
+✅ **Consistent** - All projects follow same pattern  
+✅ **Maintainable** - Updates to template benefit all projects  
+✅ **Simple** - Just 30 lines of code in app.py

cdk_factory-0.9.0/src/cdk_factory/templates/app.py.template

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""
+CDK Factory Application Entry Point
+
+This is the standard entry point for any cdk-factory based project.
+All configuration is driven by environment variables and CDK context.
+
+To use this template:
+1. Copy to your project's CDK directory (e.g., devops/cdk-iac/app.py)
+2. Update cdk.json to reference this file: "app": "python app.py"
+3. Create your config.json
+4. Run: cdk synth
+
+Note: cdk.out is automatically placed at project root for CodeBuild compatibility.
+"""
+
+import os
+from pathlib import Path
+from cdk_factory.app import CdkAppFactory
+
+
+if __name__ == "__main__":
+    # Runtime directory (where this file lives)
+    runtime_dir = str(Path(__file__).parent.resolve())
+    
+    # Configuration (Priority: ENV > CDK Context > default)
+    config_path = os.getenv('CDK_CONFIG_PATH', 'config.json')
+    
+    # Create and synth
+    # outdir is automatically set to project_root/cdk.out
+    factory = CdkAppFactory(
+        config_path=config_path,
+        runtime_directory=runtime_dir
+    )
+    
+    factory.synth(cdk_app_file=__file__)

cdk_factory-0.9.0/src/cdk_factory/templates/cdk.json.template

@@ -0,0 +1,73 @@
+{
+  "app": "python app.py",
+  "watch": {
+    "include": [
+      "**"
+    ],
+    "exclude": [
+      "README.md",
+      "cdk*.json",
+      "requirements*.txt",
+      "source.bat",
+      "**/__init__.py",
+      "**/__pycache__",
+      "**/.pytest_cache",
+      ".git",
+      ".venv"
+    ]
+  },
+  "context": {
+    "@aws-cdk/aws-lambda:recognizeLayerVersion": true,
+    "@aws-cdk/core:checkSecretUsage": true,
+    "@aws-cdk/core:target-partitions": [
+      "aws",
+      "aws-cn"
+    ],
+    "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": true,
+    "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": true,
+    "@aws-cdk/aws-ecs:arnFormatIncludesClusterName": true,
+    "@aws-cdk/aws-iam:minimizePolicies": true,
+    "@aws-cdk/core:validateSnapshotRemovalPolicy": true,
+    "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": true,
+    "@aws-cdk/aws-s3:createDefaultLoggingPolicy": true,
+    "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": true,
+    "@aws-cdk/aws-apigateway:disableCloudWatchRole": true,
+    "@aws-cdk/core:enablePartitionLiterals": true,
+    "@aws-cdk/aws-events:eventsTargetQueueSameAccount": true,
+    "@aws-cdk/aws-iam:standardizedServicePrincipals": true,
+    "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": true,
+    "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName": true,
+    "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": true,
+    "@aws-cdk/aws-route53-patters:useCertificate": true,
+    "@aws-cdk/customresources:installLatestAwsSdkDefault": false,
+    "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": true,
+    "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup": true,
+    "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId": true,
+    "@aws-cdk/aws-ec2:launchTemplateDefaultUserData": true,
+    "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments": true,
+    "@aws-cdk/aws-redshift:columnId": true,
+    "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2": true,
+    "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": true,
+    "@aws-cdk/aws-apigateway:requestValidatorUniqueId": true,
+    "@aws-cdk/aws-kms:aliasNameRef": true,
+    "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": true,
+    "@aws-cdk/core:includePrefixInUniqueNameGeneration": true,
+    "@aws-cdk/aws-efs:denyAnonymousAccess": true,
+    "@aws-cdk/aws-opensearchservice:enableOpensearchMultiAzWithStandby": true,
+    "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion": true,
+    "@aws-cdk/aws-efs:mountTargetOrderInsensitiveLogicalId": true,
+    "@aws-cdk/aws-rds:auroraClusterChangeScopeOfInstanceParameterGroupWithEachParameters": true,
+    "@aws-cdk/aws-appsync:useArnForSourceApiAssociationIdentifier": true,
+    "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials": true,
+    "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForCodeCommitSource": true,
+    "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction": true,
+    "@aws-cdk/aws-codepipeline:crossAccountKeysDefaultValueToFalse": true,
+    "@aws-cdk/aws-codepipeline:defaultPipelineTypeToV2": true,
+    "@aws-cdk/aws-kms:reduceCrossAccountRegionPolicyScope": true,
+    "@aws-cdk/aws-eks:nodegroupNameAttribute": true,
+    "@aws-cdk/aws-ec2:ebsDefaultGp3Volume": true,
+    "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm": true,
+    "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault": false,
+    "@aws-cdk/aws-s3:keepNotificationInImportedBucket": false
+  }
+}

cdk_factory-0.9.0/src/cdk_factory/version.py

@@ -0,0 +1 @@
+__version__ = "0.9.0"