12 Prompts for ChatGPT and GPT-4: From Code Writing to Architecture Design

Write a Python function `parse_json_file(filepath)` that:
- Reads a JSON file from the given path
- Returns a dictionary if valid
- Returns `None` if file not found or invalid JSON
- Logs errors using Python's `logging` module (log level ERROR)
- Includes type hints

import json
import logging
from typing import Optional, Dict, Any

def parse_json_file(filepath: str) -> Optional[Dict[str, Any]]:
    """Parse a JSON file and return a dictionary.

    Args:
        filepath (str): Path to the JSON file.

    Returns:
        Optional[Dict[str, Any]]: Parsed data or None on failure.
    """
    try:
        with open(filepath, 'r') as f:
            data = json.load(f)
        return data
    except FileNotFoundError:
        logging.error(f"File not found: {filepath}")
        return None
    except json.JSONDecodeError as e:
        logging.error(f"Invalid JSON in {filepath}: {e}")
        return None

The following Python code raises `IndexError: list index out of range` on line 5. Explain why and fix it.

```python
def get_average(numbers):
    total = 0
    for i in range(len(numbers) + 1):
        total += numbers[i]
    return total / len(numbers)

**Example Result:**
**Explanation:** The loop iterates up to `len(numbers)` (inclusive), but valid indices are `0` to `len(numbers)-1`. When `i` equals `len(numbers)`, `numbers[i]` is out of range.

**Fix:**
```python
def get_average(numbers):
    if not numbers:
        return 0  # or raise ValueError
    total = 0
    for i in range(len(numbers)):
        total += numbers[i]
    return total / len(numbers)

Refactor the following Python function into smaller, single-purpose functions. Maintain the same overall behavior. Use descriptive names and add docstrings.

```python
def process_order(order_data):
    # validate
    if 'items' not in order_data or not order_data['items']:
        raise ValueError('Order must have items')
    # calculate total
    total = 0
    for item in order_data['items']:
        total += item['price'] * item['quantity']
    # apply discount
    if total > 100:
        total *= 0.9
    # save to database
    db.save(order_data)
    return total

**Example Result:**
```python
def validate_order(order_data: dict) -> None:
    """Raise ValueError if order data is invalid."""
    if 'items' not in order_data or not order_data['items']:
        raise ValueError('Order must have items')

def calculate_total(items: list) -> float:
    """Calculate total price from items."""
    return sum(item['price'] * item['quantity'] for item in items)

def apply_discount(total: float) -> float:
    """Apply 10% discount if total > 100."""
    return total * 0.9 if total > 100 else total

def save_order(order_data: dict) -> None:
    """Persist order to database."""
    db.save(order_data)

def process_order(order_data: dict) -> float:
    """Main pipeline for order processing."""
    validate_order(order_data)
    total = calculate_total(order_data['items'])
    total = apply_discount(total)
    save_order(order_data)
    return total

Write unit tests using pytest for the following function. Cover normal cases, empty input, invalid types, and boundary values.

```python
def divide(a: float, b: float) -> float:
    if b == 0:
        raise ValueError('Cannot divide by zero')
    return a / b

**Example Result:**
```python
import pytest

def test_divide_normal():
    assert divide(10, 2) == 5.0
    assert divide(-10, 2) == -5.0
    assert divide(0, 1) == 0.0

def test_divide_by_zero():
    with pytest.raises(ValueError, match='Cannot divide by zero'):
        divide(1, 0)

def test_divide_floats():
    assert divide(7.0, 3.0) == pytest.approx(2.3333, rel=1e-3)

def test_divide_large_numbers():
    assert divide(1e10, 1e-10) == 1e20

The following function finds duplicates in a list of up to 1 million elements. It's too slow. Optimize it for O(n) time complexity.

```python
def find_duplicates(arr):
    duplicates = []
    for i in range(len(arr)):
        for j in range(i+1, len(arr)):
            if arr[i] == arr[j] and arr[i] not in duplicates:
                duplicates.append(arr[i])
    return duplicates

**Example Result:**
```python
def find_duplicates(arr):
    seen = set()
    duplicates = set()
    for item in arr:
        if item in seen:
            duplicates.add(item)
        else:
            seen.add(item)
    return list(duplicates)

Explain the following JavaScript code as if to a junior developer. Describe what each line does and why it's used.

