This code provides a Flask-based web application API endpoint for...

September 4, 2025 at 09:53 AM

from flask import Flask, request, jsonify
import math
 
app = Flask(__name__)
 
@app.route("/emi-calc-endpoint", methods=["POST"])
def emi_calc():
    data = request.json.get("values", {})
    amount = data.get("amount")
    interest = data.get("interest")
    tenure = data.get("tenure")
 
    try:
        P = float(amount)
        R = float(interest) / 12 / 100  # Monthly interest rate
        N = int(tenure)  # Number of months
 
        # EMI Formula
        emi = (P * R * math.pow(1 + R, N)) / (math.pow(1 + R, N) - 1)
 
        return jsonify({
            "version": "7.2",
            "data": {
                "emi_result": f"₹ {emi:.2f}",
                "rate": f"{interest}% pa"
            }
        })
    except Exception as e:
        return jsonify({"error": str(e)}), 400
 
 
if __name__ == "__main__":
    app.run(debug=True)

This code provides a Flask-based web application API endpoint for calculating Equated Monthly Installments (EMI) for loans. Below is a step-by-step explanation of what the code does:

Importing Libraries:
- Flask: Creates the web application and handles HTTP requests.
- request: Used to retrieve incoming JSON request data.
- jsonify: Used to format Python data into JSON responses.
- math: Used for mathematical operations (e.g., exponentiation).
Creating a Flask Application:
- app = Flask(__name__) initializes the Flask app.
Defining an Endpoint:
- The route /emi-calc-endpoint is defined to accept HTTP POST requests (methods=["POST"]).
- This endpoint is meant to calculate the EMI based on input JSON.
Receiving and Parsing Input Data:
- request.json.get("values", {}) retrieves the values field from the JSON body of the incoming request.
- The expected input JSON format is something like:
```
{
  "values": {
    "amount": 100000,
    "interest": 10,
    "tenure": 12
  }
}
```
- The loan amount, annual interest rate, and tenure in months are extracted from this input.
EMI Calculation:
- The formula for calculating EMI is: [ \text{EMI} = \frac{P \times R \times (1+R)^N}{(1+R)^N - 1} ] Where:
  - ( P ): Principal loan amount.
  - ( R ): Monthly interest rate. Converted from annual percentage by dividing by 12 and 100: float(interest) / 12 / 100.
  - ( N ): Loan tenure in months.
- The monthly EMI is computed using Python's math.pow for exponentiation, then formatted to 2 decimal places for output.

Returning the EMI Calculation:

On successful calculation, the result is returned as a JSON response in the following format:

{
  "version": "7.2",
  "data": {
    "emi_result": "₹ EMI_VALUE",
    "rate": "INTEREST_VALUE% pa"
  }
}

For example:

{
  "version": "7.2",
  "data": {
    "emi_result": "₹ 8791.67",
    "rate": "10% pa"
  }
}

Handling Errors:
- If anything goes wrong (e.g., missing data or invalid input types), the code catches the exception and returns a 400 HTTP status with an error message:
```
{
  "error": "Error message"
}
```
Running the Flask Application:
- The app.run(debug=True) starts the Flask development server, making the API accessible for testing (running locally by default at http://127.0.0.1:5000).

Purpose:

This code is a RESTful API endpoint designed to calculate loan EMIs based on user-provided loan amount, annual interest rate, and tenure. It validates input, performs the calculation, and returns the EMI in a structured JSON response.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr