serpy-rest 0.1.0__py3-none-any.whl

serpy/__init__.py

@@ -0,0 +1,190 @@
+import json
+from urllib.parse import parse_qs
+
+class Request:
+    def __init__(self, scope, receive):
+        self.scope = scope
+        self._query_params = None
+        self.receive = receive
+        self._headers = None
+
+    async def json(self):
+        body = b''
+        more_body = True
+        while more_body:
+            message = await self.receive()
+            body += message.get('body', b'')
+            more_body = message.get('more_body', False)
+
+        if not body:
+            return None
+        return json.loads(body)
+
+    @property
+    def path(self):
+        return self.scope['path']
+
+
+    @property
+    def method(self):
+        return self.scope['method']
+
+
+    @property
+    def headers(self):
+        if self._headers is None:
+            self._headers = {
+                key.decode('utf-8'): value.decode('utf-8')
+                for key, value in self.scope['headers']
+            }
+        return self._headers
+
+
+    @property
+    def query(self):
+        if self._query_params is None:
+            query_string = self.scope['query_string'].decode("utf-8")
+            self._query_params = QueryParams(query_string)
+        return self._query_params
+
+
+
+class QueryParams:
+    def __init__(self, query_string):
+        self._params = parse_qs(query_string)
+
+    def get(self, key, default=None):
+        values = self._params.get(key, [])
+        return values[0] if values else default
+
+    def getall(self, key, default=None):
+        return self._params.get(key, default or [])
+
+
+
+class Response:
+    def __init__(self, content, status_code=200):
+        self.content = content
+        self.status_code = status_code
+        self.headers = {}
+
+    async def send_to_asgi(self, send):
+        body = json.dumps(self.content).encode("utf-8")
+        
+        headers_list = [[b"content-type", b"application/json"]]
+        for key, value in self.headers.items():
+            headers_list.append([key.encode("utf-8"), value.encode("utf-8")])
+
+        await send({
+            "type": "http.response.start",
+            "status": self.status_code,
+            "headers": headers_list,
+        })
+        await send({"type": "http.response.body", "body": body})
+
+
+
+class Router:
+    def __init__(self):
+        self.routes = {}
+
+    def route(self, path, methods=None):
+        if methods is None: methods = ["GET"]
+        def wrapper(handler):
+            for method in methods:
+                self.routes[(method.upper(), path)] = handler
+            return handler
+        return wrapper
+
+
+
+class MiddlewareWrapper:
+    def __init__(self, app, middleware_func):
+        self.app = app
+        self.middleware_func = middleware_func
+
+    async def __call__(self, scope, receive):
+        async def call_next(request):
+            response = await self.app(scope, receive)
+            return response
+
+        request = Request(scope, receive)
+        response = await self.middleware_func(request, call_next)
+        return response
+
+
+
+class SerPy:
+    def __init__(self):
+        self.routes = {}
+        self.app = self._dispatch_request
+
+    def add_middleware(self, middleware_func):
+        self.app = MiddlewareWrapper(self.app, middleware_func)
+
+    def include_router(self, router: Router, prefix=""):
+        for (method, path), handler in router.routes.items():
+            self.routes[(method, prefix + path)] = handler
+
+    def route(self, path, methods=None, middleware=None):
+        if methods is None: methods = ["GET"]
+        if middleware is None: middleware = []
+        
+        def wrapper(handler):
+            for method in methods:
+                self.routes[(method.upper(), path)] = (handler, middleware)
+            return handler
+        return wrapper
+
+    def find_route(self, method, path):
+        for (route_method, route_path), (handler, middleware) in self.routes.items():
+
+            if route_method != method: continue
+            
+            route_parts = route_path.split("/")
+            path_parts = path.split("/")
+            
+            if len(route_parts) != len(path_parts): continue
+            
+            params = {}
+            match = True
+            
+            for route_part, path_part in zip(route_parts, path_parts):
+                if route_part.startswith('{') and route_part.endswith('}'):
+                    param_name = route_part[1:-1]
+                    params[param_name] = path_part
+                elif route_part != path_part:
+                    match = False
+                    break
+            if match:
+                return handler, params, middleware
+        return None, None, []
+
+    async def _dispatch_request(self, scope, receive):
+        
+        request = Request(scope, receive)
+        handler, params, route_middleware = self.find_route(request.method, request.path)
+
+        if not handler:
+            return Response(content={"error": "Route Not Found"}, status_code=404)
+
+        async def handler_call(req):
+            return await handler(req, **params)
+
+        chain = handler_call
+        for mw in reversed(route_middleware):
+            chain = self._wrap_middleware_for_dispatch(mw, chain)
+
+        response = await chain(request)
+        return response
+    
+    def _wrap_middleware_for_dispatch(self, middleware_func, next_in_chain):
+        async def new_chain_link(request):
+            return await middleware_func(request, next_in_chain)
+        return new_chain_link
+    
+    
+    async def __call__(self, scope, receive, send):
+        if scope["type"] != "http": return
+        response = await self.app(scope, receive)
+        await response.send_to_asgi(send)

