cdk-factory 0.8.8__py3-none-any.whl → 0.9.1__py3-none-any.whl

cdk_factory/app.py

@@ -25,14 +25,51 @@ class CdkAppFactory:
         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.outdir = outdir or self.args.outdir
-        self.app: aws_cdk.App = aws_cdk.App()
         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:
+            # 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/CodeBuild: calculate relative path to project_root/cdk.out
+                # This ensures cdk.out is at project root and works in CodeBuild
+                project_root = self._detect_project_root()
+                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 CDK default (./cdk.out in current directory)
+                # This allows CDK CLI to find it when running from any directory
+                self.outdir = None
+        else:
+            self.outdir = outdir or self.args.outdir
+        
+        self.app: aws_cdk.App = aws_cdk.App(outdir=self.outdir)
 
     def synth(
         self,
@@ -84,6 +121,98 @@ class CdkAppFactory:
 
         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()

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/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/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/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/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/version.py

@@ -1 +1 @@
-__version__ = "0.8.8"
+__version__ = "0.9.1"

{cdk_factory-0.8.8.dist-info → cdk_factory-0.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.8.8
+Version: 0.9.1
 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.dist-info → cdk_factory-0.9.1.dist-info}/RECORD

@@ -1,7 +1,8 @@
 cdk_factory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/app.py,sha256=xv863N7O6HPKznB68_t7O4la9JacrkG87t9TjoDUk7s,2827
+cdk_factory/app.py,sha256=OXySeuN9YYwZmNkc9oKIAnwZSw8Vpta5MIWfwhMkmPY,8444
 cdk_factory/cdk.json,sha256=SKZKhJ2PBpFH78j-F8S3VDYW-lf76--Q2I3ON-ZIQfw,3106
-cdk_factory/version.py,sha256=S5bBAK8bL7bybaXGJQuNE98fa3H65zGjTASMiyKGJGw,22
+cdk_factory/cli.py,sha256=FGbCTS5dYCNsfp-etshzvFlGDCjC28r6rtzYbe7KoHI,6407
+cdk_factory/version.py,sha256=UwJXM8JY2T3tE2id0K2k_lEaVThbRTrGO1mNibyzIz8,22
 cdk_factory/builds/README.md,sha256=9BBWd7bXpyKdMU_g2UljhQwrC9i5O_Tvkb6oPvndoZk,90
 cdk_factory/commands/command_loader.py,sha256=QbLquuP_AdxtlxlDy-2IWCQ6D-7qa58aphnDPtp_uTs,3744
 cdk_factory/configurations/base_config.py,sha256=JKjhNsy0RCUZy1s8n5D_aXXI-upR9izaLtCTfKYiV9k,9624
@@ -63,7 +64,7 @@ cdk_factory/interfaces/istack.py,sha256=bhTBs-o9FgKwvJMSuwxjUV6D3nUlvZHVzfm27jP9
 cdk_factory/interfaces/live_ssm_resolver.py,sha256=3FIr9a02SXqZmbFs3RT0WxczWEQR_CF7QSt7kWbDrVE,8163
 cdk_factory/interfaces/ssm_parameter_mixin.py,sha256=uA2j8HmAOpuEA9ynRj51s0WjUHMVLsbLQN-QS9NKyHA,12089
 cdk_factory/lambdas/health_handler.py,sha256=dd40ykKMxWCFEIyp2ZdQvAGNjw_ylI9CSm1N24Hp2ME,196
-cdk_factory/pipeline/pipeline_factory.py,sha256=OuL1pOWjThIMDYqZEBbqLzg8KK9A84qtjRMPJwnX-kk,15956
+cdk_factory/pipeline/pipeline_factory.py,sha256=NSyuADuVPsmNeo7-uoRZJrnn_KVdHzwXjLKLUcsJwRA,16480
 cdk_factory/pipeline/stage.py,sha256=Be7ExMB9A-linRM18IQDOzQ-cP_I2_ThRNzlT4FIrUg,437
 cdk_factory/pipeline/security/policies.py,sha256=H3-S6nipz3UtF9Pc5eJYr4-aREUTCaJWMjOUyd6Rdv4,4406
 cdk_factory/pipeline/security/roles.py,sha256=ZB_O5H_BXgotvVspS2kVad9EMcY-a_-vU7Nm1_Z5MB8,4985
@@ -103,6 +104,9 @@ cdk_factory/stack_library/vpc/__init__.py,sha256=7pIqP97Gf2AJbv9Ebp1WbQGHYhgEbWJ
 cdk_factory/stack_library/vpc/vpc_stack.py,sha256=zdDiGilf03esxuya5Z8zVYSVMAIuZBeD-ZKgfnEd6aw,10077
 cdk_factory/stack_library/websites/static_website_stack.py,sha256=KBQiV6PI09mpHGtH-So5Hk3uhfFLDepoXInGbfin0cY,7938
 cdk_factory/stages/websites/static_website_stage.py,sha256=X4fpKXkhb0zIbSHx3QyddBhVSLBryb1vf1Cg2fMTqog,755
+cdk_factory/templates/README.md,sha256=ATBEjG6beYvbEAdLtZ_8xnxgFD5X0cgZoI_6pToqH90,2679
+cdk_factory/templates/app.py.template,sha256=aM60x0nNV80idtCL8jm1EddY63F5tDITYOlavg-BPMU,1069
+cdk_factory/templates/cdk.json.template,sha256=SuGz4Y6kCVMDRpJrA_AJlp0kwdENiJPVngIv1xP5bwI,3526
 cdk_factory/utilities/api_gateway_integration_utility.py,sha256=yblKiMIHGXqKb7JK5IbzGM_TXjX9j893BMqgqBT44DE,63449
 cdk_factory/utilities/commandline_args.py,sha256=0FiNEJFbWVN8Ct7r0VHnJEx7rhUlaRKT7R7HMNJBSTI,2216
 cdk_factory/utilities/configuration_loader.py,sha256=z0ZdGLNbTO4_yfluB9zUh_i_Poc9qj-7oRyjMRlNkN8,1522
@@ -115,7 +119,8 @@ cdk_factory/utilities/lambda_function_utilities.py,sha256=S1GvBsY_q2cyUiaud3HORJ
 cdk_factory/utilities/os_execute.py,sha256=5Op0LY_8Y-pUm04y1k8MTpNrmQvcLmQHPQITEP7EuSU,1019
 cdk_factory/utils/api_gateway_utilities.py,sha256=If7Xu5s_UxmuV-kL3JkXxPLBdSVUKoLtohm0IUFoiV8,4378
 cdk_factory/workload/workload_factory.py,sha256=yBUDGIuB8-5p_mGcVFxsD2ZoZIziak3yh3LL3JvS0M4,5903
-cdk_factory-0.8.8.dist-info/METADATA,sha256=snclFyCZwqRqLmxauiDny56lUUnERMnVSNYvMGKZWG8,2450
-cdk_factory-0.8.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cdk_factory-0.8.8.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
-cdk_factory-0.8.8.dist-info/RECORD,,
+cdk_factory-0.9.1.dist-info/METADATA,sha256=ROeQUXNIHdxp8W7V8J-b-VjAafq9N0CHLNHSUmP9f0c,2450
+cdk_factory-0.9.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdk_factory-0.9.1.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
+cdk_factory-0.9.1.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
+cdk_factory-0.9.1.dist-info/RECORD,,

cdk_factory-0.9.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cdk-factory = cdk_factory.cli:main