fast-clean-architecture 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

fast_clean_architecture/utils.py

@@ -2,14 +2,19 @@
 
 import keyword
 import re
-import urllib.parse
-import unicodedata
 import threading
-import fcntl
-import os
+import unicodedata
+import urllib.parse
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from .exceptions import (
+    SecurityError,
+    ValidationError,
+    create_secure_error,
+    create_validation_error,
+)
 
 
 def generate_timestamp() -> str:
@@ -42,7 +47,12 @@ def get_file_lock(file_path: Union[str, Path]) -> threading.Lock:
         return _file_locks[file_path_str]
 
 
-def secure_file_operation(file_path: Union[str, Path], operation_func, *args, **kwargs):
+def secure_file_operation(
+    file_path: Union[str, Path],
+    operation_func: Callable[..., Any],
+    *args: Any,
+    **kwargs: Any,
+) -> Any:
     """Execute file operation with proper locking."""
     lock = get_file_lock(file_path)
     with lock:
@@ -61,7 +71,7 @@ def sanitize_error_message(
         r"/Users/[^/\s]+",  # User home directories
         r"/home/[^/\s]+",  # Linux home directories
         r"C:\\Users\\[^\\\s]+",  # Windows user directories
-        r"/tmp/[^/\s]+",  # Temporary directories
+        r"/tmp/[^/\s]+",  # Temporary directories  # nosec B108
         r"/var/[^/\s]+",  # System directories
         r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b",  # IP addresses
     ]
