SlimeWeb 0.1.0__tar.gz

slimeweb-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+.env/
+web/.*
+web/target/*
+slime.egg-info/
+*.pyc

slimeweb-0.1.0/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: SlimeWeb
+Version: 0.1.0
+Summary: A Simple fast lightweight webframework lib for python
+Author-email: "S.ABILASH" <abinix01@gmail.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Slime – A Rust + Python Hybrid Web Framework
+
+Slime is a high-performance web framework that combines Rust and python
+
+It is designed for developers who want Python developer experience with a Rust-powered server core.
+
+
+## Installation
+
+- pip install slimeweb
+- slime new <Project Name>
+- cd <Project Name>
+- slime run <Project Name>
+
+
+
+---
+
+## Features
+
+- Python handler functions
+- Multiple worker pool model
+- Synchronous handler
+- Multipart form support
+- File uploads
+- Streaming Response
+- Cookie signing
+- Custom headers
+- JSON / HTML / raw responses
+- Templates rendering with context
+- Hot reload of templates in dev mode
+- WebSocket
+
+---
+
+
+
+## Basic Application
+
+```python
+@app.route(path="/", method="GET")
+def index(req, resp):
+    return resp.plain("Hello from Slime")
+```
+
+
+## Request Body
+
+```python
+@app.route(path="/test", method="POST")
+def hello(req, resp):
+    print("query", req.query)
+    print("params", req.params)
+    print("body", req.body)
+    print("json", req.json)
+    print("form", req.form)
+    print("text", req.text)
+    print("bytes", req.bytes)
+    print("file",req.file)
+    return resp.json({"status": "ok"})
+```
+
+
+
+### File Upload
+```python
+@app.route(path="/test", method="POST")
+def hello(req, resp):
+    file = req.file[0] # use can upload multiple files
+    print(file.filename)
+    print(file.content_type)
+    print(file.file_path)
+    print(file.file_size)
+    print(file.extension)
+    file.save(f"testing_file.{file.extension}")
+    return resp.json({"status": "ok"})
+
+```
+
+
+### Template Render
+
+```python
+@app.route(path="/", method="GET")
+def land(req, resp):
+    html = req.render("hello.html", **{"name": "abilash", "slimeVersion": "0.0.1"})
+    return resp.html(html)
+
+```
+
+### Middleware
+
+```python
+#NOTE: middleware  should be declared after declaring route handler 
+# LifeCycle handler => 
+# middle before request -> router handler -> middle after request
+
+@app.middle_after(path="/", method="GET")
+def land_after(req, resp):
+    resp.set_header("BEFORE", "Request")
+
+
+@app.middle_before(path="/", method="GET")
+def land_before(req, resp):
+    resp.set_header("AFTER", "REQUEST")
+
+```
+
+### Streaming
+
+```python
+@app.route(path="/stream", method="GET", stream="text/plain")
+def stream_me(req, resp):
+    resp.start_stream()
+    for i in range(5):
+        resp.send(i)
+    resp.close()
+    
+    # OR u can use @app.stream
+
+@app.stream(path="/stream", method="GET", content="text/plain")
+def stream_me(req, resp):
+    resp.start_stream()
+    for i in range(5):
+        resp.send(i)
+    resp.close()    
+```
+
+
+
+### WebSocket
+```python
+@app.websocket(path="/chat", method="GET")
+def chatty(req, resp):
+
+    def read_me(msg):
+        if not resp.is_closed():
+            resp.send(msg)
+
+    resp.on_message(read_me)
+
+    def close_me():
+        pass
+
+    resp.on_close(close_me)
+```

slimeweb-0.1.0/README.md

@@ -0,0 +1,146 @@
+# Slime – A Rust + Python Hybrid Web Framework
+
+Slime is a high-performance web framework that combines Rust and python
+
+It is designed for developers who want Python developer experience with a Rust-powered server core.
+
+
+## Installation
+
+- pip install slimeweb
+- slime new <Project Name>
+- cd <Project Name>
+- slime run <Project Name>
+
+
+
+---
+
+## Features
+
+- Python handler functions
+- Multiple worker pool model
+- Synchronous handler
+- Multipart form support
+- File uploads
+- Streaming Response
+- Cookie signing
+- Custom headers
+- JSON / HTML / raw responses
+- Templates rendering with context
+- Hot reload of templates in dev mode
+- WebSocket
+
+---
+
+
+
+## Basic Application
+
+```python
+@app.route(path="/", method="GET")
+def index(req, resp):
+    return resp.plain("Hello from Slime")
+```
+
+
+## Request Body
+
+```python
+@app.route(path="/test", method="POST")
+def hello(req, resp):
+    print("query", req.query)
+    print("params", req.params)
+    print("body", req.body)
+    print("json", req.json)
+    print("form", req.form)
+    print("text", req.text)
+    print("bytes", req.bytes)
+    print("file",req.file)
+    return resp.json({"status": "ok"})
+```
+
+
+
+### File Upload
+```python
+@app.route(path="/test", method="POST")
+def hello(req, resp):
+    file = req.file[0] # use can upload multiple files
+    print(file.filename)
+    print(file.content_type)
+    print(file.file_path)
+    print(file.file_size)
+    print(file.extension)
+    file.save(f"testing_file.{file.extension}")
+    return resp.json({"status": "ok"})
+
+```
+
+
+### Template Render
+
+```python
+@app.route(path="/", method="GET")
+def land(req, resp):
+    html = req.render("hello.html", **{"name": "abilash", "slimeVersion": "0.0.1"})
+    return resp.html(html)
+
+```
+
+### Middleware
+
+```python
+#NOTE: middleware  should be declared after declaring route handler 
+# LifeCycle handler => 
+# middle before request -> router handler -> middle after request
+
+@app.middle_after(path="/", method="GET")
+def land_after(req, resp):
+    resp.set_header("BEFORE", "Request")
+
+
+@app.middle_before(path="/", method="GET")
+def land_before(req, resp):
+    resp.set_header("AFTER", "REQUEST")
+
+```
+
+### Streaming
+
+```python
+@app.route(path="/stream", method="GET", stream="text/plain")
+def stream_me(req, resp):
+    resp.start_stream()
+    for i in range(5):
+        resp.send(i)
+    resp.close()
+    
+    # OR u can use @app.stream
+
+@app.stream(path="/stream", method="GET", content="text/plain")
+def stream_me(req, resp):
+    resp.start_stream()
+    for i in range(5):
+        resp.send(i)
+    resp.close()    
+```
+
+
+
+### WebSocket
+```python
+@app.websocket(path="/chat", method="GET")
+def chatty(req, resp):
+
+    def read_me(msg):
+        if not resp.is_closed():
+            resp.send(msg)
+
+    resp.on_message(read_me)
+
+    def close_me():
+        pass
+
+    resp.on_close(close_me)
+```

slimeweb-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "SlimeWeb"
+version = "0.1.0"
+description = "A Simple fast lightweight webframework lib for python"
+authors = [{ name= "S.ABILASH", email="abinix01@gmail.com" }]
+readme = "README.md"
+requires-python = ">=3.12"
+
+[project.scripts]
+slime = "slimeweb.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[tool.hatch.build]
+packages = ["slimeweb"]
+artifacts = [
+  "slimeweb/**/*.so",
+  "slimeweb/**/*.pyd"
+]

