Introduction to Robyn

Robyn is a cutting-edge API framework designed for high-performance, rapid development, and scalability. Built for modern developers, Robyn allows you to write asynchronous, event-driven APIs with minimal effort. If you’re looking for a robust solution to build blazing-fast APIs, Robyn might be the perfect framework for you.

Why Choose Robyn?

• High performance and low latency.
• Ease of use with simple and intuitive syntax.
• Asynchronous support for enhanced scalability.
• Lightweight and efficient.

Features of Robyn

Robyn comes packed with features to simplify API development while ensuring exceptional performance. Below are some of the key APIs and how to use them:

1. Route Handling

Robyn provides a clean and efficient way to define HTTP routes:

  from robyn import App

  app = App()

  @app.get("/hello")
  async def say_hello(request):
      return {"message": "Hello, world!"}

  app.start()

2. Path Parameters

Extract parameters from the URL path like a pro:

  @app.get("/greet/{name}")
  async def greet_user(request, name):
      return {"message": f"Hello, {name}!"}

3. Query Parameters

Parse and use query params with ease:

  @app.get("/search")
  async def search(request):
      query = request.query_params.get("q", "default_search")
      return {"result": f"Searching for {query}"}

4. Post Requests

Handle POST requests efficiently:

  @app.post("/submit")
  async def handle_post(request):
      data = await request.json()
      return {"received_data": data}

5. Middleware

Add middleware to preprocess or postprocess requests and responses:

  @app.middleware("before_request")
  async def log_request(request):
      print(f"Request received: {request.method} {request.path}")

  @app.middleware("after_response")
  async def add_header(response):
      response.headers["X-Custom-Header"] = "RobynMiddleware"

6. WebSockets Support

Create real-time applications using WebSocket endpoints:

  @app.websocket("/ws")
  async def websocket_handler(websocket):
      await websocket.send_text("Welcome to the WebSocket!")
      while True:
          message = await websocket.receive_text()
          await websocket.send_text(f"Received: {message}")

7. Static Files

Serve your static assets seamlessly:

  app.static("/static", "./static_folder")

Sample Application: A Simple To-Do List API

Here’s a complete example of a To-Do List API using Robyn:

  from robyn import App

  app = App()

  todos = []

  @app.get("/todos")
  async def get_todos(request):
      return {"todos": todos}

  @app.post("/todos")
  async def add_todo(request):
      data = await request.json()
      todos.append(data["task"])
      return {"message": "Task added successfully!"}

  @app.delete("/todos/{index}")
  async def delete_todo(request, index: int):
      if 0 <= index < len(todos):
          removed_task = todos.pop(index)
          return {"message": f"Task '{removed_task}' removed successfully!"}
      return {"error": "Invalid index!"}

  @app.put("/todos/{index}")
  async def update_todo(request, index: int):
      if 0 <= index < len(todos):
          data = await request.json()
          todos[index] = data["task"]
          return {"message": f"Task updated to '{todos[index]}' successfully!"}
      return {"error": "Invalid index!"}

  app.start()

Conclusion

Robyn is a versatile and high-performance API framework that caters to modern development needs. Whether you're working on real-time applications, complex APIs, or simple web services, Robyn's powerful features and simplicity make it an excellent choice for developers. Explore Robyn today and build scalable, lightning-fast APIs!