serpy_rest-0.1.0.dist-info/METADATA

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: serpy-rest
+Version: 0.1.0
+Summary: A minimal ASGI web framework for Python.
+Home-page: https://github.com/ragav2005/SerPy
+Author: Ragav Vignes
+Author-email: ragavvignesviswanathan@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# SerPy
+
+SerPy is a minimal, modern, and lightning-fast ASGI web framework for Python. It is designed for simplicity, flexibility, and performance, making it ideal for building APIs, microservices, and web applications with minimal overhead.
+
+---
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Example Project](#example-project)
+- [Middleware](#middleware)
+- [Advanced Routing](#advanced-routing)
+- [Contributing](#contributing)
+- [Running Locally](#running-locally)
+- [License](#license)
+- [Contact](#contact)
+
+---
+
+## Features
+
+- **ASGI compatible**: Works seamlessly with ASGI servers like Uvicorn and Hypercorn
+- **Simple routing**: Path parameters, method-based routing, and easy route registration
+- **Middleware support**: Add custom middleware for logging, authentication, CORS, etc.
+- **Request/Response abstraction**: Clean API for handling requests and responses
+- **Modular**: Use routers to organize your application
+- **Type hints**: Modern Pythonic code with type hints
+
+---
+
+## Installation
+
+Install the latest release from PyPI:
+
+```bash
+pip install serpy-asgi
+```
+
+Or, to use the latest development version, clone this repository:
+
+```bash
+git clone https://github.com/ragav2005/SerPy.git
+cd SerPy
+pip install .
+```
+
+---
+
+## Quick Start
+
+Create a file called `main.py`:
+
+```python
+from serpy import SerPy, Response
+
+app = SerPy()
+
+@app.route("/hello/{name}", methods=["GET"])
+async def hello(request, name):
+	return Response({"message": f"Hello, {name}!"})
+
+# Run with: uvicorn main:app
+```
+
+Start the server:
+
+```bash
+uvicorn main:app --reload
+```
+
+---
+
+## Example Project Structure
+
+```
+myproject/
+├── main.py
+├── requirements.txt
+└── ...
+```
+
+---
+
+## Middleware
+
+Add global middleware to your app:
+
+```python
+async def log_middleware(request, call_next):
+	print(f"Request: {request.method} {request.path}")
+	response = await call_next(request)
+	return response
+
+app.add_middleware(log_middleware)
+```
+
+---
+
+## Advanced Routing
+
+Use routers to organize endpoints:
+
+```python
+from serpy import Router
+
+user_router = Router()
+
+@user_router.route("/users/{user_id}", methods=["GET"])
+async def get_user(request, user_id):
+	# Fetch user logic here
+	return Response({"user_id": user_id})
+
+app.include_router(user_router, prefix="/api")
+```
+
+---
+
+## Contributing
+
+Contributions are welcome! To contribute:
+
+1. Fork the repository
+2. Create a new branch (`git checkout -b feature/your-feature`)
+3. Commit your changes
+4. Push to your fork and submit a pull request
+
+Please ensure your code follows PEP8 and includes tests where appropriate.
+
+---
+
+## Running Locally (Development)
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/ragav2005/SerPy.git
+   cd SerPy
+   ```
+2. (Optional) Create a virtual environment:
+   ```bash
+   python3 -m venv .venv
+   source .venv/bin/activate
+   ```
+3. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+4. Run the example app or your own app with Uvicorn:
+   ```bash
+   uvicorn main:app --reload
+   ```
+
+---
+
+## License
+
+This project is licensed under the MIT License.
+
+---
+
+## Contact
+
+Author: [ragav2005](https://github.com/ragav2005)
+For questions, suggestions, or issues, please open an issue on GitHub.

serpy_rest-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+serpy/__init__.py,sha256=Wl08BQXRIsHSGJ85OqC05o2UqRdmItRBtiKbXHj-rUg,5616
+serpy_rest-0.1.0.dist-info/METADATA,sha256=Eb3r-BDvv9Mf3MYB_8QQn1cnzTbRkWs_j0uKlSghDDo,3918
+serpy_rest-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+serpy_rest-0.1.0.dist-info/top_level.txt,sha256=taqeUQycKG1R6VbUW9mD8vWeuHPE6UouxvPjgquT3tk,6
+serpy_rest-0.1.0.dist-info/RECORD,,

serpy_rest-0.1.0.dist-info/WHEEL

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

serpy_rest-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+serpy