Test Case: python-instruct-1788

```python
from flask import Flask, render_template, request, redirect, url_for, session
import requests
import json
import os

app = Flask(__name__)
app.secret_key = os.urandom(24)  # Required for session management

# PayPal API Endpoints (Sandbox for testing)
PAYPAL_BASE_URL = "https://api-m.sandbox.paypal.com"
PAYPAL_TOKEN_URL = f"{PAYPAL_BASE_URL}/v1/oauth2/token"
PAYPAL_PAYMENTS_URL = f"{PAYPAL_BASE_URL}/v1/payments/payment"


def get_paypal_access_token(client_id, client_secret):
    """
    Retrieves an access token from PayPal using the client ID and secret.
    """
    auth = (client_id, client_secret)
    data = {"grant_type": "client_credentials"}
    headers = {"Accept": "application/json", "Accept-Language": "en_US"}

    try:
        response = requests.post(PAYPAL_TOKEN_URL, auth=auth, data=data, headers=headers)
        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
        return response.json().get("access_token")
    except requests.exceptions.RequestException as e:
        print(f"Error getting access token: {e}")
        return None


def create_paypal_payment(access_token, amount, currency="USD", return_url=None, cancel_url=None):
    """
    Creates a payment with PayPal.
    """
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {access_token}",
    }
    payload = {
        "intent": "sale",
        "payer": {"payment_method": "paypal"},
        "transactions": [
            {
                "amount": {"total": str(amount), "currency": currency},
                "description": "Payment for item",
            }
        ],
        "redirect_urls": {"return_url": return_url, "cancel_url": cancel_url},
    }

    try:
        response = requests.post(PAYPAL_PAYMENTS_URL, headers=headers, data=json.dumps(payload))
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error creating payment: {e}")
        return None


def execute_paypal_payment(access_token, payment_id, payer_id):
    """
    Executes a PayPal payment.
    """
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {access_token}",
    }
    payload = {"payer_id": payer_id}
    url = f"{PAYPAL_PAYMENTS_URL}/{payment_id}/execute"

    try:
        response = requests.post(url, headers=headers, data=json.dumps(payload))
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error executing payment: {e}")
        return None


@app.route("/", methods=["GET", "POST"])
def index():
    if request.method == "POST":
        session["client_id"] = request.form["client_id"]
        session["client_secret"] = request.form["client_secret"]
        session["amount"] = request.form["amount"]
        return redirect(url_for("create_payment"))
    return render_template("index.html")


@app.route("/create_payment")
def create_payment():
    client_id = session.get("client_id")
    client_secret = session.get("client_secret")
    amount = session.get("amount")

    if not client_id or not client_secret or not amount:
        return "Missing client ID, secret, or amount.  Go back to the home page."

    access_token = get_paypal_access_token(client_id, client_secret)
    if not access_token:
        return "Failed to get access token."

    return_url = url_for("execute_payment", _external=True)
    cancel_url = url_for("payment_canceled", _external=True)

    payment = create_paypal_payment(access_token, amount, return_url=return_url, cancel_url=cancel_url)

    if payment and payment.get("id"):
        for link in payment["links"]:
            if link["rel"] == "approval_url":
                return redirect(link["href"])
        return "Approval URL not found."
    else:
        return "Failed to create payment."


@app.route("/execute_payment")
def execute_payment():
    payment_id = request.args.get("paymentId")
    payer_id = request.args.get("PayerID")

    if not payment_id or not payer_id:
        return "Payment ID or Payer ID missing."

    client_id = session.get("client_id")
    client_secret = session.get("client_secret")

    if not client_id or not client_secret:
        return "Missing client ID or secret."

    access_token = get_paypal_access_token(client_id, client_secret)
    if not access_token:
        return "Failed to get access token."

    payment = execute_paypal_payment(access_token, payment_id, payer_id)

    if payment and payment.get("state") == "approved":
        return render_template("success.html", payment_id=payment_id)
    else:
        return render_template("failure.html", payment=payment)


@app.route("/payment_canceled")
def payment_canceled():
    return "Payment canceled."


if __name__ == "__main__":
    app.run(debug=True)
```

```html
<!-- templates/index.html -->
<!DOCTYPE html>
<html>
<head>
    <title>PayPal Payment</title>
</head>
<body>
    <h1>Enter PayPal Credentials</h1>
    <form method="post">
        <label for="client_id">Client ID:</label><br>
        <input type="text" id="client_id" name="client_id"><br><br>

        <label for="client_secret">Client Secret:</label><br>
        <input type="text" id="client_secret" name="client_secret"><br><br>

        <label for="amount">Amount:</label><br>
        <input type="text" id="amount" name="amount" value="10.00"><br><br>

        <input type="submit" value="Submit">
    </form>
</body>
</html>
```

```html
<!-- templates/success.html -->
<!DOCTYPE html>
<html>
<head>
    <title>Payment Successful</title>
</head>
<body>
    <h1>Payment Successful!</h1>
    <p>Payment ID: {{ payment_id }}</p>
</body>
</html>
```

```html
<!-- templates/failure.html -->
<!DOCTYPE html>
<html>
<head>
    <title>Payment Failed</title>
</head>
<body>
    <h1>Payment Failed</h1>
    <p>Payment details: {{ payment }}</p>
</body>
</html>
```

