devdox-ai-locust 0.1.3.post1__py3-none-any.whl → 0.1.4__py3-none-any.whl

devdox_ai_locust/cli.py

@@ -197,19 +197,20 @@ async def _generate_and_create_tests(
     custom_requirement: Optional[str] = "",
     host: Optional[str] = "0.0.0.0",
     auth: bool = False,
+    db_type: str = "",
 ) -> List[Dict[Any, Any]]:
     """Generate tests using AI and create test files"""
     together_client = AsyncTogether(api_key=api_key)
 
     with console.status("[bold green]Generating Locust tests with AI..."):
         generator = HybridLocustGenerator(ai_client=together_client)
-
         test_files, test_directories = await generator.generate_from_endpoints(
             endpoints=endpoints,
             api_info=api_info,
             custom_requirement=custom_requirement,
             target_host=host,
             include_auth=auth,
+            db_type=db_type,
         )
 
     # Create test files
@@ -271,6 +272,12 @@ def cli(ctx: click.Context, verbose: bool) -> None:
 )
 @click.option("--host", "-H", type=str, help="Target host URL")
 @click.option("--auth/--no-auth", default=True, help="Include authentication in tests")
+@click.option(
+    "--db-type",
+    type=click.Choice(["", "mongo", "postgresql"], case_sensitive=False),
+    default="",
+    help="Database type for testing (empty for no database, mongo, or postgresql)",
+)
 @click.option("--dry-run", is_flag=True, help="Generate tests without running them")
 @click.option(
     "--custom-requirement", type=str, help="Custom requirements for test generation"
@@ -291,6 +298,7 @@ def generate(
     run_time: str,
     host: Optional[str],
     auth: bool,
+    db_type: str,
     dry_run: bool,
     custom_requirement: Optional[str],
     together_api_key: Optional[str],
@@ -309,6 +317,7 @@ def generate(
                 run_time,
                 host,
                 auth,
+                db_type,
                 dry_run,
                 custom_requirement,
                 together_api_key,
@@ -332,6 +341,7 @@ async def _async_generate(
     run_time: str,
     host: Optional[str],
     auth: bool,
+    db_type: str,
     dry_run: bool,
     custom_requirement: Optional[str],
     together_api_key: Optional[str],
@@ -343,7 +353,6 @@ async def _async_generate(
     try:
         _, api_key = _initialize_config(together_api_key)
         output_dir = _setup_output_directory(output)
-
         # Display configuration
         if ctx.obj["verbose"]:
             _display_configuration(
@@ -363,7 +372,14 @@ async def _async_generate(
         )
 
         created_files = await _generate_and_create_tests(
-            api_key, endpoints, api_info, output_dir, custom_requirement, host, auth
+            api_key,
+            endpoints,
+            api_info,
+            output_dir,
+            custom_requirement,
+            host,
+            auth,
+            db_type,
         )
 
         # Show results

devdox_ai_locust/config.py

@@ -8,7 +8,7 @@ from pydantic_settings import BaseSettings
 class Settings(BaseSettings):
     """Application settings."""
 
-    VERSION: str = "0.1.3.post1"
+    VERSION: str = "0.1.4"
 
     API_KEY: str = ""  # Fallback for backward compatibility
 

devdox_ai_locust/hybrid_loctus_generator.py

@@ -25,6 +25,7 @@ logger = logging.getLogger(__name__)
 
 
 test_data_file_path = "test_data.py"
+data_provider_path = "data_provider.py"
 
 
 @dataclass
@@ -118,6 +119,7 @@ class EnhancementProcessor:
         base_files: Dict[str, str],
         directory_files: List[Dict[str, Any]],
         grouped_endpoints: Dict[str, List[Endpoint]],
+        db_type: str = "",
     ) -> Tuple[List[Dict[str, Any]], List[str]]:
         """Process workflow enhancements"""
         enhanced_directory_files: List[Dict[str, Any]] = []
@@ -134,10 +136,13 @@ class EnhancementProcessor:
             first_workflow = base_workflow_files[0]
             # Get the content from the dictionary - adjust key name as needed
             base_workflow_content = first_workflow.get("base_workflow.py", "")
-
         for workflow_item in directory_files:
             enhanced_workflow_item = await self._enhance_single_workflow(
-                workflow_item, base_files, base_workflow_content, grouped_endpoints
+                workflow_item,
+                base_files,
+                base_workflow_content,
+                grouped_endpoints,
+                db_type,
             )
             if enhanced_workflow_item:
                 enhanced_directory_files.append(enhanced_workflow_item["files"])
@@ -151,6 +156,7 @@ class EnhancementProcessor:
         base_files: Dict[str, str],
         base_workflow_files: str,
         grouped_endpoints: Dict[str, List[Endpoint]],
+        db_type: str = "",
     ) -> Dict[str, Any] | None:
         """Enhance a single workflow file"""
         for key, value in workflow_item.items():
@@ -164,6 +170,7 @@ class EnhancementProcessor:
                 base_workflow=base_workflow_files,
                 grouped_enpoints=workflow_endpoints_dict,
                 auth_endpoints=auth_endpoints,
+                db_type=db_type,
             )
             if enhanced_workflow:
                 return {
@@ -174,14 +181,19 @@ class EnhancementProcessor:
         return None
 
     async def process_test_data_enhancement(
-        self, base_files: Dict[str, str], endpoints: List[Endpoint]
+        self, base_files: Dict[str, str], endpoints: List[Endpoint], db_type: str = ""
     ) -> Tuple[Dict[str, str], List[str]]:
         """Process test data enhancement"""
         enhanced_files = {}
         enhancements = []
         if self.ai_config and self.ai_config.enhance_test_data:
             enhanced_test_data = await self.locust_generator.enhance_test_data_file(
-                base_files.get(test_data_file_path, ""), endpoints
+                base_files.get(test_data_file_path, ""),
+                endpoints,
+                db_type,
+                base_files.get(data_provider_path, ""),
+                base_files.get("db_config.py", ""),
+                data_provider_path,
             )
             if enhanced_test_data:
                 enhanced_files[test_data_file_path] = enhanced_test_data
@@ -289,6 +301,7 @@ class HybridLocustGenerator:
         custom_requirement: Optional[str] = None,
         target_host: Optional[str] = None,
         include_auth: bool = True,
+        db_type: str = "",
     ) -> Tuple[Dict[str, str], List[Dict[str, Any]]]:
         """
         Generate Locust tests using hybrid approach
@@ -308,6 +321,7 @@ class HybridLocustGenerator:
                     api_info,
                     include_auth=include_auth,
                     target_host=target_host,
+                    db_type=db_type,
                 )
             )
 
@@ -322,6 +336,7 @@ class HybridLocustGenerator:
                     directory_files,
                     grouped_enpoints,
                     custom_requirement,
+                    db_type,
                 )
                 if enhancement_result.success:
                     logger.info(
@@ -422,6 +437,7 @@ class HybridLocustGenerator:
         directory_files: List[Dict[str, Any]],
         grouped_endpoints: Dict[str, List[Endpoint]],
         custom_requirement: Optional[str] = None,
+        db_type: str = "",
     ) -> EnhancementResult:
         """Enhance base files with AI - Refactored for reduced cognitive complexity"""
         start_time = asyncio.get_event_loop().time()
@@ -434,6 +450,7 @@ class HybridLocustGenerator:
                 directory_files,
                 grouped_endpoints,
                 custom_requirement,
+                db_type,
             )
 
             processing_time = asyncio.get_event_loop().time() - start_time
@@ -462,6 +479,7 @@ class HybridLocustGenerator:
         directory_files: List[Dict[str, Any]],
         grouped_endpoints: Dict[str, List[Endpoint]],
         custom_requirement: Optional[str] = None,
+        db_type: str = "",
     ) -> EnhancementResult:
         """Process all enhancements using the enhancement processor"""
         processor = EnhancementProcessor(self.ai_config, self)
@@ -476,7 +494,7 @@ class HybridLocustGenerator:
             processor.process_domain_flows_enhancement(
                 endpoints, api_info, custom_requirement
             ),
-            processor.process_test_data_enhancement(base_files, endpoints),
+            processor.process_test_data_enhancement(base_files, endpoints, db_type),
             processor.process_validation_enhancement(base_files, endpoints),
         ]
 
@@ -501,7 +519,7 @@ class HybridLocustGenerator:
                 workflow_files,
                 workflow_enhancements,
             ) = await processor.process_workflow_enhancements(
-                base_files, directory_files, grouped_endpoints
+                base_files, directory_files, grouped_endpoints, db_type
             )
             enhanced_directory_files.extend(workflow_files)
             enhancements_applied.extend(workflow_enhancements)
@@ -557,6 +575,7 @@ class HybridLocustGenerator:
         base_workflow: str,
         grouped_enpoints: Dict[str, List[Endpoint]],
         auth_endpoints: List[Endpoint],
+        db_type: str = "",
     ) -> Optional[str]:
         try:
             template = self.jinja_env.get_template("workflow.j2")
@@ -568,6 +587,7 @@ class HybridLocustGenerator:
                 base_workflow=base_workflow,
                 auth_endpoints=auth_endpoints,
                 base_content=base_content,
+                db_type=db_type,
             )
             enhanced_content = await self._call_ai_service(prompt)
             return enhanced_content
@@ -577,7 +597,13 @@ class HybridLocustGenerator:
         return ""
 
     async def enhance_test_data_file(
-        self, base_content: str, endpoints: List[Endpoint]
+        self,
+        base_content: str,
+        endpoints: List[Endpoint],
+        db_type: str = "",
+        data_provider: str = "",
+        db_config: str = "",
+        data_provider_path: str = "",
     ) -> Optional[str]:
         """Enhance test data generation with domain knowledge"""
 
@@ -592,11 +618,14 @@ class HybridLocustGenerator:
                 "base_content": base_content,
                 "schemas_info": schemas_info,
                 "endpoints": endpoints,
+                "db_type": db_type,
+                "data_provider_content": data_provider,
+                "db_config": db_config,
+                "data_provider_path": data_provider_path,
             }
 
             # Render enhanced content
             prompt = template.render(**context)
-
             enhanced_content = await self._call_ai_service(prompt)
             if enhanced_content and self._validate_python_code(enhanced_content):
                 return enhanced_content

devdox_ai_locust/locust_generator.py

@@ -12,7 +12,8 @@ import black
 from jinja2 import Environment, FileSystemLoader
 from pathlib import Path
 import logging
-from dataclasses import dataclass
+from enum import Enum
+from dataclasses import dataclass, asdict
 from datetime import datetime
 
 
@@ -21,6 +22,48 @@ from devdox_ai_locust.utils.open_ai_parser import Endpoint, Parameter
 logger = logging.getLogger(__name__)
 
 
+class DatabaseType(Enum):
+    """Supported database types for testing"""
+
+    MONGO = "mongo"
+    POSTGRES = "postgres"
+
+
+@dataclass
+class MongoDBConfig:
+    """MongoDB-specific configuration"""
+
+    use_realistic_data: str = "true"
+    enable_mongodb: str = "false"
+    use_mongodb_for_test_data: str = "false"
+    mongodb_uri: str = "mongodb://localhost:27017/"
+    mongodb_database: str = "locust_test_data"
+    MONGODB_MAX_POOL_SIZE: int = 100
+    MONGODB_MIN_POOL_SIZE: int = 10
+
+    # MongoDB Timeout Settings
+    MONGODB_CONNECT_TIMEOUT_MS: int = 5000
+    MONGODB_SERVER_SELECTION_TIMEOUT_MS: int = 5000
+    MONGODB_SOCKET_TIMEOUT_MS: int = 10000
+    MONGODB_MAX_IDLE_TIME_MS: int = 60000
+    MONGODB_WAIT_QUEUE_TIMEOUT_MS: int = 10000
+
+    # MongoDB Collection Names to be added
+
+
+@dataclass
+class PostgreSQLConfig:
+    """PostgreSQL-specific configuration"""
+
+    host: str = "localhost"
+    port: str = "5432"
+    database: str = "test_db"
+    user: str = "test_user"
+    password: str = "test_password"
+    pool_size: str = "10"
+    max_overflow: str = "20"
+
+
 @dataclass
 class TestDataConfig:
     """Configuration for test data generation"""
@@ -100,6 +143,7 @@ class LocustTestGenerator:
         api_info: Dict[str, Any],
         include_auth: bool = True,
         target_host: Optional[str] = None,
+        db_type: str = "",
     ) -> Tuple[Dict[str, str], List[Dict[str, Any]], Dict[str, List[Endpoint]]]:
         """
         Generate complete Locust test suite from parsed endpoints
@@ -121,14 +165,23 @@ class LocustTestGenerator:
                 "locustfile.py": self._generate_main_locustfile(
                     endpoints, api_info, list(grouped_enpoint.keys())
                 ),
-                "test_data.py": self._generate_test_data_file(),
+                "test_data.py": self._generate_test_data_file(db_type),
                 "config.py": self._generate_config_file(api_info),
                 "utils.py": self._generate_utils_file(),
                 "custom_flows.py": self._generate_custom_flows_file(),
                 "requirements.txt": self._generate_requirements_file(),
-                "README.md": self._generate_readme_file(api_info),
-                ".env.example": self._generate_env_example(api_info, target_host),
+                "README.md": self._generate_readme_file(api_info, db_type),
+                ".env.example": self._generate_env_example(
+                    api_info, target_host, db_type
+                ),
             }
+            if db_type != "":
+                self.generated_files["db_config.py"] = self._generate_db_file(
+                    db_type, "db_config.py.j2"
+                )
+                self.generated_files["data_provider.py"] = self._generate_db_file(
+                    db_type, "data_provider.py.j2"
+                )
 
             return self.generated_files, workflows_files, grouped_enpoint
         except Exception as e:
@@ -639,10 +692,13 @@ class LocustTestGenerator:
 
     '''
 
-    def _generate_test_data_file(self) -> str:
+    def _generate_test_data_file(self, db_type: str = "") -> str:
         """Generate test_data.py file content"""
+        data_provider_content = None
+        if db_type == DatabaseType.MONGO.value:
+            data_provider_content = "mongo_data_provider"
         template = self.jinja_env.get_template("test_data.py.j2")
-        return template.render()
+        return template.render(data_provider_content=data_provider_content)
 
     def _generate_config_file(self, api_info: Dict[str, Any]) -> str:
         """Generate config.py file content"""
@@ -665,8 +721,16 @@ class LocustTestGenerator:
         content = template.render()
         return content
 
+    def _generate_db_file(self, db_type: str, file_name: str) -> str:
+        """Generate db file content"""
+        template = self.jinja_env.get_template(db_type + "/" + file_name)
+        return template.render()
+
     def _generate_env_example(
-        self, api_info: Dict[str, Any], target_host: Optional[str] = None
+        self,
+        api_info: Dict[str, Any],
+        target_host: Optional[str] = None,
+        db_type: str = "",
     ) -> str:
         """Generate .env.example file content"""
         try:
@@ -686,12 +750,15 @@ class LocustTestGenerator:
                 "LOCUST_SPAWN_RATE": "5",
                 "LOCUST_RUN_TIME": "10m",
                 "LOCUST_HOST": locust_host,
-                "USE_REALISTIC_DATA": "true",
                 "DATA_SEED": "42",
                 "REQUEST_TIMEOUT": "30",
                 "MAX_RETRIES": "3",
             }
 
+            if db_type == DatabaseType.MONGO.value:
+                mongodb_config = MongoDBConfig()
+                environment_vars.update(asdict(mongodb_config))
+
             context = {
                 "environment_vars": environment_vars,
                 "api_info": api_info,
@@ -706,15 +773,23 @@ class LocustTestGenerator:
             logger.error(f"❌ Failed to generate .env.example from template: {e}")
             return ""
 
-    def _generate_readme_file(self, api_info: Dict[str, Any]) -> str:
+    def _generate_readme_file(self, api_info: Dict[str, Any], db_type: str = "") -> str:
         try:
             # Get the template
             template = self.jinja_env.get_template("readme.md.j2")
+            db_using = ""
+            if db_type == DatabaseType.MONGO.value:
+                template_db = self.jinja_env.get_template(
+                    DatabaseType.MONGO.value + "/db_integration.j2"
+                )
+
+                db_using = template_db.render()
 
             # Prepare template context
             context = {
                 "api_info": api_info,
                 "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "db_using": db_using,
             }
 
             # Render the template

devdox_ai_locust/prompt/test_data.j2

@@ -1,62 +1,186 @@
-Enhance this test data generator with domain-specific realistic data while preserving ALL existing methods and their signatures:
+Evolve this Test Data Generator into a fully production-ready, intelligent data generation framework.
+{% if data_provider_content %}Incorporate MongoDB integration for live data enrichment, delivering a complete, robust, and realistic test data engine with domain awareness, caching, and smart relationships.{% endif %}
 
-Current File:
+**CURRENT STATE ANALYSIS**:
+```python
 {{base_content}}
+```
+
+
+{% if data_provider_content %}
+    Database config file content with path to DB{{ data_provider_path }}:
+    {{ db_config }}
+
+
+    **MONGODB DATA PROVIDER** (Available for Integration):
+    ```python
+    {{data_provider_content}}
+    ```
+{% endif %}
 
-API Schemas Found:
-{{ schemas_info }}
 
 API Endpoints Context:
-[
-{% for ep in endpoints -%}
-    "Path: {{ ep.path }}, Method: {{ ep.method }}, Tags: {{ ep.tags }}"{% if not loop.last %},{% endif %}
-{% endfor -%}
-]
+    - **Schemas**: {schemas_info}
+    - **Endpoints**: [{% for ep in endpoints -%}
+    "Path: {{ ep.path }}, Method: {{ ep.method }}, Tags: {{ ep.tags }}"{% if not loop.last %},{% endif %}{% endfor -%}]
+
+
 
-REQUIREMENTS - Enhance by adding NEW functionality while keeping ALL existing methods intact:
+**CRITICAL REQUIREMENT**: Every method must have COMPLETE, FUNCTIONAL implementation. NO stubs, NO pass statements, NO placeholder comments.
 
-1. **Domain-Specific Data Generators**:
+**IMPLEMENTATION SPECIFICATIONS**:
+{% set counter = namespace(value=1) %}
+
+{% if data_provider_content %}
+    {{ counter.value }}.  **MongoDB Integration** (COMPLETE Implementation Required)
+```python
+def get_from_mongodb_or_generate(self, collection_name: str, entity_type: str, fallback_generator: callable = None, **kwargs) -> Dict[str, Any]:
+    \"\"\"COMPLETE implementation with full error handling, logging, and statistics\"\"\"
+    # IMPLEMENT: Full MongoDB integration with:
+    # - Statistics tracking (mongo_queries, cache_hits, fallback_generations)
+    # - Comprehensive error handling with specific exception types
+    # - Logging with appropriate levels (DEBUG, WARNING, ERROR)
+    # - Performance metrics collection
+    # - Graceful degradation when MongoDB unavailable
+    # - Return type validation and data sanitization
+```
+
+    {% set counter.value = counter.value + 1 %}
+{% endif %}
+
+{{ counter.value }}. **Domain-Specific Data Generators**(COMPLETE Implementation Required)
    - Add methods like `generate_affiliate_data()`, `generate_user_credentials()`, `generate_product_data()`
    - Create realistic data based on API endpoint patterns (affiliate, user, product, etc.)
    - Add specific payload generators for common API patterns
+    {% if data_provider_content %}- Use MongoDB data as templates when available{% endif %}
+   - Add `generate_realistic_data(entity_type: str)` for entity-specific data
+{% set counter.value = counter.value + 1 %}
+
+
+
+{{ counter.value }} **Realistic Data Generation**:
+   - Add `generate_realistic_data(entity_type: str, **kwargs)` for entity-specific data
+   - Create realistic data based on API endpoint patterns (user, product, order, etc.)
+   {% if data_provider_content %}- Integrate MongoDB data patterns into generated data {% endif %}
+   - Add business logic validation for generated data
+{% set counter.value = counter.value + 1 %}
 
-2. **Realistic ID Generation**:
+
+{{ counter.value }}. **Realistic ID Generation**:
    - Add `generate_realistic_id(entity_type: str)` for entity-specific IDs
    - Create correlated IDs (user_id -> session_id -> transaction_id)
    - Add methods like `generate_affiliate_id()`, `generate_partner_id()`, etc.
+{% set counter.value = counter.value + 1 %}
 
-3. **Payload Templates**:
+{{ counter.value }}. **Payload Templates**:
    - Add `get_payload_template(endpoint_path: str, method: str)`
    - Create endpoint-specific payload generators
    - Add `generate_login_payload()`, `generate_registration_payload()`, etc.
+{% set counter.value = counter.value + 1 %}
 
-4. **Data Relationships & Correlation**:
+{{ counter.value }}. **Data Relationships & Correlation**:
    - Add session management: `create_user_session()`, `get_session_data()`
    - Create data dependency chains (parent-child relationships)
    - Add `link_related_entities(parent_id, child_type)` for realistic relationships
+{% set counter.value = counter.value + 1 %}
+
+
+{{ counter.value }}. COMPLETE Implementation Required)
+    ```python
+    def cache_generated_data(self, key: str, data: Any, ttl_seconds: int = 300) -> None:
+    \"\"\"COMPLETE thread-safe caching implementation\"\"\"
+    # IMPLEMENT: Full caching system with:
+    # - Thread-safe operations using threading.Lock()
+    # - TTL (time-to-live) management with automatic expiration
+    # - Cache size limits with LRU eviction
+    # - Memory usage tracking and optimization
+    # - Cache hit/miss statistics
+    # - Data serialization/deserialization if needed
 
-5. **Smart Caching & Performance**:
-   - Add `cache_generated_data(key, data)` and `get_cached_data(key)`
-   - Create reusable entity pools for better performance
-   - Add `get_or_create_entity(entity_type, **kwargs)`
+    def get_cached_data(self, key: str) -> Optional[Any]:
+        \"\"\"COMPLETE cache retrieval with validation\"\"\"
+        # IMPLEMENT: Full cache retrieval with:
+        # - TTL validation and automatic cleanup
+        # - Thread-safe access
+        # - Statistics updating (cache_hits counter)
+        # - Data integrity validation
+        # - Proper None handling for cache misses
 
-6. **Specialized Pattern Generators**:
+    def get_or_create_entity(self, entity_type: str, **kwargs) -> Dict[str, Any]:
+        \"\"\"COMPLETE entity management with intelligent caching\"\"\"
+        # IMPLEMENT: Full entity lifecycle management:
+        # - Cache key generation from entity_type and kwargs
+        # - Cache lookup with TTL validation
+        # - MongoDB integration for real data
+        # - Fallback to realistic generation
+        # - Automatic caching of generated/retrieved data
+        # - Relationship tracking and linking
+    ```
+{% set counter.value = counter.value + 1 %}
+
+{{ counter.value }}. **Specialized Pattern Generators**:
    - Add `generate_api_key_data()`, `generate_webhook_payload()`
    - Create `generate_pagination_data()`, `generate_filter_data()`
    - Add `generate_error_scenarios()` for negative testing
+{% set counter.value = counter.value + 1 %}
 
-7. **Validation & Constraints**:
+{{ counter.value }}. **Validation & Constraints**:
    - Add `validate_generated_data(data, schema)`
    - Create constraint-aware generation
    - Add business rule validation
+{% set counter.value = counter.value + 1 %}
+
+{% if data_provider_content %}
+    {{ counter.value }}. **MongoDB Integration Specifics**:
+    - **MANDATORY**: `mongo_data_provider.get_multiple_documents(collection_name, count, query)` when retrieving multiple realistic  to return list records from MongoDB.
+    - Use `mongo_data_provider.get_document(collection_name,query,projection)` when retrieving a single realistic record from MongoDB or fallback generation.
+    - Add `mongo_data_provider.preload_cache()` integration
+    - Use `mongo_config.enable_mongodb` for availability checking
+    - Implement proper connection error handling
+    - Add MongoDB query optimization
+    - Include data freshness validation
+    {% set counter.value = counter.value + 1 %}
+{% endif %}
+
+{% if data_provider_content %}
+
+**🚨 FINAL VALIDATION REQUIREMENTS**:
+
+The generated code MUST contain these exact function calls:
+1. `mongo_data_provider.get_multiple_documents()` - Used at least 5 times
+2. `mongo_data_provider.get_random_document()` - Used for single items only
+3. Both methods must have proper error handling and fallback generation
+
+
+**VERIFICATION CHECKLIST**:
+- [ ] `get_multiple_documents()` appears in at least 5 different methods
+- [ ] `get_document()` is used for single entity retrieval
+- [ ] No method uses only `get_document()` when batch data is needed
+- [ ] All MongoDB calls have try/catch error handling
+- [ ] All MongoDB calls have fallback generation
+**FAILURE CRITERIA**: If `get_multiple_documents()` appears less than 5 times in the generated code, the implementation is incomplete and must be regenerated.
+{% endif %}
+
+**OUTPUT REQUIREMENTS**:
+
+1. **ZERO Placeholder Methods**: Every method must be FULLY implemented
+2. **Production Quality**: Include proper error handling, logging, and documentation
+3. **Thread Safety**: All caching and state management must be thread-safe
+4. **Performance Optimized**: Efficient algorithms and memory usage
+5. **Comprehensive Testing**: Generate data that covers edge cases and business scenarios
+6. **Backward Compatibility**: All existing functionality must continue working
+7. **Rich Data**: Generate realistic, coherent data with proper relationships
+8. **Extensive Logging**: Use logging module with appropriate levels
+9. **Statistics Tracking**: Detailed metrics for monitoring and optimization
+10. **MongoDB Integration**: Seamless integration with provided data provider
 
-CRITICAL CONSTRAINTS:
-- MUST preserve ALL existing method signatures exactly as they are
-- MUST keep all existing functionality working
-- MUST maintain backward compatibility
-- ADD new methods, don't modify existing ones
-- Keep the global `test_data_generator` instance
+🚨 **CRITICAL SUCCESS CRITERIA**:
+- NO methods should contain `pass` or placeholder comments
+- ALL caching methods must be fully functional
+- ALL data generation must produce realistic, coherent data
+- ALL MongoDB integration must handle errors gracefully
+- ALL relationships must be properly tracked and maintained
 
-Focus on making the data generation smarter and more realistic while ensuring all existing code that imports and uses this generator continues to work without changes.
+Return the COMPLETE, PRODUCTION-READY Python file with every method fully implemented and tested-quality code.
 
-Output: Complete enhanced Python file with ALL existing content preserved + new intelligent features
+**Format**: Return ONLY the complete Python code wrapped in ```python``` tags with NO explanations outside the code block.