Plinx 0.0.1__py3-none-any.whl

Plinx-0.0.1.dist-info/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,12 @@
+plinx/__init__.py,sha256=oMho3a3JJZllxtj4lLwS96pwWRBvctDJRFww5lfqlBs,32
+plinx/applications.py,sha256=Oy2pO1zyfKWyYXeJ8AuzdoAab6XJThNHDbOdpKWA5-8,5957
+plinx/methods.py,sha256=CEaousqNXbgdyaEL0BdOtAWh1p03jAaAFzXJkY9xII0,294
+plinx/middleware.py,sha256=OiNDhKWpmpKkAIbSWxRzP_tQXSyfDToos-MQMDPSUWM,2161
+plinx/response.py,sha256=oDZPF9V76HhqdUZLzSmoLw_q-GG9hc5krfCBgNm3OfU,1460
+plinx/status_codes.py,sha256=V7vX7_ujYIaVjO3I3eVUnuNKiTXMSov56wJt8tvMbAM,700
+plinx/utils.py,sha256=WaU_j7YXsdlZh3M33B2vXjRPAU26lBeQ5sV2ZasXVwE,352
+Plinx-0.0.1.dist-info/LICENSE,sha256=MljMjTJD6oOY41eZWLDZ4x8FrTUcl7ElKxWIXJXUwLM,1066
+Plinx-0.0.1.dist-info/METADATA,sha256=N-vDBHtG4pV2LKumS4yh40_IYzKKh8PgRf1G3Umw_Q0,2568
+Plinx-0.0.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+Plinx-0.0.1.dist-info/top_level.txt,sha256=U_4P3aFsTEhhvfiE3sVbJKAG9Fp4IPC5d6zpttayAZw,6
+Plinx-0.0.1.dist-info/RECORD,,

Plinx-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

Plinx-0.0.1.dist-info/top_level.txt

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

plinx/__init__.py

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

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/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/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/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/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/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()