@@ -76,18 +86,20 @@ def sanitize_error_message(
     return sanitized_msg
 
 
-def create_secure_error(error_type: str, operation: str, details: Optional[str] = None):
+def create_secure_error_message(
+    error_type: str, operation: str, details: Optional[str] = None
+) -> str:
     """Create a secure error message without exposing sensitive information."""
-    from fast_clean_architecture.exceptions import ValidationError
+    import os
 
     base_msg = f"Failed to {operation}"
-
     if details:
-        # Sanitize details before including
-        safe_details = sanitize_error_message(details)
-        return ValidationError(f"{base_msg}: {safe_details}")
-
-    return ValidationError(base_msg)
+        # Sanitize details to prevent information leakage
+        safe_details = details.replace(os.path.expanduser("~"), "<HOME>")
+        safe_details = re.sub(r"/Users/[^/]+", "/Users/<USER>", safe_details)
+        safe_details = re.sub(r"\\Users\\[^\\]+", "\\Users\\<USER>", safe_details)
+        return f"{base_msg}: {safe_details}"
+    return base_msg
 
 
 def to_snake_case(name: str) -> str:
@@ -220,18 +232,20 @@ def validate_name(name: str) -> None:
         decoded_name = urllib.parse.unquote(name)
         # Apply Unicode normalization to handle Unicode attacks
         normalized_name = unicodedata.normalize("NFKC", decoded_name)
-    except Exception:
+    except (ValueError, UnicodeDecodeError, UnicodeError):
         # If decoding fails, treat as suspicious
-        raise ValidationError(
-            f"Invalid component name: suspicious encoding detected in '{name}'"
+        raise create_secure_error(
+            "encoding_attack",
+            "name validation",
+            f"Suspicious encoding detected in component name: {name[:50]}",
         )
 
     # Check for path traversal in original, decoded, and normalized forms
     names_to_check = [name, decoded_name, normalized_name]
     for check_name in names_to_check:
         if ".." in check_name or "/" in check_name or "\\" in check_name:
-            raise ValidationError(
-                f"Invalid component name: path traversal detected in '{name}'"
+            raise create_secure_error(
+                "path_traversal", "name validation", "Path traversal pattern detected"
             )
 
     # Check for encoded path traversal sequences
@@ -252,8 +266,10 @@ def validate_name(name: str) -> None:
     name_lower = name.lower()
     for pattern in encoded_patterns:
         if pattern in name_lower:
-            raise ValidationError(
-                f"Invalid component name: encoded path traversal detected in '{name}'"
+            raise create_secure_error(
+                "encoded_path_traversal",
+                "name validation",
+                "Encoded path traversal sequence detected",
             )
 
     # Check for Unicode path traversal variants
@@ -264,14 +280,18 @@ def validate_name(name: str) -> None:
     for dot in unicode_dots:
         for dot2 in unicode_dots:
             if dot + dot2 in name:
-                raise ValidationError(
-                    f"Invalid component name: Unicode path traversal detected in '{name}'"
+                raise create_secure_error(
+                    "unicode_path_traversal",
+                    "name validation",
+                    "Unicode path traversal pattern detected",
                 )
 
     for slash in unicode_slashes + unicode_backslashes:
         if slash in name:
-            raise ValidationError(
-                f"Invalid component name: Unicode path separator detected in '{name}'"
+            raise create_secure_error(
+                "unicode_path_separator",
+                "name validation",
+                "Unicode path separator detected",
             )
 
     # Check for shell injection attempts
@@ -347,8 +367,8 @@ def get_template_variables(
     module_name: str,
     component_name: str,
     component_type: str,
-    **kwargs,
-) -> dict:
+    **kwargs: Any,
+) -> Dict[str, Any]:
     """Generate template variables for rendering."""
     snake_name = to_snake_case(component_name)
     pascal_name = to_pascal_case(component_name)
@@ -489,7 +509,6 @@ def get_component_type_from_path(path: str) -> Optional[str]:
         "queries",  # application
         "models",
         "external",
-        "internal",  # infrastructure
         "api",
         "schemas",  # presentation
     ]
@@ -503,7 +522,7 @@ def get_component_type_from_path(path: str) -> Optional[str]:
     return None
 
 
-def parse_location_path(location: str) -> dict[str, str]:
+def parse_location_path(location: str) -> Dict[str, str]:
     """Parse location path to extract system, module, layer, and component type.
 
     Args:
@@ -535,7 +554,7 @@ def parse_location_path(location: str) -> dict[str, str]:
     layer_components = {
         "domain": ["entities", "repositories", "value_objects"],
         "application": ["services", "commands", "queries"],
-        "infrastructure": ["models", "repositories", "external", "internal"],
+        "infrastructure": ["models", "repositories", "external"],
         "presentation": ["api", "schemas"],
     }
 

fast_clean_architecture/validation.py

@@ -0,0 +1,302 @@
+"""Validation utilities for Fast Clean Architecture."""
+
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Pattern, Set, Union
+
+from .exceptions import Result, SecurityError, ValidationError
+
+
+class ValidationRules:
+    """Centralized validation rules and patterns."""
+
+    # Component naming patterns
+    COMPONENT_NAME_PATTERN: Pattern[str] = re.compile(r"^[a-zA-Z][a-zA-Z0-9_]*$")
+    SYSTEM_NAME_PATTERN: Pattern[str] = re.compile(r"^[a-zA-Z][a-zA-Z0-9_-]*$")
+    MODULE_NAME_PATTERN: Pattern[str] = re.compile(r"^[a-zA-Z][a-zA-Z0-9_]*$")
+
+    # Security patterns
+    DANGEROUS_PATH_PATTERNS: List[Pattern[str]] = [
+        re.compile(r"\.\."),  # Path traversal
+        re.compile(r"^/etc/|^/root/|^/proc/|^/sys/"),  # Dangerous system paths only
+        re.compile(r"^~"),  # Home directory
+        re.compile(r"\$\{"),  # Variable expansion
+        re.compile(r"\$\("),  # Command substitution
+    ]
+
+    # Valid component types and layers
+    VALID_LAYERS: Set[str] = {"domain", "application", "infrastructure", "presentation"}
+
+    VALID_COMPONENT_TYPES: Set[str] = {
+        "entities",
+        "repositories",
+        "services",
+        "controllers",
+        "models",
+        "views",
+        "adapters",
+        "gateways",
+        "external",
+    }
+
+    # File extension validation
+    ALLOWED_EXTENSIONS: Set[str] = {
+        ".py",
+        ".yaml",
+        ".yml",
+        ".json",
+        ".md",
+        ".txt",
+        ".toml",
+    }
+
+
+class Validator:
+    """Main validation class with comprehensive checks."""
+
+    @staticmethod
+    def validate_component_name(name: str) -> Result[str, ValidationError]:
+        """Validate component name format."""
+        if not name:
+            return Result.failure(
+                ValidationError(
+                    "Component name cannot be empty", context={"name": name}
+                )
+            )
+
+        if not ValidationRules.COMPONENT_NAME_PATTERN.match(name):
+            return Result.failure(
+                ValidationError(
+                    f"Invalid component name format: {name}. Must start with letter and contain only letters, numbers, and underscores.",
+                    context={
+                        "name": name,
+                        "pattern": ValidationRules.COMPONENT_NAME_PATTERN.pattern,
+                    },
+                )
+            )
+
+        if len(name) > 50:
+            return Result.failure(
+                ValidationError(
+                    f"Component name too long: {len(name)} characters. Maximum 50 allowed.",
+                    context={"name": name, "length": len(name)},
+                )
+            )
+
+        return Result.success(name)
+
+    @staticmethod
+    def validate_system_name(name: str) -> Result[str, ValidationError]:
+        """Validate system name format."""
+        if not name:
+            return Result.failure(
+                ValidationError("System name cannot be empty", context={"name": name})
+            )
+
+        if not ValidationRules.SYSTEM_NAME_PATTERN.match(name):
+            return Result.failure(
+                ValidationError(
+                    f"Invalid system name format: {name}. Must start with letter and contain only letters, numbers, underscores, and hyphens.",
+                    context={
+                        "name": name,
+                        "pattern": ValidationRules.SYSTEM_NAME_PATTERN.pattern,
+                    },
+                )
+            )
+
+        return Result.success(name)
+
+    @staticmethod
+    def validate_module_name(name: str) -> Result[str, ValidationError]:
+        """Validate module name format."""
+        if not name:
+            return Result.failure(
+                ValidationError("Module name cannot be empty", context={"name": name})
+            )
+
+        if not ValidationRules.MODULE_NAME_PATTERN.match(name):
+            return Result.failure(
+                ValidationError(
+                    f"Invalid module name format: {name}. Must start with letter and contain only letters, numbers, and underscores.",
+                    context={
+                        "name": name,
+                        "pattern": ValidationRules.MODULE_NAME_PATTERN.pattern,
+                    },
+                )
+            )
+
+        return Result.success(name)
+
+    @staticmethod
+    def validate_layer(layer: str) -> Result[str, ValidationError]:
+        """Validate layer name."""
+        if layer not in ValidationRules.VALID_LAYERS:
+            return Result.failure(
+                ValidationError(
+                    f"Invalid layer: {layer}. Must be one of: {', '.join(sorted(ValidationRules.VALID_LAYERS))}",
+                    context={
+                        "layer": layer,
+                        "valid_layers": list(ValidationRules.VALID_LAYERS),
+                    },
+                )
+            )
+
+        return Result.success(layer)
+
+    @staticmethod
+    def validate_component_type(component_type: str) -> Result[str, ValidationError]:
+        """Validate component type."""
+        if component_type not in ValidationRules.VALID_COMPONENT_TYPES:
+            return Result.failure(
+                ValidationError(
+                    f"Invalid component type: {component_type}. Must be one of: {', '.join(sorted(ValidationRules.VALID_COMPONENT_TYPES))}",
+                    context={
+                        "component_type": component_type,
+                        "valid_types": list(ValidationRules.VALID_COMPONENT_TYPES),
+                    },
+                )
+            )
+
+        return Result.success(component_type)
+
+    @staticmethod
+    def validate_file_path(file_path: Union[str, Path]) -> Result[Path, SecurityError]:
+        """Validate file path for security issues."""
+        path_str = str(file_path)
+
+        # Check for dangerous patterns
+        for pattern in ValidationRules.DANGEROUS_PATH_PATTERNS:
+            if pattern.search(path_str):
+                return Result.failure(
+                    SecurityError(
+                        f"Potentially dangerous path pattern detected: {path_str}",
+                        context={"path": path_str, "pattern": pattern.pattern},
+                    )
+                )
+
+        # Convert to Path object
+        try:
+            path_obj = Path(path_str)
+        except Exception as e:
+            return Result.failure(
+                SecurityError(
+                    f"Invalid path format: {path_str}",
+                    context={"path": path_str, "error": str(e)},
+                )
+            )
+
+        # Check file extension
+        if (
+            path_obj.suffix
+            and path_obj.suffix not in ValidationRules.ALLOWED_EXTENSIONS
+        ):
+            return Result.failure(
+                SecurityError(
+                    f"File extension not allowed: {path_obj.suffix}",
+                    context={
+                        "path": path_str,
+                        "extension": path_obj.suffix,
+                        "allowed": list(ValidationRules.ALLOWED_EXTENSIONS),
+                    },
+                )
+            )
+
+        return Result.success(path_obj)
+
+    @staticmethod
+    def validate_description(
+        description: str, max_length: int = 500
+    ) -> Result[str, Union[ValidationError, SecurityError]]:
+        """Validate description text."""
+        if len(description) > max_length:
+            return Result.failure(
+                ValidationError(
+                    f"Description too long: {len(description)} characters. Maximum {max_length} allowed.",
+                    context={
+                        "description": description[:100] + "...",
+                        "length": len(description),
+                        "max_length": max_length,
+                    },
+                )
+            )
+
+        # Check for potentially dangerous content
+        dangerous_patterns = ["<script", "${", "$(", "javascript:"]
+        for pattern in dangerous_patterns:
+            if pattern.lower() in description.lower():
+                return Result.failure(
+                    SecurityError(
+                        f"Potentially dangerous content in description: {pattern}",
+                        context={
+                            "description": description[:100] + "...",
+                            "pattern": pattern,
+                        },
+                    )
+                )
+
+        return Result.success(description)
+
+    @classmethod
+    def validate_component_creation(
+        cls,
+        system_name: str,
+        module_name: str,
+        layer: str,
+        component_type: str,
+        component_name: str,
+        file_path: Optional[Union[str, Path]] = None,
+        description: Optional[str] = None,
+    ) -> Result[Dict[str, Any], Union[ValidationError, SecurityError]]:
+        """Comprehensive validation for component creation."""
+
+        # Validate all required fields
+        system_validation = cls.validate_system_name(system_name)
+        if system_validation.is_failure:
+            return system_validation  # type: ignore
+
+        module_validation = cls.validate_module_name(module_name)
+        if module_validation.is_failure:
+            return module_validation  # type: ignore
+
+        layer_validation = cls.validate_layer(layer)
+        if layer_validation.is_failure:
+            return layer_validation  # type: ignore
+
+        component_type_validation = cls.validate_component_type(component_type)
+        if component_type_validation.is_failure:
+            return component_type_validation  # type: ignore
+
+        component_name_validation = cls.validate_component_name(component_name)
+        if component_name_validation.is_failure:
+            return component_name_validation  # type: ignore
+
+        # Validate optional fields
+        validated_file_path = None
+        if file_path is not None:
+            file_validation = cls.validate_file_path(file_path)
+            if file_validation.is_failure:
+                return file_validation  # type: ignore
+            else:
+                validated_file_path = file_validation.value
+
+        if description is not None:
+            description_validation = cls.validate_description(description)
+            if description_validation.is_failure:
+                return description_validation  # type: ignore
+
+        # Return validated data
+        validated_data = {
+            "system_name": system_name,
+            "module_name": module_name,
+            "layer": layer,
+            "component_type": component_type,
+            "component_name": component_name,
+        }
+
+        if validated_file_path is not None:
+            validated_data["file_path"] = str(validated_file_path)
+
+        if description is not None:
+            validated_data["description"] = description
+
+        return Result.success(validated_data)

{fast_clean_architecture-1.0.0.dist-info → fast_clean_architecture-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-clean-architecture
-Version: 1.0.0
+Version: 1.1.0
 Summary: CLI tool for scaffolding clean architecture in FastAPI projects
 Project-URL: Homepage, https://github.com/alden-technologies/fast-clean-architecture
 Project-URL: Repository, https://github.com/alden-technologies/fast-clean-architecture
@@ -17,28 +17,22 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Requires-Dist: jinja2<4.0.0,>=3.1.0
 Requires-Dist: pathlib-mate<2.0.0,>=1.0.0
+Requires-Dist: portalocker<3.0.0,>=2.0.0
+Requires-Dist: psutil>=5.9.0
 Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: pyyaml<7.0.0,>=6.0
 Requires-Dist: rich<14.0.0,>=13.0.0
+Requires-Dist: structlog<24.0.0,>=23.0.0
 Requires-Dist: typer[all]<1.0.0,>=0.9.0
-Provides-Extra: dev
-Requires-Dist: bandit<2.0.0,>=1.7.0; extra == 'dev'
-Requires-Dist: black<24.0.0,>=23.0.0; extra == 'dev'
-Requires-Dist: isort<6.0.0,>=5.0.0; extra == 'dev'
-Requires-Dist: mypy<2.0.0,>=1.0.0; extra == 'dev'
-Requires-Dist: pytest-cov<5.0.0,>=4.0.0; extra == 'dev'
-Requires-Dist: pytest<8.0.0,>=7.0.0; extra == 'dev'
-Requires-Dist: safety<3.0.0,>=2.0.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Fast Clean Architecture
@@ -76,36 +70,52 @@ poetry add fast-clean-architecture
 
 ### From Source
 
-#### Using pip
+#### Using Poetry (Recommended)
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-pip install -e .
+poetry install
 ```
 
-#### Using Poetry
+#### Using pip with requirements.txt
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-poetry install
+pip install -r requirements.txt
+```
+
+#### Using pip (editable install)
+```bash
+git clone https://github.com/alden-technologies/fast-clean-architecture.git
+cd fast-clean-architecture
+pip install -e .
 ```
 
 ### Development Installation
 
-#### Using pip
+#### Using Poetry (Recommended)
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-pip install -e ".[dev]"
+poetry install --extras dev
 ```
 
-#### Using Poetry
+#### Using pip with dev requirements
+```bash
+git clone https://github.com/alden-technologies/fast-clean-architecture.git
+cd fast-clean-architecture
+pip install -r requirements-dev.txt
+```
+
+#### Using pip (editable install with dev dependencies)
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-poetry install --with dev
+pip install -e ".[dev]"
 ```
 
+**Note**: This project uses Poetry for dependency management. The `requirements.txt` and `requirements-dev.txt` files are provided for convenience and compatibility with pip-based workflows.
+
 ## 🏗️ Architecture Overview
 
 Fast Clean Architecture follows the clean architecture pattern with these layers:
@@ -130,7 +140,7 @@ Fast Clean Architecture follows the clean architecture pattern with these layers
 │           └── 📁 presentation/     # API layer
 │               ├── 📁 api/          # FastAPI routers
 │               └── 📁 schemas/      # Pydantic schemas
-└── 📄 fca-config.yaml             # Project configuration
+└── 📄 fca_config.yaml             # Project configuration
 ```
 
 ## 📋 Prerequisites
@@ -323,7 +333,7 @@ fca-scaffold create-component --help
 
 ### Configuration File
 
-The `fca-config.yaml` file tracks your project structure:
+The `fca_config.yaml` file tracks your project structure:
 
 ```yaml
 project:

fast_clean_architecture-1.1.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+fast_clean_architecture/__init__.py,sha256=VOCrdvUXRx1IOKghlxhkzuKY4KFcU7s_RlLtjL10rFE,533
+fast_clean_architecture/analytics.py,sha256=2EC8iF1WERhoJm_XCATkUnkBvLIm8lxp9-Ukl4sf4dU,8733
+fast_clean_architecture/cli.py,sha256=S_GViX0gYFQJmmorqSk2nPunHRGL-8VpAmannJMFS-c,37263
+fast_clean_architecture/config.py,sha256=UAyzEifdqrbpZDDirVR_E2yq5rlTJyv19Iixd01ufiI,19969
+fast_clean_architecture/error_tracking.py,sha256=uyOEg6IZLNd-1u57bCCLpTzeBwP02pjVxRivXy1GyVM,6034
+fast_clean_architecture/exceptions.py,sha256=0CTkgDjG-Ilqc9Vex02ofgPCSBfmNNceK6ZGwCIF8n0,16578
+fast_clean_architecture/health.py,sha256=yvvGAOW_VXiuX7J4Od-IN7yazSA9fw8ugvfyb-hKzeU,5294
+fast_clean_architecture/logging_config.py,sha256=6I82AWCFGMdP5KFeDiL_wtXk2RLMcDL0_-u9Ka8TW4M,1580
+fast_clean_architecture/metrics.py,sha256=-7ln9E8UTSTBXWr7QhPRwpkGl_H1gKjmOMq79m6ASa0,3219
+fast_clean_architecture/protocols.py,sha256=45IQhACDJj8KvlHLAETlSpf_F5BTkivl52MgUJwizhs,12547
+fast_clean_architecture/utils.py,sha256=TbD7evQsKf_2KAr4RJ8iVhnpgBLA1FY6VaRd0CJSwEU,18837
+fast_clean_architecture/validation.py,sha256=Iu9KyaBZX1VznM_bMb_4Jvu8o4XtAQoUxaWcA1UhNkI,10873
+fast_clean_architecture/generators/__init__.py,sha256=bpq_b3lMiOBcn8bJhC3UCVLsSxIj9bGaSteGgN-Lgkc,560
+fast_clean_architecture/generators/component_generator.py,sha256=xlYnqeK55Y5pjYOuz4OaRenQkng0hYe6Kx1MICr9lSs,50128
+fast_clean_architecture/generators/config_updater.py,sha256=faSjwPX_sFWl8-qq4rl0HfOMUoZNKA1HwX3uP0BVCT4,16711
+fast_clean_architecture/generators/generator_factory.py,sha256=YB_qlGcdNWJsu1ZFP46ik3eK7fjZFCCFo4hfSkwQYMc,7746
+fast_clean_architecture/generators/package_generator.py,sha256=S234nCTHezdGMor0IaxbyWUyO3T68kAx_pJuHVKJHog,5978
+fast_clean_architecture/generators/template_validator.py,sha256=7N1_Sn3BqPIWnv0oKZvSvGgi3y64FKShSIvkFlrlbVA,23651
+fast_clean_architecture/generators/validation_config.py,sha256=ryqlEnE0tGIG5Ste9QsQccr_5HCS1Bl-gn422faDXug,2392
+fast_clean_architecture/generators/validation_metrics.py,sha256=mQ5pUVH2zg-gfaTHm0lf7-n6X7evTEGPeN__OPeaqS0,6644
+fast_clean_architecture/templates/__init__.py,sha256=uweRUmrNZosbwDlnM10Nfu9rKzPcEqXEr6BchsSAr58,146
+fast_clean_architecture/templates/__init__.py.j2,sha256=ogycgpBmYv-O1yoyQK9-Ki_x4FlYgb58mvhPrhiQNpA,618
+fast_clean_architecture/templates/api.py.j2,sha256=jPt1i84GuGEyeftJ8IythTrcTzac1GGyd4lQedl7_FA,2362
+fast_clean_architecture/templates/command.py.j2,sha256=jjmteEF-UqXdlhM487SSUHzeaz2l8vHq6BzOykw0gJM,612
+fast_clean_architecture/templates/entity.py.j2,sha256=5AIP6LwuusVNHiiAhph0bpFfnVzPhfnBdDMwZi_gx_s,1458
+fast_clean_architecture/templates/external.py.j2,sha256=dXqm9Y_EsoFXErF0ukdAzOwQbZy667gjQtU7ZD5iWnw,5418
+fast_clean_architecture/templates/infrastructure_repository.py.j2,sha256=nxKe7zpSRnpZkqpBrlhOkKLu2vERAiFhrt9iWU3K6aU,2543
+fast_clean_architecture/templates/model.py.j2,sha256=f3toWIDu5nX5wkHKPbk0-XXow3RLP7D5VknhLPNwSHo,1113
+fast_clean_architecture/templates/query.py.j2,sha256=7AwqC8BpzGq6L4T-g3Wo8Xj_SPOK0L1ke1RkJ4DQsVU,594
+fast_clean_architecture/templates/repository.py.j2,sha256=YsjPpVakZR2A-JmsK-VYE6bYDhmeRBfNtID9SdhsGj8,1694
+fast_clean_architecture/templates/schemas.py.j2,sha256=iwZT42LxqgNL4ms_-uQkWKWQWaiMDflWzdlWMBke_3M,755
+fast_clean_architecture/templates/service.py.j2,sha256=utNp_E7bywlMfjY9SHzzrH4isr-WeXpnRIb15XkZrj4,3926
+fast_clean_architecture/templates/value_object.py.j2,sha256=IVI69cuYTa_7g1s9T5guigIqeSl1lXFapWFu-XKzYjE,919
+fast_clean_architecture-1.1.0.dist-info/METADATA,sha256=mqX8xt3q2b-miLJHwU5S0el4gaiXfXhPQ38K4JrZwhQ,17096
+fast_clean_architecture-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_clean_architecture-1.1.0.dist-info/entry_points.txt,sha256=5R_7kBX0dYEq6n8lyTmv7Sn4Rs3pjpLqGX-mB_3FL1w,65
+fast_clean_architecture-1.1.0.dist-info/licenses/LICENSE,sha256=wpM1B1Znw_YrC9L_R0jiXPHWz5iM_tNW4UOvBtl026s,1075
+fast_clean_architecture-1.1.0.dist-info/RECORD,,

fast_clean_architecture-1.0.0.dist-info/RECORD

@@ -1,30 +0,0 @@
-fast_clean_architecture/__init__.py,sha256=1B-oli8nUGzjXVe62dN_uAV6fTQlt_wNZmlbzLZs1C8,524
-fast_clean_architecture/cli.py,sha256=bug84CZx87zlAw7eCRGMs6-wVtFDER9snAvWPv-GxEs,15447
-fast_clean_architecture/config.py,sha256=W-H4r3sPHbx4CSp8_wC3VylnRRYngzw2OosC2__V0RE,18742
-fast_clean_architecture/exceptions.py,sha256=cFgIcHGlY7EqIeQvt95_D57AWZxCJja9XVt_MQo4gFE,1667
-fast_clean_architecture/utils.py,sha256=rrdiYUyj-xQ24nCaK5fspFvHIsjpspJAhxc64jzWgrk,18295
-fast_clean_architecture/generators/__init__.py,sha256=xgd1_9vo1DZ5DgKZainvK-rqoRVKz8Nvo7X34uDOdIs,280
-fast_clean_architecture/generators/component_generator.py,sha256=zPBkkTq0gTRPQGeaatCmqTeJt5QLmgN2k3kNZwzXfao,39089
-fast_clean_architecture/generators/config_updater.py,sha256=5SNeOszx_9urd8_NBM3aDDqw_Pu4cyWW9gLE_IMwo3c,10518
-fast_clean_architecture/generators/package_generator.py,sha256=pMi-SNMe2mUuwmE7YrJnfJNJrYmMk6jgTp7hJV_bozE,5896
-fast_clean_architecture/generators/template_validator.py,sha256=xOBRxvCLaR6cE0q3CgVdMjN5pHud8tJEWIOEMh4kRBA,20399
-fast_clean_architecture/generators/validation_config.py,sha256=OU46Ye2ik9AH51009faWIoe-GPzg-b8A4D2JaoFZSDY,2313
-fast_clean_architecture/generators/validation_metrics.py,sha256=owUYjqbDIttg4ZLXKvUkjqRQqxsrYe2f009oTrzbXXU,6493
-fast_clean_architecture/templates/__init__.py,sha256=uweRUmrNZosbwDlnM10Nfu9rKzPcEqXEr6BchsSAr58,146
-fast_clean_architecture/templates/__init__.py.j2,sha256=ogycgpBmYv-O1yoyQK9-Ki_x4FlYgb58mvhPrhiQNpA,618
-fast_clean_architecture/templates/api.py.j2,sha256=jPt1i84GuGEyeftJ8IythTrcTzac1GGyd4lQedl7_FA,2362
-fast_clean_architecture/templates/command.py.j2,sha256=jjmteEF-UqXdlhM487SSUHzeaz2l8vHq6BzOykw0gJM,612
-fast_clean_architecture/templates/entity.py.j2,sha256=5AIP6LwuusVNHiiAhph0bpFfnVzPhfnBdDMwZi_gx_s,1458
-fast_clean_architecture/templates/external.py.j2,sha256=SbZ8GEp9Q02bQTI59k0wDE5lDWVJWa7wI6VOBpsoAd4,1844
-fast_clean_architecture/templates/infrastructure_repository.py.j2,sha256=nxKe7zpSRnpZkqpBrlhOkKLu2vERAiFhrt9iWU3K6aU,2543
-fast_clean_architecture/templates/model.py.j2,sha256=f3toWIDu5nX5wkHKPbk0-XXow3RLP7D5VknhLPNwSHo,1113
-fast_clean_architecture/templates/query.py.j2,sha256=7AwqC8BpzGq6L4T-g3Wo8Xj_SPOK0L1ke1RkJ4DQsVU,594
-fast_clean_architecture/templates/repository.py.j2,sha256=YsjPpVakZR2A-JmsK-VYE6bYDhmeRBfNtID9SdhsGj8,1694
-fast_clean_architecture/templates/schemas.py.j2,sha256=iwZT42LxqgNL4ms_-uQkWKWQWaiMDflWzdlWMBke_3M,755
-fast_clean_architecture/templates/service.py.j2,sha256=utNp_E7bywlMfjY9SHzzrH4isr-WeXpnRIb15XkZrj4,3926
-fast_clean_architecture/templates/value_object.py.j2,sha256=IVI69cuYTa_7g1s9T5guigIqeSl1lXFapWFu-XKzYjE,919
-fast_clean_architecture-1.0.0.dist-info/METADATA,sha256=UAswG12fAvPtXkdOGttTx-o3Dh10jIUAtdx9jYoHFeg,16765
-fast_clean_architecture-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_clean_architecture-1.0.0.dist-info/entry_points.txt,sha256=5R_7kBX0dYEq6n8lyTmv7Sn4Rs3pjpLqGX-mB_3FL1w,65
-fast_clean_architecture-1.0.0.dist-info/licenses/LICENSE,sha256=wpM1B1Znw_YrC9L_R0jiXPHWz5iM_tNW4UOvBtl026s,1075
-fast_clean_architecture-1.0.0.dist-info/RECORD,,