Plinx 0.0.1__tar.gz

Plinx-0.0.1/LICENSE

@@ -0,0 +1,8 @@
+Copyright © 2025 Dhaval Savalia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

Plinx-0.0.1/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.1
+Name: Plinx
+Version: 0.0.1
+Summary: Plinx is an experimental, minimalistic, and extensible web framework and ORM written in Python.
+Home-page: https://github.com/dhavalsavalia/plinx
+Author: Dhaval Savalia
+Author-email: coder@dhavalsavalia.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.11.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+
+# Plinx
+
+![purpose](https://img.shields.io/badge/purpose-learning-green.svg)
+![PyPI](https://img.shields.io/pypi/v/bumbo.svg)
+
+**Plinx** is an experimental, minimalistic, and extensible WSGI-based web framework and ORM written in Python.  
+It is designed to be simple, fast, and easy to extend, making it ideal for rapid prototyping and educational purposes.
+
+---
+
+## Features
+
+- 🚀 Minimal and fast web framework
+- 🛣️ Intuitive routing system
+- 🧩 Extensible middleware support
+- 🧪 Simple, readable codebase for learning and hacking
+- 📝 Type hints and modern Python best practices
+
+---
+
+## Installation
+
+Install directly from the git source:
+
+```bash
+pip install git+https://github.com/dhavalsavalia/plinx.git
+```
+
+---
+
+## Quickstart
+
+Create a simple web application in seconds:
+
+```python
+from plinx import Plinx
+
+app = Plinx()
+
+@app.route("/")
+def index(request, response):
+    response.text = "Hello, world!"
+```
+
+Run your app (example, assuming you have an ASGI server like `uvicorn`):
+
+```bash
+uvicorn myapp:app
+```
+
+## Testing
+
+Use [pytest](https://docs.pytest.org/en/latest/) to unit test this framework.
+
+```bash
+pytest --cov=.
+```
+
+---
+
+## Roadmap
+
+- [x] Web Framework
+  - [x] Routing
+  - [x] Explicit Routing Methods (GET, POST, etc.)
+  - [x] Parameterized Routes
+  - [x] Class Based Routes
+  - [x] Django-like Routes
+  - [x] Middleware Support
+- [ ] ORM
+
+---
+
+## Contributing
+
+Contributions are welcome! Please open issues or submit pull requests for improvements, bug fixes, or new features.
+
+---
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](LICENSE) for details.
+
+---
+
+## Author & Contact
+
+Created and maintained by [Dhaval Savalia](https://github.com/dhavalsavalia).  
+For questions or opportunities, feel free to reach out via [LinkedIn](https://www.linkedin.com/in/dhavalsavalia/) or open an issue.
+
+---

Plinx-0.0.1/Plinx.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.1
+Name: Plinx
+Version: 0.0.1
+Summary: Plinx is an experimental, minimalistic, and extensible web framework and ORM written in Python.
+Home-page: https://github.com/dhavalsavalia/plinx
+Author: Dhaval Savalia
+Author-email: coder@dhavalsavalia.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.11.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+
+# Plinx
+
+![purpose](https://img.shields.io/badge/purpose-learning-green.svg)
+![PyPI](https://img.shields.io/pypi/v/bumbo.svg)
+
+**Plinx** is an experimental, minimalistic, and extensible WSGI-based web framework and ORM written in Python.  
+It is designed to be simple, fast, and easy to extend, making it ideal for rapid prototyping and educational purposes.
+
+---
+
+## Features
+
+- 🚀 Minimal and fast web framework
+- 🛣️ Intuitive routing system
+- 🧩 Extensible middleware support
+- 🧪 Simple, readable codebase for learning and hacking
+- 📝 Type hints and modern Python best practices
+
+---
+
+## Installation
+
+Install directly from the git source:
+
+```bash
+pip install git+https://github.com/dhavalsavalia/plinx.git
+```
+
+---
+
+## Quickstart
+
+Create a simple web application in seconds:
+
+```python
+from plinx import Plinx
+
+app = Plinx()
+
+@app.route("/")
+def index(request, response):
+    response.text = "Hello, world!"
+```
+
+Run your app (example, assuming you have an ASGI server like `uvicorn`):
+
+```bash
+uvicorn myapp:app
+```
+
+## Testing
+
+Use [pytest](https://docs.pytest.org/en/latest/) to unit test this framework.
+
+```bash
+pytest --cov=.
+```
+
+---
+
+## Roadmap
+
+- [x] Web Framework
+  - [x] Routing
+  - [x] Explicit Routing Methods (GET, POST, etc.)
+  - [x] Parameterized Routes
+  - [x] Class Based Routes
+  - [x] Django-like Routes
+  - [x] Middleware Support
+- [ ] ORM
+
+---
+
+## Contributing
+
+Contributions are welcome! Please open issues or submit pull requests for improvements, bug fixes, or new features.
+
+---
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](LICENSE) for details.
+
+---
+
+## Author & Contact
+
+Created and maintained by [Dhaval Savalia](https://github.com/dhavalsavalia).  
+For questions or opportunities, feel free to reach out via [LinkedIn](https://www.linkedin.com/in/dhavalsavalia/) or open an issue.
+
+---

Plinx-0.0.1/Plinx.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+setup.py
+Plinx.egg-info/PKG-INFO
+Plinx.egg-info/SOURCES.txt
+Plinx.egg-info/dependency_links.txt
+Plinx.egg-info/top_level.txt
+plinx/__init__.py
+plinx/applications.py
+plinx/methods.py
+plinx/middleware.py
+plinx/response.py
+plinx/status_codes.py
+plinx/utils.py
+plinx.egg-info/PKG-INFO
+plinx.egg-info/SOURCES.txt
+plinx.egg-info/dependency_links.txt
+plinx.egg-info/top_level.txt
+tests/test_application.py

Plinx-0.0.1/Plinx.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

Plinx-0.0.1/Plinx.egg-info/top_level.txt

@@ -0,0 +1 @@
+plinx

Plinx-0.0.1/README.md

@@ -0,0 +1,91 @@
+# Plinx
+
+![purpose](https://img.shields.io/badge/purpose-learning-green.svg)
+![PyPI](https://img.shields.io/pypi/v/bumbo.svg)
+
+**Plinx** is an experimental, minimalistic, and extensible WSGI-based web framework and ORM written in Python.  
+It is designed to be simple, fast, and easy to extend, making it ideal for rapid prototyping and educational purposes.
+
+---
+
+## Features
+
+- 🚀 Minimal and fast web framework
+- 🛣️ Intuitive routing system
+- 🧩 Extensible middleware support
+- 🧪 Simple, readable codebase for learning and hacking
+- 📝 Type hints and modern Python best practices
+
+---
+
+## Installation
+
+Install directly from the git source:
+
+```bash
+pip install git+https://github.com/dhavalsavalia/plinx.git
+```
+
+---
+
+## Quickstart
+
+Create a simple web application in seconds:
+
+```python
+from plinx import Plinx
+
+app = Plinx()
+
+@app.route("/")
+def index(request, response):
+    response.text = "Hello, world!"
+```
+
+Run your app (example, assuming you have an ASGI server like `uvicorn`):
+
+```bash
+uvicorn myapp:app
+```
+
+## Testing
+
+Use [pytest](https://docs.pytest.org/en/latest/) to unit test this framework.
+
+```bash
+pytest --cov=.
+```
+
+---
+
+## Roadmap
+
+- [x] Web Framework
+  - [x] Routing
+  - [x] Explicit Routing Methods (GET, POST, etc.)
+  - [x] Parameterized Routes
+  - [x] Class Based Routes
+  - [x] Django-like Routes
+  - [x] Middleware Support
+- [ ] ORM
+
+---
+
+## Contributing
+
+Contributions are welcome! Please open issues or submit pull requests for improvements, bug fixes, or new features.
+
+---
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](LICENSE) for details.
+
+---
+
+## Author & Contact
+
+Created and maintained by [Dhaval Savalia](https://github.com/dhavalsavalia).  
+For questions or opportunities, feel free to reach out via [LinkedIn](https://www.linkedin.com/in/dhavalsavalia/) or open an issue.
+
+---

Plinx-0.0.1/plinx/__init__.py

@@ -0,0 +1 @@
+from .applications import Plinx

Plinx-0.0.1/plinx/applications.py

@@ -0,0 +1,192 @@
+import inspect
+from typing import Callable, Dict, Iterable, Tuple
+from wsgiref.types import StartResponse, WSGIEnvironment
+
+from parse import parse
+from requests import Session as RequestsSession
+from webob import Request
+from wsgiadapter import WSGIAdapter as RequestsWSGIAdapter
+
+from .methods import HTTPMethods
+from .middleware import Middleware
+from .response import PlinxResponse as Response
+from .status_codes import StatusCodes
+from .utils import handle_404
+
+
+class Plinx:
+    def __init__(self):
+        self.routes: Dict[str, Tuple[HTTPMethods, Callable]] = {}
+        self.exception_handler = None
+        self.middleware = Middleware(self)
+
+        self._method_decorators = {}
+        for method in HTTPMethods:
+            self._method_decorators[method.name.lower()] = (
+                self._create_method_decorator(method)
+            )
+
+    def __call__(
+        self,
+        environ: WSGIEnvironment,
+        start_response: StartResponse,
+    ) -> Iterable[bytes]:
+        """
+        Entrypoint for the WSGI application.
+        :param environ: The WSGI environment.
+        :param start_response: The WSGI callable.
+        :return: The response body produced by the middleware.
+        """
+        return self.middleware(environ, start_response)
+
+    def add_route(
+        self,
+        path: str,
+        handler: Callable,
+        method: HTTPMethods = HTTPMethods.GET,
+    ):
+        """
+        Add a route to the application. Django-like syntax.
+        :param path: The path to register.
+        :param handler: The handler to register.
+        :return:
+        """
+        if path in self.routes:
+            raise RuntimeError(f"Route '{path}' is already registered.")
+
+        self.routes[path] = (method, handler)
+
+    def route(
+        self,
+        path: str,
+    ):
+        """
+        Register a route with the given path.
+        :param path: The path to register.
+        :return:
+        """
+
+        def wrapper(handler):
+            self.add_route(path, handler)
+            return handler
+
+        return wrapper
+
+    def __getattr__(
+        self,
+        name: str,
+    ):
+        """Allow access to HTTP method decorators like app.get, app.post etc."""
+        if name in self._method_decorators:
+            return self._method_decorators[name]
+        raise RuntimeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'"
+        )
+
+    def _create_method_decorator(self, method: HTTPMethods):
+        """
+        Creates a decorator for registering routes with a specific HTTP method.
+        :param method: The HTTP method enum value
+        :return: Decorator function
+        """
+
+        def decorator(path: str):
+            def wrapper(handler):
+                self.add_route(path, handler, method)
+                return handler
+
+            return wrapper
+
+        return decorator
+
+    def handle_request(
+        self,
+        request: Request,
+    ) -> Response:
+        """
+        Handle the given request and return the response.
+        :param request: The request object.
+        :return: The response object.
+        """
+        response: Response = Response()
+
+        handler_definition, kwargs = self.find_handler(request, response)
+
+        try:
+            if handler_definition is not None:
+                method, handler = handler_definition
+
+                # Handle CBVs
+                if inspect.isclass(handler):
+                    handler = getattr(
+                        handler(),
+                        request.method.lower(),
+                        None,
+                    )
+                    # only allow methods that are defined in the class
+                    if handler is None:
+                        response.status_code = StatusCodes.METHOD_NOT_ALLOWED.value
+                        response.text = "Method Not Allowed"
+                        return response
+
+                if inspect.isfunction(handler):
+                    # Handle function-based views
+                    if request.method != method.value:
+                        response.status_code = StatusCodes.METHOD_NOT_ALLOWED.value
+                        response.text = "Method Not Allowed"
+                        return response
+
+                handler(request, response, **kwargs)
+
+        except Exception as e:
+            if self.exception_handler:
+                self.exception_handler(request, response, e)
+            else:
+                response.status_code = StatusCodes.INTERNAL_SERVER_ERROR.value
+                response.text = str(e)
+
+        return response
+
+    def find_handler(
+        self,
+        request: Request,
+        response: Response,
+    ) -> Tuple[Callable, dict | None] | Tuple[None, None]:
+        """
+        Find the handler for the given request.
+        If no handler is found, set the response status code to 404
+        and return None.
+
+        :param request: The request object.
+        :param response: The response object.
+        :return: A tuple containing the handler and the named parameters.
+        If no handler is found, return tuple[None, None].
+        """
+        for path, handler in self.routes.items():
+            parse_result = parse(path, request.path)
+            if parse_result is not None:
+                return handler, parse_result.named
+
+        handle_404(response)
+        return None, None
+
+    def add_exception_handler(
+        self,
+        exception_handler,
+    ):
+        self.exception_handler = exception_handler
+
+    def add_middleware(
+        self,
+        middleware_cls: type[Middleware],
+    ):
+        """
+        Add a middleware class to the application.
+        :param middleware_cls: The middleware class to add.
+        """
+        self.middleware.add(middleware_cls)
+
+    def test_session(self, base_url="http://testserver"):
+        session = RequestsSession()
+        session.mount(prefix=base_url, adapter=RequestsWSGIAdapter(self))
+        return session

Plinx-0.0.1/plinx/methods.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class HTTPMethods(Enum):
+    """HTTP methods for the API."""
+
+    # Safe methods
+    GET = "GET"
+    HEAD = "HEAD"
+
+    # Idempotent methods
+    PUT = "PUT"
+    DELETE = "DELETE"
+    OPTIONS = "OPTIONS"
+
+    # Non-idempotent methods
+    POST = "POST"
+    PATCH = "PATCH"

Plinx-0.0.1/plinx/middleware.py

@@ -0,0 +1,81 @@
+from webob import Request, Response
+
+
+class Middleware:
+    """
+    Middleware base class for all middleware classes.
+    This class is used to create middleware for the Plinx application.
+    Middleware classes should inherit from this class and implement the
+    `process_request` and `process_response` methods.
+    """
+
+    def __init__(
+        self,
+        app,
+    ):
+        """
+        Middleware base class for all middleware classes.
+        :param app: The WSGI application.
+        """
+        self.app = app
+
+    def __call__(
+        self,
+        environ: dict,
+        start_response: callable,
+    ):
+        """
+        Entrypoint for the WSGI middleware since it is now entrypoint for the WSGI application.
+        :param environ: The WSGI environment.
+        :param start_response: The WSGI callable.
+        :return: The response body.
+        """
+        request = Request(environ)
+
+        response = self.app.handle_request(request)
+
+        return response(environ, start_response)
+
+    def add(
+        self,
+        middleware_cls,
+    ):
+        """
+        Add a middleware class to the application.
+        :param middleware_cls: The middleware class to add.
+        """
+        self.app = middleware_cls(self.app)
+
+    def process_request(
+        self,
+        request: Request,
+    ):
+        """
+        Process the request before it is passed to the application.
+        :param request: The request object.
+        """
+        pass # pragma: no cover
+
+    def process_response(
+        self,
+        request: Request,
+        response: Response,
+    ):
+        """
+        Process the response after it is passed to the application.
+        :param request: The request object.
+        :param response: The response object.
+        """
+        pass # pragma: no cover
+
+    def handle_request(self, request: Request):
+        """
+        Handle the incoming request.
+        :param request: The request object.
+        :return: The response object.
+        """
+        self.process_request(request)
+        response = self.app.handle_request(request)
+        self.process_response(request, response)
+
+        return response

Plinx-0.0.1/plinx/response.py

@@ -0,0 +1,48 @@
+import json
+from typing import Iterable
+from wsgiref.types import StartResponse, WSGIEnvironment
+
+from webob import Response as WebObResponse
+
+
+class PlinxResponse:
+    def __init__(self):
+        self.json = None
+        self.text = None
+        self.content_type = None
+        self.body = b""
+        self.status_code = 200
+        self.headers = {}
+
+    def __call__(
+        self,
+        environ: WSGIEnvironment,
+        start_response: StartResponse,
+    ) -> Iterable[bytes]:
+        """
+        Entrypoint for the WSGI application.
+        :param environ: The WSGI environment.
+        :param start_response: The WSGI callable.
+        :return: The response body produced by the middleware.
+        """
+
+        self.set_body_and_content_type()
+
+        response = WebObResponse(
+            body=self.body,
+            content_type=self.content_type,
+            status=self.status_code,
+            headers=self.headers,
+        )
+        return response(environ, start_response)
+
+    def set_body_and_content_type(self):
+        if self.json is not None:
+            self.body = json.dumps(self.json).encode("UTF-8")
+            self.content_type = "application/json"
+        elif self.text is not None:
+            self.body = self.text.encode("utf-8") if isinstance(self.text, str) else self.text
+            self.content_type = "text/plain"
+
+        if self.content_type is not None:
+            self.headers["Content-Type"] = self.content_type

Plinx-0.0.1/plinx/status_codes.py

@@ -0,0 +1,36 @@
+from enum import Enum
+
+
+class StatusCodes(Enum):
+    """Status codes for the API."""
+
+    # 2XX
+    OK = 200
+    CREATED = 201
+    ACCEPTED = 202
+    NO_CONTENT = 204
+
+    # 3XX
+    NOT_MODIFIED = 304
+
+    # 4XX
+    BAD_REQUEST = 400
+    UNAUTHORIZED = 401
+    FORBIDDEN = 403
+    NOT_FOUND = 404
+    METHOD_NOT_ALLOWED = 405
+    NOT_ACCEPTABLE = 406
+    CONFLICT = 409
+    GONE = 410
+    PRECONDITION_FAILED = 412
+    UNSUPPORTED_MEDIA_TYPE = 415
+    TOO_MANY_REQUESTS = 429
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451
+
+    # 5XX
+    INTERNAL_SERVER_ERROR = 500
+    NOT_IMPLEMENTED = 501
+    BAD_GATEWAY = 502
+    SERVICE_UNAVAILABLE = 503
+    GATEWAY_TIMEOUT = 504
+    HTTP_VERSION_NOT_SUPPORTED = 505

Plinx-0.0.1/plinx/utils.py

@@ -0,0 +1,13 @@
+from webob import Response
+
+from plinx.status_codes import StatusCodes
+
+
+def handle_404(response: Response) -> None:
+    """
+    Set the response status code to 404 and return None.
+    :param response:
+    :return:
+    """
+    response.status_code = StatusCodes.NOT_FOUND.value
+    response.text = StatusCodes.NOT_FOUND.name.replace("_", " ").title()

Plinx-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

Plinx-0.0.1/setup.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import io
+import os
+
+from setuptools import find_packages, setup
+
+# Package meta-data.
+NAME = "Plinx"
+DESCRIPTION = "Plinx is an experimental, minimalistic, and extensible web framework and ORM written in Python."
+URL = "https://github.com/dhavalsavalia/plinx"
+EMAIL = "coder@dhavalsavalia.com"
+AUTHOR = "Dhaval Savalia"
+REQUIRES_PYTHON = ">=3.11.0"
+VERSION = None
+
+REQUIRED = []
+EXTRAS = {}
+
+with open("VERSION", "r") as f:
+    VERSION = f.read().strip()
+
+# Below is from setup.py for humans (https://github.com/navdeep-G/setup.py)
+here = os.path.abspath(os.path.dirname(__file__))
+
+# Import the README and use it as the long-description.
+try:
+    with io.open(os.path.join(here, "README.md"), encoding="utf-8") as f:
+        long_description = "\n" + f.read()
+except FileNotFoundError:
+    long_description = DESCRIPTION
+
+# Load the package's __version__.py module as a dictionary.
+about = {}
+about["__version__"] = VERSION
+
+
+
+# Where the magic happens:
+setup(
+    name=NAME,
+    version=VERSION,
+    description=DESCRIPTION,
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author=AUTHOR,
+    author_email=EMAIL,
+    python_requires=REQUIRES_PYTHON,
+    url=URL,
+    packages=find_packages(exclude=["tests", "*.tests", "*.tests.*", "tests.*"]),
+    install_requires=REQUIRED,
+    extras_require=EXTRAS,
+    include_package_data=True,
+    license="MIT",
+    classifiers=[
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: Implementation :: CPython",
+        "Programming Language :: Python :: Implementation :: PyPy",
+    ],
+    setup_requires=["wheel"],
+)

Plinx-0.0.1/tests/test_application.py

@@ -0,0 +1,293 @@
+import pytest
+
+from plinx import Plinx
+from plinx.methods import HTTPMethods
+from plinx.middleware import Middleware
+
+
+@pytest.fixture
+def app():
+    return Plinx()
+
+
+@pytest.fixture
+def client(app):
+    return app.test_session()
+
+
+class TestFlaskLikeApplication:
+    def test_app_object(self, app):
+        assert app.routes == {}
+        assert app is not None
+
+    def test_route_decorator(self, app):
+        @app.route("/home")
+        def home(request, response):
+            response.text = "Hello, World!"
+
+        method, handler = app.routes["/home"]
+        assert handler == home
+        assert method.value == "GET"
+
+    def test_404_response(self, client):
+        response = client.get("http://testserver/not-found")
+        assert response.status_code == 404
+        assert response.text == "Not Found"
+
+    def test_parameterized_route(self, app, client):
+        @app.route("/hello/{name}")
+        def hello(request, response, name):
+            response.text = f"Hello, {name}!"
+
+        response = client.get("http://testserver/hello/Dhaval")
+        assert response.status_code == 200
+        assert response.text == "Hello, Dhaval!"
+
+    def test_duplicate_route(self, app):
+        @app.route("/duplicate")
+        def handler1(request, response):
+            response.text = "First"
+
+        with pytest.raises(RuntimeError) as excinfo:
+
+            @app.route("/duplicate")
+            def handler2(request, response):
+                response.text = "Second"
+
+        assert isinstance(excinfo.value, RuntimeError)
+        assert "Route '/duplicate' is already registered." == str(excinfo.value)
+
+    def test_method_not_allowed(self, app, client):
+        @app.post("/method_not_allowed")
+        def method_not_allowed(request, response):
+            response.text = "Best POST method"
+
+        response = client.get("http://testserver/method_not_allowed")
+        assert response.status_code == 405
+        assert response.text == "Method Not Allowed"
+
+    def test_post_request(self, app, client):
+        @app.post("/post")
+        def post_handler(request, response):
+            response.text = "POST request received"
+
+        response = client.post("http://testserver/post")
+        assert response.status_code == 200
+        assert response.text == "POST request received"
+
+    def test_get_request(self, app, client):
+        @app.get("/get")
+        def get_handler(request, response):
+            response.text = "GET request received"
+
+        response = client.get("http://testserver/get")
+        assert response.status_code == 200
+        assert response.text == "GET request received"
+
+    def test_put_request(self, app, client):
+        @app.put("/put")
+        def put_handler(request, response):
+            response.text = "PUT request received"
+
+        response = client.put("http://testserver/put")
+        assert response.status_code == 200
+        assert response.text == "PUT request received"
+
+    def test_delete_request(self, app, client):
+        @app.delete("/delete")
+        def delete_handler(request, response):
+            response.text = "DELETE request received"
+
+        response = client.delete("http://testserver/delete")
+        assert response.status_code == 200
+        assert response.text == "DELETE request received"
+
+    def test_options_request(self, app, client):
+        @app.options("/options")
+        def options_handler(request, response):
+            response.text = "OPTIONS request received"
+
+        response = client.options("http://testserver/options")
+        assert response.status_code == 200
+        assert response.text == "OPTIONS request received"
+
+    def test_patch_request(self, app, client):
+        @app.patch("/patch")
+        def patch_handler(request, response):
+            response.text = "PATCH request received"
+
+        response = client.patch("http://testserver/patch")
+        assert response.status_code == 200
+        assert response.text == "PATCH request received"
+
+    def test_head_request(self, app, client):
+        @app.head("/head")
+        def head_handler(request, response):
+            response.headers["X-TEST-HEADER"] = "Test Header"
+
+        response = client.head("http://testserver/head")
+        assert response.status_code == 200
+        assert response.headers["X-TEST-HEADER"] == "Test Header"
+
+    def test_invalid_method(self, app, client):
+        with pytest.raises(RuntimeError) as excinfo:
+
+            @app.trace("/invalid")
+            def invalid_handler(request, response):
+                response.text = "Invalid method"
+
+        assert isinstance(excinfo.value, RuntimeError)
+        assert "'Plinx' object has no attribute 'trace'" == str(excinfo.value)
+
+
+class TestClassBasedView:
+    def test_class_based_route(self, app, client):
+        @app.route("/book")
+        class BooksResource:
+            def get(self, req, resp):
+                resp.text = "Books Page"
+
+            def post(self, req, resp):
+                resp.text = "Endpoint to create a book"
+
+        response = client.get("http://testserver/book")
+        assert response.status_code == 200
+        assert response.text == "Books Page"
+        response = client.post("http://testserver/book")
+        assert response.status_code == 200
+        assert response.text == "Endpoint to create a book"
+
+    def test_method_not_allowed(self, app, client):
+        @app.route("/cbv")
+        class DummyCBV:
+            def get(self, req, resp):
+                resp.text = "GET OK"
+
+        response = client.post("http://testserver/cbv")
+        assert response.status_code == 405
+        assert response.text == "Method Not Allowed"
+
+
+class TestExceptionHandling:
+    def test_custom_exception_handler(self, app, client):
+        def on_exception(request, response, exception):
+            response.text = "AttributeErrorHappened"
+
+        app.add_exception_handler(on_exception)
+
+        @app.route("/exception")
+        def exception_handler(request, response):
+            raise AttributeError("This is a test exception")
+
+        response = client.get("http://testserver/exception")
+        assert response.text == "AttributeErrorHappened"
+
+    def test_no_exception_handler(self, app, client):
+        @app.route("/exception")
+        def exception_handler(request, response):
+            raise AttributeError("This is a test exception")
+
+        response = client.get("http://testserver/exception")
+
+        assert response.status_code == 500
+        assert response.text == "This is a test exception"
+
+
+class TestDjangoLikeApplication:
+    def test_add_route(self, app, client):
+        def home(request, response):
+            response.text = "Hello, World!"
+
+        app.add_route("/home", home)
+
+        response = client.get("http://testserver/home")
+        assert response.status_code == 200
+        assert response.text == "Hello, World!"
+
+    def test_method_not_allowed(self, app, client):
+        def home(request, response):
+            response.text = "Hello, World!"
+
+        app.add_route("/home", home, HTTPMethods.POST)
+
+        response = client.get("http://testserver/home")
+        assert response.status_code == 405
+        assert response.text == "Method Not Allowed"
+
+
+class TestMiddleware:
+    def test_middleware_functionality(self, app, client):
+        process_request_called = False
+        process_response_called = False
+
+        class CallMiddlewareMethods(Middleware):
+            def __init__(self, app):
+                super().__init__(app)
+
+            def process_request(self, request):
+                nonlocal process_request_called
+                process_request_called = True
+
+            def process_response(self, request, response):
+                nonlocal process_response_called
+                process_response_called = True
+
+        app.add_middleware(CallMiddlewareMethods)
+
+        @app.route("/")
+        def home(request, response):
+            response.text = "Hello, World!"
+
+        client.get("http://testserver/")
+
+        assert process_request_called is True
+        assert process_response_called is True
+
+
+class TestCustomResponses:
+    def test_json_response_helper(self, app, client):
+        @app.route("/json")
+        def json_response(request, response):
+            response.json = {"message": "Hello, JSON!"}
+
+        response = client.get("http://testserver/json")
+
+        assert response.status_code == 200
+        assert response.headers["Content-Type"] == "application/json"
+        assert response.json() == {"message": "Hello, JSON!"}
+
+    def test_text_response_helper(self, app, client):
+        @app.route("/text")
+        def text_response(request, response):
+            response.text = "Hello, Text!"
+
+        response = client.get("http://testserver/text")
+
+        assert response.status_code == 200
+        assert response.headers["Content-Type"] == "text/plain"
+        assert response.text == "Hello, Text!"
+    
+    def test_manually_setting_body(self, app, client):
+        @app.route("/manual")
+        def manual_response(request, response):
+            response.body = b"Hello, Manual!"
+            response.content_type = "text/plain"
+
+        response = client.get("http://testserver/manual")
+
+        assert response.status_code == 200
+        assert response.headers["Content-Type"] == "text/plain"
+        assert response.text == "Hello, Manual!"
+    
+    def test_custom_headers(self, app, client):
+        @app.route("/headers")
+        def custom_headers(request, response):
+            response.headers["X-Custom-Header"] = "CustomValue"
+            response.text = "Hello, Headers!"
+
+        response = client.get("http://testserver/headers")
+
+        assert response.status_code == 200
+        assert response.text == "Hello, Headers!"
+        assert response.headers["X-Custom-Header"] == "CustomValue"
+        assert response.headers["Content-Type"] == "text/plain"