slimeweb-0.1.0/slimeweb/__init__.py

@@ -0,0 +1 @@
+from .slime import Slime

slimeweb-0.1.0/slimeweb/cli.py

@@ -0,0 +1,124 @@
+# AUTHOR: S.ABILASH
+# Email: abinix01@gmail.com
+
+import os
+import shutil
+import subprocess as sp
+import sys
+from pathlib import Path
+
+
+def create_project(name: str):
+    if shutil.which("uv") is None:
+        print("\n[*] uv is not found installing...")
+        command = [sys.executable, "-m", "pip", "install", "uv"]
+        sp.run(command, check=True)
+
+    print(f"\n[*] Creating project {name}")
+    root = Path.cwd() / name
+
+    static_path = root / "static"
+    template_path = root / "templates"
+
+    static_path.mkdir(parents=True, exist_ok=True)
+    template_path.mkdir(parents=True, exist_ok=True)
+
+    script_path = root / "main.py"
+
+    code = """
+from slimeweb import Slime
+
+app = Slime(__file__)
+
+@app.route(path="/", method="GET")
+def home(req, resp):
+    return resp.plain("Hello World from slime")
+
+if __name__ == "__main__":
+    app.serve(dev=True)
+"""
+
+    script_path.write_text(code)
+
+    print("[*] Creating an env")
+    if not (root / ".venv").exists():
+        os.chdir(root)
+        sp.run(
+            ["uv", "venv", "--python", "python3.14t"],
+            check=True,
+            stdout=sp.DEVNULL,
+            stderr=sp.DEVNULL,
+        )
+        sp.run(
+            ["uv", "python", "pin", "python3.14t"],
+            check=True,
+            stdout=sp.DEVNULL,
+            stderr=sp.DEVNULL,
+        )
+        sp.run(["uv", "init"])
+        sp.run(["uv", "add", "slimeweb"], check=True)
+    print(f"\n\n[*] Project '{name}' created 🎉🎉🎉")
+    print(f"[*] cd {name} ")
+
+    print("[*] slime run main")
+
+
+def run_project(script: Path):
+
+    script_path = Path.cwd()
+    if script.suffix == ".py":
+        script_path = script_path.joinpath(Path(script))
+    else:
+        script_path = script_path.joinpath(Path(script).with_suffix(".py"))
+
+    if not script_path.exists():
+        print(f"❌ Script '{script_path}' not found")
+        sys.exit(1)
+
+    sp.run(["uv", "run", "python", "-Xgil=0", script_path])
+
+
+def display_logo():
+    print("   _____ _ _             __          __  _     ")
+    print("  / ____| (_)            \\ \\        / / | |    ")
+    print(" | (___ | |_ _ __ ___   __\\ \\  /\\  / /__| |__  ")
+    print("   ___ \\| | | '_ ` _ \\ / _ \\ \\/  \\/ / _ \\ '_ \\ ")
+    print("  ____) | | | | | | | |  __/\\  /\\  /  __/ |_) |")
+    print(" |_____/|_|_|_| |_| |_|\\___| \\/  \\/ \\___|_.__/ ")
+    print("Version: 0.1.0\t\t\t Author: S.Abilash")
+
+
+def main():
+    display_logo()
+    args = sys.argv[1:]
+
+    if not args:
+        print("Usage:")
+        print("  slime new <project_name>")
+        print("  slime run <script>")
+        sys.exit(1)
+
+    command = args[0]
+
+    if command == "new":
+        if len(args) != 2:
+            print("Usage: slime new <project_name>")
+            sys.exit(1)
+
+        create_project(args[1])
+
+    elif command == "run":
+        if len(args) != 2:
+            print("Usage: slime run <script>")
+            sys.exit(1)
+
+        parent_path = Path(args[0]).parent
+        project_path = parent_path.joinpath(Path(args[1]))
+        run_project(project_path)
+
+    else:
+        print(f"Unknown command: {command}")
+
+
+if __name__ == "__main__":
+    main()

