usage: app.py [-h] [--processes PROCESSES] [--workers WORKERS] [--log-level LOG_LEVEL] [--create] [--docs] [--open-browser] [--version]

Robyn, a fast async web framework with a rust runtime.

options:
  -h, --help            show this help message and exit
  --processes PROCESSES
                        Choose the number of processes. [Default: 1]
  --workers WORKERS     Choose the number of workers. [Default: 1]
  --dev                 Development mode. It restarts the server based on file changes.
  --log-level LOG_LEVEL
                        Set the log level name
  --create              Create a new project template.
  --docs                Open the Robyn documentation.
  --open-browser        Open the browser on successful start.
  --version             Show the Robyn version.
  --compile-rust-path COMPILE_RUST_PATH
                        Compile rust files in the given path.
  --create-rust-file CREATE_RUST_FILE
                        Create a rust file with the given name.
  --disable-openapi     Disable the OpenAPI documentation.
  --fast                Fast mode. It sets the optimal values for processes, workers and log level. However, you can override them.

# Basic development mode
python app.py --dev

# Development with custom port
python app.py --dev --port 3000

# Development with debug logging
python app.py --dev --log-level DEBUG

# Fast mode (automatic optimization)
python app.py --fast

# Custom scaling configuration
python app.py --processes 4 --workers 2

# Production with specific log level
python app.py --fast --log-level INFO

usage: python -m robyn app.py [-h] [--processes PROCESSES] [--workers WORKERS] [--dev] [--log-level LOG_LEVEL] [--create] [--docs] [--open-browser] [--version]


Robyn, a fast async web framework with a rust runtime.

options:
  -h, --help            show this help message and exit
  --processes PROCESSES
                        Choose the number of processes. [Default: 1]
  --workers WORKERS     Choose the number of workers. [Default: 1]
  --dev                 Development mode. It restarts the server based on file changes.
  --log-level LOG_LEVEL
                        Set the log level name
  --create              Create a new project template.
  --docs                Open the Robyn documentation.
  --open-browser        Open the browser on successful start.
  --version             Show the Robyn version.
  --compile-rust-path COMPILE_RUST_PATH
                        Compile rust files in the given path.
  --create-rust-file CREATE_RUST_FILE
                        Create a rust file with the given name.
  --disable-openapi     Disable the OpenAPI documentation.
  --fast                Fast mode. It sets the optimal values for processes, workers and log level. However, you can override them.

from robyn import Robyn, Request
import json

app = Robyn(__file__)

# In-memory storage for demo
posts = {
    "1": {"id": "1", "title": "First Post", "content": "Hello World"},
    "2": {"id": "2", "title": "Second Post", "content": "Learning Robyn"}
}

# GET - Retrieve all posts
@app.get("/posts")
def get_posts(query_params):
    limit = int(query_params.get("limit", "10"))
    posts_list = list(posts.values())[:limit]
    return {"posts": posts_list, "total": len(posts)}

# GET - Retrieve specific post
@app.get("/posts/:id")
def get_post(path_params):
    post_id = path_params["id"]
    if post_id in posts:
        return {"post": posts[post_id]}
    return {"error": "Post not found"}, 404

# POST - Create new post
@app.post("/posts")
def create_post(body):
    data = json.loads(body)
    post_id = str(len(posts) + 1)
    new_post = {
        "id": post_id,
        "title": data.get("title", ""),
        "content": data.get("content", "")
    }
    posts[post_id] = new_post
    return {"message": "Post created", "post": new_post}, 201

# PUT - Update entire post
@app.put("/posts/:id")
def update_post(path_params, body):
    post_id = path_params["id"]
    if post_id not in posts:
        return {"error": "Post not found"}, 404
    
    data = json.loads(body)
    posts[post_id] = {
        "id": post_id,
        "title": data.get("title", ""),
        "content": data.get("content", "")
    }
    return {"message": "Post updated", "post": posts[post_id]}

# PATCH - Partial update
@app.patch("/posts/:id")
def patch_post(path_params, body):
    post_id = path_params["id"]
    if post_id not in posts:
        return {"error": "Post not found"}, 404
    
    data = json.loads(body)
    post = posts[post_id]
    
    # Update only provided fields
    if "title" in data:
        post["title"] = data["title"]
    if "content" in data:
        post["content"] = data["content"]
    
    return {"message": "Post updated", "post": post}

# DELETE - Remove post
@app.delete("/posts/:id")
def delete_post(path_params):
    post_id = path_params["id"]
    if post_id not in posts:
        return {"error": "Post not found"}, 404
    
    deleted_post = posts.pop(post_id)
    return {"message": "Post deleted", "post": deleted_post}

from robyn import Robyn, Request
from datetime import datetime
import json

app = Robyn(__file__)

# Simple JSON response - automatic serialization
@app.get("/api/status")
def get_status():
    return {
        "status": "active",
        "timestamp": datetime.now().isoformat(),
        "version": "1.0.0"
    }

# Complex nested JSON
@app.get("/api/user/:id")
def get_user_profile(path_params):
    user_id = path_params["id"]
    return {
        "user": {
            "id": user_id,
            "profile": {
                "name": "John Doe",
                "email": "john@example.com",
                "preferences": {
                    "theme": "dark",
                    "notifications": True
                }
            },
            "activity": [
                {"action": "login", "timestamp": "2024-01-15T10:30:00Z"},
                {"action": "view_post", "timestamp": "2024-01-15T10:35:00Z"}
            ]
        }
    }

# List/array responses
@app.get("/api/posts")
def get_posts():
    return [
        {"id": 1, "title": "First Post", "published": True},
        {"id": 2, "title": "Draft Post", "published": False},
        {"id": 3, "title": "Latest Post", "published": True}
    ]

# Custom status codes with JSON
@app.post("/api/posts")
def create_post(body):
    try:
        data = json.loads(body)
        # Validate required fields
        if not data.get("title"):
            return {"error": "Title is required"}, 400
        
        # Success response
        return {
            "message": "Post created successfully",
            "post": {
                "id": 123,
                "title": data["title"],
                "created_at": datetime.now().isoformat()
            }
        }, 201
    except json.JSONDecodeError:
        return {"error": "Invalid JSON format"}, 400

from robyn.robyn import QueryParams, Headers
from robyn.types import PathParams, RequestMethod, RequestBody, RequestURL

@app.get("/untyped/query_params")
def untyped_basic(query_params):
    return query_params.to_dict()


@app.get("/typed/query_params")
def typed_basic(query_data: QueryParams):
    return query_data.to_dict()


@app.get("/untyped/path_params/:id")
def untyped_path_params(query_params: PathParams):
    return query_params  # contains the path params since the type annotations takes precedence over the reserved names


@app.post("/typed_untyped/combined")
def typed_untyped_combined(
        query_params,
        method_data: RequestMethod,
        body_data: RequestBody,
        url: RequestURL,
        headers_item: Headers,
):
    return {
        "body": body_data,
        "query_params": query_params.to_dict(),
        "method": method_data,
        "url": url.path,
        "headers": headers_item.get("server"),
    }