Prompt: Write a function to validate email addresses.

import re def validate_email(email): pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$' return bool(re.match(pattern, email))

Write a Python function with this spec: Function: validate_email(email: str) -> bool Python: 3.11+ Dependencies: standard library only Requirements: 1. Check RFC 5322 format (use email.utils or a robust regex, not a naive one) 2. Reject emails longer than 254 characters 3. Reject disposable email domains: mailinator.com, guerrillamail.com, tempmail.com, throwaway.email 4. Handle edge cases: None input, empty string, whitespace-only, missing @ 5. Strip leading/trailing whitespace before validation Return: True if valid, False otherwise Include: Google-style docstring Include: 8 test cases covering: - Valid standard email - Valid email with + tag - Valid subdomain email - Disposable domain (should fail) - Too long (should fail) - None input (should fail) - Empty string (should fail) - Missing @ (should fail)

Debug this Flask API error. Diagnose the root cause, then provide the fix. Endpoint: POST /api/orders Framework: Flask 3.0 + SQLAlchemy 2.0 Database: PostgreSQL 16 Error traceback: sqlalchemy.exc.IntegrityError: (psycopg2.errors.ForeignKeyViolation) insert or update on table "order_items" violates foreign key constraint "order_items_product_id_fkey" DETAIL: Key (product_id)=(847) is not present in table "products". Route handler: @app.route('/api/orders', methods=['POST']) def create_order(): data = request.get_json() order = Order(customer_id=data['cid']) db.session.add(order) db.session.flush() for item in data['items']: oi = OrderItem( order_id=order.id, product_id=item['product_id'], quantity=item['qty']) db.session.add(oi) db.session.commit() return jsonify(order.to_dict()), 201 Request payload that triggers the error: {"cid": 12, "items": [ {"product_id": 847, "qty": 2} ]}

Root cause: product_id 847 doesn't exist in the products table. The route handler doesn't validate that product IDs exist before inserting order items. The fix (validate before insert): @app.route('/api/orders', methods=['POST']) def create_order(): data = request.get_json() # Validate all product IDs exist product_ids = [i['product_id'] for i in data['items']] existing = db.session.query( Product.id ).filter( Product.id.in_(product_ids) ).all() existing_ids = {p.id for p in existing} missing = set(product_ids) - existing_ids if missing: return jsonify({ "error": "Invalid product IDs", "missing": list(missing) }), 400 # ... rest of the handler

Refactor this [language] code. Current issues: 1. [specific problem — performance, readability, coupling, duplication, etc.] 2. [specific problem] 3. [specific problem] Constraints: - Must maintain the same public API (function signature, return type) - Must pass these existing tests: [list] - Target complexity: [O(n), O(n log n), etc.] - Use [pattern/library] for [specific part] Don't change: - [things that should stay the same] [paste the code]

Write pytest tests for this function: [paste the function] Test framework: pytest Style: AAA (Arrange-Act-Assert) Naming: test_[function]_[scenario]_[expected] Cover these scenarios: 1. Happy path with typical input 2. Empty input 3. None/null input 4. Boundary values (0, max int, etc.) 5. Invalid types 6. Concurrent access (if applicable) 7. Large input (performance sanity check) For each test: - Clear docstring explaining what's tested - Explicit assertion messages - No test interdependencies

import pytest from app.validators import validate_email class TestValidateEmail: def test_valid_standard_email(self): """Standard email passes validation.""" assert validate_email("user@example.com") def test_valid_email_with_plus_tag(self): """Gmail-style + tags are valid.""" assert validate_email( "user+newsletter@gmail.com") def test_none_input_returns_false(self): """None input should not raise.""" assert not validate_email(None) def test_disposable_domain_rejected(self): """Disposable emails are rejected.""" assert not validate_email( "test@mailinator.com") def test_exceeds_max_length_rejected(self): """Emails > 254 chars are invalid.""" long = "a" * 245 + "@test.com" assert not validate_email(long)

For code generation: □ Language and version (Python 3.11) □ Framework and version (Flask 3.0) □ Function signature with types □ Dependencies allowed/forbidden □ Coding conventions (naming, style) □ Related types/interfaces For debugging: □ Full error message / traceback □ The code that triggers the error □ The input that causes the failure □ Database schema (if DB-related) □ Framework/library versions □ What you've already tried For refactoring: □ The current code □ What's wrong with it (specific issues) □ What "better" looks like (target) □ Constraints (API compatibility, etc.) □ Existing tests that must still pass

□ Specified language and version "Python 3.11" not just "Python" □ Included function signature Name, parameters, types, return type □ Listed edge cases explicitly None, empty, boundary values, errors □ Specified dependencies "Standard library only" or "can use X" □ Asked for tests Always. The model writes them for free. □ Provided relevant context Schema, related code, framework version □ Defined "done" What does correct output look like?

□ Read the code before using it Never copy-paste without reading □ Run the tests If they pass, the code probably works If they fail, you found a bug early □ Check edge cases manually The model might have missed one □ Verify no hallucinated APIs Model sometimes invents function names or uses deprecated APIs □ Check security SQL injection, XSS, hardcoded secrets □ Verify it fits your codebase Naming conventions, error handling patterns, logging style