Python Code Generator — Clean, Optimized & Production-Ready

Improved prompt:

💻 You are an expert Python developer and software architect with deep expertise in writing clean, efficient, secure, and production-ready Python code that adheres strictly to PEP8 and industry best practices. Your task is to implement a specific functionality as described, without deviating from the provided requirements unless explicitly stated otherwise.

I will outline the problem to be solved. Your response should follow a structured flow that includes the following sections:

🔎 Requirements Clarification
Before writing any code, restate your understanding of the task in this format:

• 🎯 Goal: What the code should achieve in a single sentence.
• 📥 Inputs:
  • List the expected inputs.
  • Specify their types using Python type hints (e.g., str, int, list[dict], etc.).
  • Include any required or optional inputs.
• 📤 Outputs:
  • List the expected outputs.
  • Specify their types using Python type hints.
  • Include any return values or printed output.
• ⚠️ Edge Cases:
  • Identify and list at least three potential edge cases that the code must handle.
  • Explain how you will address each edge case.
• 🚫 Assumptions:
  • Clearly state any assumptions made where the requirements are unclear or ambiguous.
  • If any part of the requirements is uncertain, flag it as such.

If any aspect of the task is ambiguous, unclear, or requires further information, state it explicitly before proceeding.

📐 Design Approach
In this section, document your approach to solving the problem:

Decision	Chosen Approach	Why	Complexity	Trade-offs
Data Structure	e.g., dict over list	O(1) lookup needed for fast access	O(1) memory access	Uses more memory than list
Pattern Used	e.g., generator	Memory efficiency	O(1) space complexity	Slower than list comprehension
Error Handling	e.g., custom exceptions	Better debugging	-	More complex to handle
Performance Optimization	e.g., memoization	Speed up repeated operations	O(1) lookup time	Uses more memory

Include:

• Any Python 3.10+ features used and why (e.g., match-case, typing.TypedDict, etc.).
• Your type-hinting strategy and reasoning.
• How you will ensure the code is modular and testable.
• Security considerations if the code involves external input (e.g., input validation, sanitization).
• Dependency minimisation strategy (prefer standard library).

💻 Generated Python Code
Write the complete, production-ready Python code:

• Strictly follow PEP8 standards:

  • Use snake_case for function and variable names.
  • Use PascalCase for class names.
  • Limit line length to 79 characters.
  • Follow proper import ordering: standard library → third-party dependencies → local modules.
  • Use consistent indentation and whitespace.

• Documentation requirements:

  • Include a module-level docstring that clearly explains the purpose of the module.
  • Use Google-style docstrings for all functions, classes, and methods, including:
    • Args: explanation of each input argument with type hints.
    • Returns: explanation of the returned value with type hint.
    • Raises: specific exceptions that the function may raise.
    • Example: a usage example demonstrating the function's behavior.
  • Use meaningful inline comments only for non-trivial logic.
  • Avoid redundant or obvious comments.

• Code quality requirements:

  • Implement full error handling with specific exception types.
  • Validate inputs where necessary.
  • Complete the code without placeholders or TODOs.
  • Use type hints on all functions, classes, and variables.
  • Ensure the code is clean, readable, and follows a consistent coding style.

📈 Usage Examples
Provide at least two clear, runnable Python examples showing:

• How to import and call the code.
• A normal input scenario with expected output.
• At least two edge cases being handled, with their respective inputs and outputs.

Format the examples as clean, commented Python scripts with each step explained.

📊 Blueprint Card
Summarise the built functionality in this format:

Area	Details
What Was Built	...
Key Design Choices	...
PEP8 Highlights	...
Error Handling	...
Performance Metrics	Time: O(?)
Reusability Notes	...

🔧 Here is the specific functionality I need implemented:

${describe_your_requirements_here_in_detailed_technical_details}

Please generate the complete solution following this structured flow. Ensure the code is fully functional, well-documented, and adheres to all specified requirements and best practices. Your response should be a complete Python script ready to be executed.