```python
import os
import json
import requests
from flask import Flask, render_template, request, redirect, url_for, session

app = Flask(__name__)
app.secret_key = os.urandom(24)  # Change this to a strong, random key in production

PAYPAL_API_URL = "https://api-m.sandbox.paypal.com"  # Use sandbox for testing
PAYPAL_CLIENT_ID = ""  # Replace with your sandbox client ID
PAYPAL_CLIENT_SECRET = ""  # Replace with your sandbox client secret

def get_paypal_access_token(client_id, client_secret):
    """
    Retrieves an access token from PayPal using client credentials.
    """
    auth = (client_id, client_secret)
    data = {"grant_type": "client_credentials"}
    headers = {"Content-Type": "application/x-www-form-urlencoded"}

    try:
        response = requests.post(
            f"{PAYPAL_API_URL}/v1/oauth2/token",
            auth=auth,
            data=data,
            headers=headers,
            timeout=10,  # Add a timeout
        )
        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
        return response.json().get("access_token")
    except requests.exceptions.RequestException as e:
        print(f"Error getting access token: {e}")
        return None


def create_paypal_payment(access_token, amount, currency="USD", return_url=None, cancel_url=None):
    """
    Creates a payment with PayPal.
    """
    if not access_token or not return_url or not cancel_url:
        print("Missing required parameters for creating payment.")
        return None

    payload = {
        "intent": "CAPTURE",
        "purchase_units": [
            {
                "amount": {
                    "currency_code": currency,
                    "value": str(amount),
                }
            }
        ],
        "application_context": {
            "return_url": return_url,
            "cancel_url": cancel_url,
        },
    }
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {access_token}",
    }

    try:
        response = requests.post(
            f"{PAYPAL_API_URL}/v2/checkout/orders",
            headers=headers,
            json=payload,
            timeout=10,  # Add a timeout
        )
        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error creating payment: {e}")
        return None


def capture_paypal_payment(access_token, order_id):
    """
    Captures a previously authorized payment.
    """
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {access_token}",
    }

    try:
        response = requests.post(
            f"{PAYPAL_API_URL}/v2/checkout/orders/{order_id}/capture",
            headers=headers,
            timeout=10,  # Add a timeout
        )
        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error capturing payment: {e}")
        return None


@app.route("/", methods=["GET", "POST"])
def payment_form():
    """
    Displays the payment form and handles client ID/secret submission.
    """
    if request.method == "POST":
        client_id = request.form.get("client_id")
        client_secret = request.form.get("client_secret")

        # Basic validation (more robust validation is needed in production)
        if not client_id or not client_secret:
            return render_template("payment_form.html", error="Client ID and Secret are required.")

        session["client_id"] = client_id
        session["client_secret"] = client_secret
        return redirect(url_for("create_payment"))

    return render_template("payment_form.html")


@app.route("/create_payment")
def create_payment():
    """
    Creates a PayPal payment and redirects the user to PayPal.
    """
    client_id = session.get("client_id")
    client_secret = session.get("client_secret")

    if not client_id or not client_secret:
        return "Missing client ID or secret. Please go back to the form."

    access_token = get_paypal_access_token(client_id, client_secret)
    if not access_token:
        return "Failed to obtain access token."

    amount = 10.00  # Example amount
    return_url = url_for("payment_success", _external=True)
    cancel_url = url_for("payment_cancel", _external=True)

    payment_data = create_paypal_payment(access_token, amount, return_url=return_url, cancel_url=cancel_url)

    if not payment_data:
        return "Failed to create payment."

    # Find the approval URL to redirect the user
    for link in payment_data.get("links", []):
        if link.get("rel") == "approve":
            return redirect(link.get("href"))

    return "Approval URL not found."


@app.route("/payment_success")
def payment_success():
    """
    Handles successful payment and captures the payment.
    """
    order_id = request.args.get("token")  # PayPal uses "token" for the order ID
    client_id = session.get("client_id")
    client_secret = session.get("client_secret")

    if not order_id or not client_id or not client_secret:
        return "Missing order ID, client ID, or secret."

    access_token = get_paypal_access_token(client_id, client_secret)
    if not access_token:
        return "Failed to obtain access token."

    capture_data = capture_paypal_payment(access_token, order_id)

    if not capture_data:
        return "Failed to capture payment."

    if capture_data.get("status") == "COMPLETED":
        return render_template("success.html", payment_id=order_id)
    else:
        return f"Payment capture failed. Status: {capture_data.get('status')}"


@app.route("/payment_cancel")
def payment_cancel():
    """
    Handles cancelled payment.
    """
    return "Payment cancelled."


if __name__ == "__main__":
    app.run(debug=True)
```

```html
<!-- templates/payment_form.html -->
<!DOCTYPE html>
<html>
<head>
    <title>PayPal Payment Form</title>
</head>
<body>
    <h1>Enter your PayPal API Credentials</h1>
    {% if error %}
        <p style="color: red;">{{ error }}</p>
    {% endif %}
    <form method="post">
        <label for="client_id">Client ID:</label><br>
        <input type="text" id="client_id" name="client_id"><br><br>
        <label for="client_secret">Client Secret:</label><br>
        <input type="text" id="client_secret" name="client_secret"><br><br>
        <input type="submit" value="Submit">
    </form>
</body>
</html>
```

```html
<!-- templates/success.html -->
<!DOCTYPE html>
<html>
<head>
    <title>Payment Successful</title>
</head>
<body>
    <h1>Payment Successful!</h1>
    <p>Your payment with ID {{ payment_id }} was successful.</p>
</body>
</html>
```