```javascript
const debounce = (fn, delay) => {
  let timerId;
  return (...args) => {
    clearTimeout(timerId);
    timerId = setTimeout(() => fn.apply(this, args), delay);
  };
};

**Example Result:**
This is a **debounce** utility. It ensures a function is not called too frequently—ideal for search input or resize handlers.

- `let timerId;`: Stores the timeout ID across calls.
- `return (...args) => ...`: Returns a new function that wraps the original.
- `clearTimeout(timerId)`: Cancels any pending execution if the function is called again.
- `setTimeout(() => fn.apply(this, args), delay)`: Schedules the original function to run after `delay` ms.

**Why it works:** Every new call resets the timer, so `fn` only runs after the last call.

---

## 7. Generate a Microservice Endpoint with Full Documentation

**Task:** Request an API endpoint with input validation, error handling, and OpenAPI comments.

**Prompt:**

**Example Result:**
```python
from flask import Flask, request, jsonify
import re

app = Flask(__name__)

def is_valid_email(email: str) -> bool:
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
    return re.match(pattern, email) is not None

@app.route('/api/users', methods=['POST'])
def create_user():
    """
    Create a new user.
    ---
    parameters:
      - name: body
        in: body
        required: true
        schema:
          type: object
          properties:
            name:
              type: string
            email:
              type: string
    responses:
      201:
        description: User created
      400:
        description: Validation error
    """
    data = request.get_json()
    if not data:
        return jsonify({'error': 'Request must be JSON'}), 400

    name = data.get('name', '')
    email = data.get('email', '')

    if not name or len(name) < 1 or len(name) > 100:
        return jsonify({'error': 'Name must be 1-100 characters'}), 400
    if not is_valid_email(email):
        return jsonify({'error': 'Invalid email format'}), 400

    # Save to DB logic here (omitted for brevity)
    user_id = 123  # example
    return jsonify({'id': user_id}), 201

Convert the following Python function to idiomatic JavaScript. Maintain the same behavior.

```python
def filter_active_users(users):
    return [u for u in users if u.get('active') and u.get('last_login') > '2025-01-01']

**Example Result:**
```javascript
function filterActiveUsers(users) {
    return users.filter(u => u.active && new Date(u.last_login) > new Date('2025-01-01'));
}

Design a PostgreSQL schema for a blog platform. Requirements:
- Users can write multiple posts
- Posts belong to one category
- Posts can have many tags (many-to-many)
- Include primary keys, foreign keys, and indexes
- Provide CREATE TABLE statements

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE categories (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL
);

CREATE TABLE posts (
    id SERIAL PRIMARY KEY,
    user_id INTEGER REFERENCES users(id),
    category_id INTEGER REFERENCES categories(id),
    title VARCHAR(255) NOT NULL,
    content TEXT,
    published BOOLEAN DEFAULT FALSE,
    created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE tags (
    id SERIAL PRIMARY KEY,
    name VARCHAR(50) UNIQUE NOT NULL
);

CREATE TABLE post_tags (
    post_id INTEGER REFERENCES posts(id),
    tag_id INTEGER REFERENCES tags(id),
    PRIMARY KEY (post_id, tag_id)
);

CREATE INDEX idx_posts_user_id ON posts(user_id);
CREATE INDEX idx_posts_category_id ON posts(category_id);

Write a GitHub Actions workflow for a Python project that:
- Runs on push to main and pull requests
- Installs dependencies
- Runs pytest with coverage
- Lints with flake8
- Only deploys to Heroku on push to main if tests pass

name: CI/CD Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.12'
      - name: Install dependencies
        run: pip install -r requirements.txt
      - name: Lint with flake8
        run: flake8 . --max-line-length=120
      - name: Test with pytest
        run: pytest --cov=.

  deploy:
    needs: test
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to Heroku
        uses: akhileshns/heroku-deploy@v3.12.12
        with:
          heroku_api_key: ${{ secrets.HEROKU_API_KEY }}
          heroku_app_name: "my-app"
          heroku_email: "user@example.com"

Write a regex in Python to extract all phone numbers in format (XXX) XXX-XXXX or XXX-XXX-XXXX from a text. Include explanation and test examples.

import re

pattern = r'\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}'
text = "Call me at (123) 456-7890 or 987-654-3210."
matches = re.findall(pattern, text)
# matches: ['(123) 456-7890', '987-654-3210']

Review the following architecture for a real-time chat application:
- Monolithic Flask backend
- PostgreSQL for messages
- WebSocket for real-time
Suggest three concrete improvements with trade-offs.