Refactoring your Python App with 12-Factor Methodology

# app.py
from flask import Flask, request, jsonify

app = Flask(__name__)

# In-memory storage for tasks
tasks = []

@app.route("/")
def hello():
return "Welcome to the Task Management App!"

@app.route("/tasks", methods=["GET"])
def get_tasks():
return jsonify(tasks)

@app.route("/tasks", methods=["POST"])
def add_task():
task = request.json.get("task")
if task:
new_task = {"id": len(tasks) + 1, "task": task, "completed": False}
tasks.append(new_task)
return jsonify(new_task), 201
return jsonify({"error": "Invalid task"}), 400

@app.route("/tasks/<int:task_id>", methods=["PUT"])
def update_task(task_id):
task = next((task for task in tasks if task["id"] == task_id), None)
if task:
task["completed"] = request.json.get("completed", task["completed"])
return jsonify(task)
return jsonify({"error": "Task not found"}), 404

@app.route("/tasks/<int:task_id>", methods=["DELETE"])
def delete_task(task_id):
global tasks
tasks = [task for task in tasks if task["id"] != task_id]
return "", 204

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

The application in app.py is a simple Flask-based task management API. Here's a breakdown of its functionality:

1. It creates a Flask application instance.

2. It uses an in-memory list to store tasks (as a temporary solution).

3. It defines several routes:

- A root route ("/") that returns a welcome message.

- A GET route ("/tasks") to retrieve all tasks.

- A POST route ("/tasks") to add a new task.

- A PUT route ("/tasks/<task_id>") to update a task's completion status.

- A DELETE route ("/tasks/<task_id>") to remove a task.

4. Each route handles its respective HTTP method and performs operations on the tasks list.

5. The application runs in debug mode when executed directly.

Regarding refactoring with the 12-factor app methodology, here are some brief suggestions: [1]

1. Codebase: The application is already in a single codebase, which is good.

2. Dependencies: Create a requirements.txt file to explicitly declare and isolate dependencies.

3. Config: Move configuration settings (like debug mode) into environment variables.

4. Backing Services: Replace the in-memory list with a proper database, treated as an attached resource.

5. Build, release, run: Separate these stages clearly in your deployment process.

6. Processes: Ensure the app is stateless, moving the task storage to a backing service.

7. Port binding: The app is already designed to be self-contained, which is good.

8. Concurrency: Ensure the app can scale horizontally by running multiple instances.

9. Disposability: Implement graceful shutdown and startup processes.

10. Dev/prod parity: Keep development, staging, and production environments as similar as possible.

11. Logs: Implement proper logging instead of using print statements.

12. Admin processes: Any admin or management tasks should be run as one-off processes in identical environments.

Implementing these factors would make the application more robust, scalable, and easier to maintain, especially in a cloud environment.

Sources
[1] The 12-Factor App Methodology
blog.mikaeels.comtwelve-factor-app-methodology

docker-compose up --build