feat: updating main, uuid, base, and json

Author: MeelahMe

app/main.py

@@ -1,15 +1,40 @@
 from fastapi import FastAPI
-from app.routes import json_tools, uuid_tools, base64_tools, time_tools, password_tools
+from app.routes import (
+    json_tools,
+    uuid_tools,
+    base64_tools,
+    time_tools,
+    password_tools
+)
 
-app = FastAPI(title="Developer Toolkit API")
+# Initialize the FastAPI app with metadata for documentation
+app = FastAPI(
+    title="Developer Toolkit API",
+    description="A collection of backend utilities for developers including encoding, formatting, timestamp conversion, and more.",
+    version="1.0.0",
+    contact={
+        "name": "Jameelah Mercer",
+        "email": "hello@juadocs.com",
+        "url": "https://juadocs.com"
+    },
+    license_info={
+        "name": "MIT",
+        "url": "https://opensource.org/licenses/MIT",
+    },
+)
 
+# Register routers for each toolkit module
 app.include_router(json_tools.router)
 app.include_router(uuid_tools.router)
 app.include_router(base64_tools.router)
 app.include_router(time_tools.router)
 app.include_router(password_tools.router)
 
-@app.get("/")
+# Root route to verify the API is running
+@app.get("/", tags=["Root"])
 def read_root():
+    """
+    Root endpoint that returns a welcome message.
+    """
     return {"message": "Welcome to the Developer Toolkit API!"}
 

app/routes/base64_tools.py

@@ -2,30 +2,31 @@
 from pydantic import BaseModel, Field
 import base64
 
+# Create a router for Base64 encoding/decoding routes
 router = APIRouter(prefix="/tools/base64", tags=["Base64 Tools"])
 
-# Input model for encoding plain text
+# Request model for encoding input
 class Base64EncodeInput(BaseModel):
     content: str = Field(
         example="hello world",
         description="The plain text string to encode into Base64"
     )
 
-# Output model for encoded result
+# Response model for encoded result
 class Base64EncodeResponse(BaseModel):
     encoded: str = Field(
         example="aGVsbG8gd29ybGQ=",
-        description="The Base64-encoded string"
+        description="The Base64-encoded output string"
     )
 
-# Input model for decoding Base64 string
+# Request model for decoding input
 class Base64DecodeInput(BaseModel):
     encoded: str = Field(
         example="aGVsbG8gd29ybGQ=",
         description="The Base64-encoded string to decode"
     )
 
-# Output model for decoded result
+# Response model for decoded result
 class Base64DecodeResponse(BaseModel):
     decoded: str = Field(
         example="hello world",
@@ -36,14 +37,17 @@ class Base64DecodeResponse(BaseModel):
     "/encode",
     response_model=Base64EncodeResponse,
     summary="Encode a string to Base64",
-    response_description="Returns the Base64-encoded version of the input"
+    response_description="Returns the Base64-encoded result"
 )
 def encode_base64(data: Base64EncodeInput):
     """
-    Encode a plain text string into Base64.
+    Encode a plain text string into Base64 format.
 
-    Accepts a `content` field containing a UTF-8 string,
-    and returns its Base64-encoded version.
+    Parameters:
+        data (Base64EncodeInput): JSON object with a 'content' field.
+
+    Returns:
+        Base64EncodeResponse: Encoded Base64 string.
     """
     try:
         encoded = base64.b64encode(data.content.encode("utf-8")).decode("utf-8")
@@ -54,15 +58,18 @@ def encode_base64(data: Base64EncodeInput):
 @router.post(
     "/decode",
     response_model=Base64DecodeResponse,
-    summary="Decode a Base64 string to plain text",
-    response_description="Returns the decoded string"
+    summary="Decode a Base64 string",
+    response_description="Returns the decoded plain text result"
 )
 def decode_base64(data: Base64DecodeInput):
     """
-    Decode a Base64 string back into plain text.
+    Decode a Base64 string into a plain UTF-8 string.
+
+    Parameters:
+        data (Base64DecodeInput): JSON object with an 'encoded' field.
 
-    Accepts an `encoded` field containing a Base64 string,
-    and returns the decoded UTF-8 string.
+    Returns:
+        Base64DecodeResponse: Decoded plain text string.
     """
     try:
         decoded_bytes = base64.b64decode(data.encoded.encode("utf-8"))

app/routes/json_tools.py

@@ -2,20 +2,21 @@
 from pydantic import BaseModel, Field
 import json
 
+# Create a FastAPI router with a URL prefix and tag for grouping
 router = APIRouter(prefix="/tools/json", tags=["JSON Tools"])
 
-# Request model with a raw JSON string input
+# Request model for the JSON prettifier
 class JSONPrettifyInput(BaseModel):
     content: str = Field(
         example='{"key":"value"}',
-        description="Raw JSON string to format"
+        description="Raw JSON string to be formatted"
     )
 
-# Response model with prettified output
+# Response model for the prettified JSON output
 class JSONPrettifyResponse(BaseModel):
     prettified: str = Field(
         example='{\n    "key": "value"\n}',
-        description="Formatted JSON string with indentation"
+        description="Formatted JSON string with proper indentation"
     )
 
 @router.post(
@@ -26,19 +27,19 @@ class JSONPrettifyResponse(BaseModel):
 )
 def prettify_json(data: JSONPrettifyInput):
     """
-    Prettify (beautify) a raw JSON string.
+    Convert a compact JSON string into a human-readable, formatted string.
 
-    Accepts a compact JSON string and returns a formatted version
-    with indentation and line breaks.
+    Parameters:
+        data (JSONPrettifyInput): JSON payload containing raw JSON text.
 
     Returns:
-        JSON object containing a single `prettified` key with the formatted string.
+        JSONPrettifyResponse: A dictionary with the prettified version of the input JSON.
     """
     try:
-        # Parse the input JSON string to an object
+        # Parse the raw JSON string into a Python object
         parsed = json.loads(data.content)
 
-        # Convert it back to a nicely indented string
+        # Re-convert to JSON with indentation
         prettified = json.dumps(parsed, indent=4)
 
         return {"prettified": prettified}

app/routes/uuid_tools.py

@@ -2,9 +2,10 @@
 from pydantic import BaseModel, Field
 import uuid
 
+# Create a router with a URL prefix and grouping tag
 router = APIRouter(prefix="/tools/uuid", tags=["UUID Tools"])
 
-# Response model with example UUID
+# Response model for the UUID generator
 class UUIDResponse(BaseModel):
     uuid: str = Field(
         example="123e4567-e89b-12d3-a456-426614174000",
@@ -19,10 +20,10 @@ class UUIDResponse(BaseModel):
 )
 def generate_uuid():
     """
-    Generate a random UUID version 4.
+    Generate a version 4 (random) UUID.
 
     Returns:
-        A JSON object containing a stringified UUID.
+        UUIDResponse: A dictionary containing the generated UUID.
     """
     return {"uuid": str(uuid.uuid4())}