slimeweb-0.1.0/slimeweb/slime.py

@@ -0,0 +1,197 @@
+# AUTHOR: S.ABILASH
+# Email: abinix01@gmail.com
+
+import inspect
+from typing import Callable, Dict
+
+
+class Routes:
+    def __init__(
+        self,
+        path: str = "/",
+        method: str = "GET",
+        stream: str | None = None,
+        ws: bool = False,
+    ) -> None:
+        if method.upper() not in ["GET", "POST", "PATCH", "PUT", "DELETE", "OPTIONS"]:
+            raise ValueError(f"{method} is not Valid")
+
+        self.path: str = path
+        self.method: str = method
+        self.stream: str | None = stream
+        self.ws: bool = ws
+
+    def __hash__(self) -> int:
+        return hash((self.path, self.method, self.stream))
+
+    def __eq__(self, value: object) -> bool:
+        return (
+            isinstance(value, Routes)
+            and self.path == value.path
+            and self.method == value.method
+            and self.stream == value.stream
+            and self.ws == value.ws
+        )
+
+    def __str__(self) -> str:
+        return f"""
+            Path: {self.path}
+            Method: {self.method}
+            {f"Stream: {self.stream}" if self.stream is not None else ""}
+            {f"Websocket: {self.ws}" if self.ws is not None else ""}
+        """
+
+
+class Slime:
+    def __init__(self, filename: str) -> None:
+        if filename is None or not isinstance(filename, str):
+            raise ValueError("Need argument as __file__ ")
+
+        # for templating purpose we can fetch file path with /templates and /static
+        self.__filename: str | None = filename
+
+        # => you can multiple or same path with different request
+        # like let saay user can assign  a path /name
+        # with methods like GET,POST under /name
+        # => for each handler there can be only one method
+        self.__routes: Dict[Routes, Dict[str, Callable | None]] = {}
+
+    def middle_before(self, path: str = "/", method: str = "GET") -> Callable:
+        def wrapper(middle_handler) -> Callable:
+            if middle_handler is None or not callable(middle_handler):
+                raise ValueError(
+                    f"Middleware handler should be a function for [Path: {path}, Method: {method}]"
+                )
+            if inspect.iscoroutinefunction(middle_handler):
+                raise Exception("Slime currently doesnt support async handler.")
+            found: bool = False
+            if path == "*":
+                for route in self.__routes:
+                    call_handler = self.__routes.get(route)
+                    if call_handler is not None:
+                        call_handler["before"] = middle_handler
+            else:
+                for route in self.__routes:
+                    if route.path == path and route.method == method:
+                        call_handler = self.__routes.get(route)
+                        if call_handler is not None:
+                            call_handler["before"] = middle_handler
+                            found = True
+                            break
+                if not found:
+                    raise ValueError(
+                        "You need to define the request handler to declare middleware"
+                    )
+            return middle_handler
+
+        return wrapper
+
+    def middle_after(self, path: str = "/", method: str = "GET") -> Callable:
+        def wrapper(middle_handler) -> Callable:
+            if middle_handler is None or not callable(middle_handler):
+                raise ValueError(
+                    f"Middleware handler should be a function for [Path: {path}, Method: {method}]"
+                )
+            if inspect.iscoroutinefunction(middle_handler):
+                raise Exception("Slime currently doesnt support async handler.")
+            found: bool = False
+            if path == "*":
+                for route in self.__routes:
+                    call_handler = self.__routes.get(route)
+                    if call_handler is not None:
+                        call_handler["before"] = middle_handler
+            else:
+                for route in self.__routes:
+                    if route.path == path and route.method == method:
+                        call_handler = self.__routes.get(route)
+                        if call_handler is not None:
+                            call_handler["after"] = middle_handler
+                            found = True
+                            break
+                if not found:
+                    raise ValueError(
+                        "You need to define the request handler to declare middleware"
+                    )
+            return middle_handler
+
+        return wrapper
+
+    def route(
+        self,
+        path: str = "/",
+        method: str = "GET",
+        stream: str | None = None,
+        ws: bool = False,
+    ) -> Callable:
+        def wrapper(route_handler) -> Callable:
+            if route_handler is None or not callable(route_handler):
+                raise ValueError(
+                    f"Route handler should be a function for [Path: {path}, Method: {method}]"
+                )
+            if inspect.iscoroutinefunction(route_handler):
+                raise Exception("Slime currently doesnt support async handler.")
+            self.__routes[Routes(path, method, stream, ws)] = {
+                "handler": route_handler,
+                "before": None,
+                "after": None,
+            }
+            return route_handler
+
+        return wrapper
+
+    def stream(
+        self, path: str = "/", method: str = "GET", content: str = "text/plain"
+    ) -> Callable:
+        def wrapper(stream_handler) -> Callable:
+            if stream_handler is None or not callable(stream_handler):
+                raise ValueError(
+                    f"Stream handler should be a function for [Path: {path}, Method: {method}]"
+                )
+            if not isinstance(content, str):
+                raise ValueError(
+                    f"Stream content type should be of type <String> with MIME for [Path: {path}, Method: {method}]"
+                )
+            self.__routes[Routes(path, method, stream=content)] = {
+                "handler": stream_handler,
+                "before": None,
+                "after": None,
+            }
+            return stream_handler
+
+        return wrapper
+
+    def websocket(self, path: str = "/", method: str = "GET") -> Callable:
+        def wrapper(websocket_handler) -> Callable:
+            if websocket_handler is None or not callable(websocket_handler):
+                raise ValueError(
+                    f"Websocket handler should be a function for [Path: {path}, Method: {method}]"
+                )
+            self.__routes[Routes(path, method, stream=None, ws=True)] = {
+                "handler": websocket_handler,
+                "before": None,
+                "after": None,
+            }
+            return websocket_handler
+
+        return wrapper
+
+    def _get_routes(self) -> Dict[Routes, Dict[str, Callable | None]]:
+        return self.__routes
+
+    def serve(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 3000,
+        secret_key: str | None = None,
+        dev: bool = False,
+    ) -> None:
+        if secret_key is None:
+            import secrets
+
+            secret_key = secrets.token_urlsafe(30)
+
+        import web
+
+        web.init_web(self, host, port, secret_key, dev)
+        print("Slime server is shutting down...")
+        print("Finished")

slimeweb-0.1.0/slimeweb/web/__init__.py

@@ -0,0 +1,5 @@
+from .web import *
+
+__doc__ = web.__doc__
+if hasattr(web, "__all__"):
+    __all__ = web.__all__