Introduction to Vibora: A High-Performance Web Framework

Vibora is a modern, fast, and asynchronous Python web framework known for its excellent performance and efficiency when building APIs or web applications. Designed with simplicity in mind, Vibora uses Python’s asyncio features to handle requests in an elegant and non-blocking way, making it an ideal choice for developers who value speed, scalability, and maintainability.

In this guide, we’ll dive into Vibora’s key features and showcase dozens of APIs with practical code snippets. By the end of this article, you’ll have the knowledge to build a fully functional web application using Vibora.

Why Choose Vibora?

• Blazing-fast performance thanks to asynchronous programming.
• Support for routing, templating, WebSocket, and more.
• HTML and JSON rendering for RESTful services.
• Easy integration with third-party libraries and tools.

Getting Started with Vibora

First, you’ll need to install Vibora. Use the following command:

  pip install vibora

Creating a Simple Hello World API

The easiest way to get started with Vibora is by creating a simple “Hello World” API. Here’s how:

  from vibora import Vibora, Response

  app = Vibora()

  @app.route('/')
  async def home():
      return Response(b'Hello World!')

  if __name__ == '__main__':
      app.run(host='127.0.0.1', port=8000)

Run the script, and navigate to http://127.0.0.1:8000 in your web browser. You’ll see the message Hello World!

Understanding Vibora’s Routing API

Routing is one of the core concepts in Vibora. You can create routes for different HTTP methods, path parameters, and more. Here’s an example:

  @app.route('/greet/')
  async def greet(name: str):
      return Response(f'Hello, {name}!'.encode())

Navigate to /greet/John, and you’ll get the response: Hello, John!

Working with JSON APIs

Vibora makes it easy to build RESTful APIs that return JSON data:

  import json
  from vibora.responses import JsonResponse

  @app.route('/api/data')
  async def get_data():
      data = {'key1': 'value1', 'key2': 'value2'}
      return JsonResponse(data)

Adding Middleware

Middleware is used to process requests and responses globally. Here’s a middleware example:

  from vibora.middlewares import Middleware

  class ExampleMiddleware(Middleware):
      async def before_request(self, request):
          print(f'Received request: {request.path}')

  app.middlewares.append(ExampleMiddleware())

Using Templates for HTML Rendering

Vibora’s template engine makes it easy to render dynamic HTML pages:

  from vibora import templates

  template = templates.Template("
Hello, {{ name }}!
")

  @app.route('/render-html/')
  async def render_html(name: str):
      return template.render(name=name)

Building a Complete Vibora Application

Combining the features above, here’s a complete Vibora application:

  from vibora import Vibora, templates, Response
  from vibora.responses import JsonResponse

  app = Vibora()

  template = templates.Template("
Hello, {{ name }}!
")

  @app.route('/')
  async def home():
      return Response(b'Welcome to Vibora!')

  @app.route('/greet/')
  async def greet(name: str):
      return Response(f'Hello, {name}!'.encode())

  @app.route('/api/data')
  async def get_data():
      data = {'key1': 'value1', 'key2': 'value2'}
      return JsonResponse(data)

  @app.route('/render-html/')
  async def render_html(name: str):
      return template.render(name=name)

  if __name__ == '__main__':
      app.run(host='0.0.0.0', port=8000)

With this application, you can handle static text responses, JSON APIs, and template-based HTML rendering, giving you flexibility and speed for developing modern web applications and APIs.

Conclusion

Vibora is an excellent choice for developers seeking performance-oriented web frameworks. With its seamless integration of asynchronous programming and developer-friendly APIs, you can create robust and lightning-fast applications in no time.