sistine 0.1.0__tar.gz

sistine-0.1.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: sistine
+Version: 0.1.0
+Summary: React-like framework for Python - return HTML/CSS/JS like React, route like Next.js
+Author: ararya
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ararya/sistine
+Project-URL: Repository, https://github.com/ararya/sistine
+Keywords: react,html,css,js,web,ui,framework,streamlit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: starlette>=0.40.0
+Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: streamlit>=1.28.0
+
+# Sistine
+
+<img width="1620" height="1620" alt="sistine-fibel" src="https://github.com/user-attachments/assets/84af899f-9fc2-418f-af78-f9408bc33d03" />
+
+> React-like UI framework for Python, powered by **Streamlit**. Build incredibly flexible, custom-designed UIs with HTML/Tailwind, while leveraging Streamlit's native widgets and data caching.
+
+## Why Sistine?
+
+Streamlit is fantastic for data apps, but often developers complain:
+- Hard to customize CSS/Layouts or use Tailwind.
+- Complex nested UIs are difficult to build.
+- UI elements lack flexibility.
+
+**Sistine fixes this!** You can write full custom HTML, inject Tailwind CSS, and separate your concerns using a React-like component approach, all while letting Streamlit handle the backend server, caching, and state management.
+
+## Installation
+
+```bash
+pip install sistine
+```
+
+## Features
+
+- **React-like Syntax (Chaining)**: Write clean components `el.div(cls="...")(children)`.
+- **Tailwind CSS Built-in**: One command `app.use_tailwind()` to enable utility classes.
+- **Native Streamlit Interoperability**: Mix `st.write()` or Streamlit buttons alongside Sistine components!
+- **Auto-caching**: Use `@query` to fetch API/Database, and it automatically hooks into `st.cache_data`.
+- **MVC Modularity**: Fully supports splitting code into Models, Views, and Controllers.
+
+## Quick Start
+
+```python
+from sistine import streamlit as st, Sistine, el
+
+app = Sistine(title="My App")
+app.use_tailwind()
+
+# 1. Modular React-like Component using Chaining Syntax
+def Card(title: str, description: str):
+    return el.div(cls="bg-white p-6 rounded-xl shadow-md")(
+        el.h2(cls="text-2xl font-bold text-gray-800")(title),
+        el.p(cls="text-gray-600 mt-2")(description)
+    )
+
+# 2. Define Routes Easily
+@app.sistine("/")
+def home():
+    # You can still use Streamlit native features!
+    st.toast("Welcome to Sistine!")
+    
+    return str(
+        el.div(cls="min-h-screen bg-gray-50 p-10 flex flex-col items-center justify-center")(
+            el.h1(cls="text-4xl font-extrabold text-blue-600 mb-8")("Hello Sistine!"),
+            Card("Awesome Framework", "Return HTML/Tailwind seamlessly inside Streamlit.")
+        )
+    )
+
+if __name__ == "__main__":
+    app.run(port=8080)
+```
+
+Run your app normally:
+```bash
+python app.py
+```
+
+## The Power of `@query`
+
+Say goodbye to slow apps! Use `@query` for any API calls or expensive database queries. Sistine automatically caches it using `st.cache_data` in the background.
+
+```python
+from sistine import query
+import requests
+
+@query
+def fetch_users():
+    # Only hits the network once, subsequent calls are instantly cached!
+    res = requests.get("https://jsonplaceholder.typicode.com/users")
+    return res.json()
+```
+
+## Streamlit State & Widgets
+
+Sistine runs *inside* Streamlit. You can use `st.session_state` to make your Sistine UI reactive!
+
+```python
+from sistine import streamlit as st, Sistine, el
+
+app = Sistine()
+
+if "count" not in st.session_state:
+    st.session_state.count = 0
+
+@app.sistine("/")
+def counter():
+    # Native Streamlit Widget
+    if st.button("Add +1"):
+        st.session_state.count += 1
+        
+    # Sistine UI that reacts to Streamlit state!
+    return str(
+        el.h1(cls="text-3xl")(f"Count is: {st.session_state.count}")
+    )
+```
+
+## Examples
+
+Check out the [`examples/`](examples) directory for complete applications:
+- `tailwind_app.py` - Basic Tailwind setup.
+- `routing_app.py` - Multi-page routing with URL parameters (`/user/{id}`).
+- `dashboard_app.py` - Complex UI layout (sidebar, grid cards).
+- `pokeapi_app.py` - Working API integration showcasing `@query`.
+- `state_app.py` - Interactivity using Streamlit's `session_state`.
+- `mvc_app/` - Example of organizing a massive Sistine app using MVC pattern.

sistine-0.1.0/README.md

@@ -0,0 +1,114 @@
+# Sistine
+
+<img width="1620" height="1620" alt="sistine-fibel" src="https://github.com/user-attachments/assets/84af899f-9fc2-418f-af78-f9408bc33d03" />
+
+> React-like UI framework for Python, powered by **Streamlit**. Build incredibly flexible, custom-designed UIs with HTML/Tailwind, while leveraging Streamlit's native widgets and data caching.
+
+## Why Sistine?
+
+Streamlit is fantastic for data apps, but often developers complain:
+- Hard to customize CSS/Layouts or use Tailwind.
+- Complex nested UIs are difficult to build.
+- UI elements lack flexibility.
+
+**Sistine fixes this!** You can write full custom HTML, inject Tailwind CSS, and separate your concerns using a React-like component approach, all while letting Streamlit handle the backend server, caching, and state management.
+
+## Installation
+
+```bash
+pip install sistine
+```
+
+## Features
+
+- **React-like Syntax (Chaining)**: Write clean components `el.div(cls="...")(children)`.
+- **Tailwind CSS Built-in**: One command `app.use_tailwind()` to enable utility classes.
+- **Native Streamlit Interoperability**: Mix `st.write()` or Streamlit buttons alongside Sistine components!
+- **Auto-caching**: Use `@query` to fetch API/Database, and it automatically hooks into `st.cache_data`.
+- **MVC Modularity**: Fully supports splitting code into Models, Views, and Controllers.
+
+## Quick Start
+
+```python
+from sistine import streamlit as st, Sistine, el
+
+app = Sistine(title="My App")
+app.use_tailwind()
+
+# 1. Modular React-like Component using Chaining Syntax
+def Card(title: str, description: str):
+    return el.div(cls="bg-white p-6 rounded-xl shadow-md")(
+        el.h2(cls="text-2xl font-bold text-gray-800")(title),
+        el.p(cls="text-gray-600 mt-2")(description)
+    )
+
+# 2. Define Routes Easily
+@app.sistine("/")
+def home():
+    # You can still use Streamlit native features!
+    st.toast("Welcome to Sistine!")
+    
+    return str(
+        el.div(cls="min-h-screen bg-gray-50 p-10 flex flex-col items-center justify-center")(
+            el.h1(cls="text-4xl font-extrabold text-blue-600 mb-8")("Hello Sistine!"),
+            Card("Awesome Framework", "Return HTML/Tailwind seamlessly inside Streamlit.")
+        )
+    )
+
+if __name__ == "__main__":
+    app.run(port=8080)
+```
+
+Run your app normally:
+```bash
+python app.py
+```
+
+## The Power of `@query`
+
+Say goodbye to slow apps! Use `@query` for any API calls or expensive database queries. Sistine automatically caches it using `st.cache_data` in the background.
+
+```python
+from sistine import query
+import requests
+
+@query
+def fetch_users():
+    # Only hits the network once, subsequent calls are instantly cached!
+    res = requests.get("https://jsonplaceholder.typicode.com/users")
+    return res.json()
+```
+
+## Streamlit State & Widgets
+
+Sistine runs *inside* Streamlit. You can use `st.session_state` to make your Sistine UI reactive!
+
+```python
+from sistine import streamlit as st, Sistine, el
+
+app = Sistine()
+
+if "count" not in st.session_state:
+    st.session_state.count = 0
+
+@app.sistine("/")
+def counter():
+    # Native Streamlit Widget
+    if st.button("Add +1"):
+        st.session_state.count += 1
+        
+    # Sistine UI that reacts to Streamlit state!
+    return str(
+        el.h1(cls="text-3xl")(f"Count is: {st.session_state.count}")
+    )
+```
+
+## Examples
+
+Check out the [`examples/`](examples) directory for complete applications:
+- `tailwind_app.py` - Basic Tailwind setup.
+- `routing_app.py` - Multi-page routing with URL parameters (`/user/{id}`).
+- `dashboard_app.py` - Complex UI layout (sidebar, grid cards).
+- `pokeapi_app.py` - Working API integration showcasing `@query`.
+- `state_app.py` - Interactivity using Streamlit's `session_state`.
+- `mvc_app/` - Example of organizing a massive Sistine app using MVC pattern.

sistine-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sistine"
+version = "0.1.0"
+description = "React-like framework for Python - return HTML/CSS/JS like React, route like Next.js"
+authors = [
+    {name = "ararya"},
+]
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.10"
+keywords = ["react", "html", "css", "js", "web", "ui", "framework", "streamlit"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: User Interfaces",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+]
+dependencies = [
+    "starlette>=0.40.0",
+    "uvicorn>=0.30.0",
+    "streamlit>=1.28.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/ararya/sistine"
+Repository = "https://github.com/ararya/sistine"
+
+[project.scripts]
+sistine = "sistine.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

sistine-0.1.0/setup.cfg

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

sistine-0.1.0/src/sistine/__init__.py

@@ -0,0 +1,7 @@
+import streamlit
+
+from .app import Sistine
+from .el import el
+from .query import query
+
+__all__ = ["Sistine", "el", "query", "streamlit"]

sistine-0.1.0/src/sistine/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

sistine-0.1.0/src/sistine/app.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from .server import StreamlitServer
+
+
+_PAGE = """\
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>{title}</title>
+<script src="https://unpkg.com/htmx.org@2.0.4"></script>
+<style>
+* {{ margin: 0; padding: 0; box-sizing: border-box; }}
+body {{ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; }}
+{global_css}
+</style>
+{global_head}
+{framework_meta}
+</head>
+<body hx-boost="true">{content}{framework_script}</body>
+</html>"""
+
+
+class Sistine:
+    def __init__(
+        self,
+        title: str = "Sistine App",
+        framework: Any = None,
+    ) -> None:
+        self._title = title
+        self._fw = framework
+        self._routes: dict[str, Callable[..., Any]] = {}
+        self._global_css: list[str] = []
+        self._global_head: list[str] = []
+        self._server = StreamlitServer(self)
+
+        if framework is not None:
+            fw_name = getattr(framework, "__name__", str(framework))
+            fw_ver = getattr(framework, "__version__", "?")
+            self._global_head.append(
+                f'<meta name="generator" content="Sistine + {fw_name} {fw_ver}">'
+            )
+
+    def css(self, code: str) -> None:
+        self._global_css.append(code)
+
+    def head(self, tag: str) -> None:
+        self._global_head.append(tag)
+
+    def use_tailwind(self) -> None:
+        self.head('<script src="https://cdn.tailwindcss.com"></script>')
+
+    def sistine(self, path: str) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
+            self._routes[path] = fn
+            return fn
+        return decorator
+
+    def _render(self, html: str) -> str:
+        fw_meta = ""
+        fw_script = ""
+
+        if self._fw is not None:
+            fw_name = getattr(self._fw, "__name__", "framework")
+            fw_meta = f'<meta name="framework" content="{fw_name}">'
+            fw_script = (
+                f'<script>window.__SISTINE_FRAMEWORK__="{fw_name}";</script>'
+            )
+
+        return _PAGE.format(
+            title=self._title,
+            content=html,
+            global_css="\n".join(self._global_css),
+            global_head="\n".join(self._global_head),
+            framework_meta=fw_meta,
+            framework_script=fw_script,
+        )
+
+    def run(self, host: str = "127.0.0.1", port: int = 8080) -> None:
+        self._server.run(host, port)

sistine-0.1.0/src/sistine/cli.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import argparse
+import os
+import runpy
+import sys
+from pathlib import Path
+
+
+def cmd_init(args: argparse.Namespace) -> None:
+    project_name = args.name
+    base_dir = Path(project_name)
+    
+    if (base_dir / "main.py").exists() or (base_dir / "controllers").exists():
+        print(f"Error: A Sistine project already seems to exist in '{project_name}'.")
+        sys.exit(1)
+        
+    base_dir.mkdir(parents=True, exist_ok=True)
+    (base_dir / "models").mkdir()
+    (base_dir / "views").mkdir()
+    (base_dir / "controllers").mkdir()
+    
+    # Generate main.py
+    (base_dir / "main.py").write_text(
+        "from sistine import Sistine\n"
+        "from controllers.home import register_routes\n\n"
+        "app = Sistine(title=\"My Sistine App\")\n"
+        "app.use_tailwind()\n\n"
+        "register_routes(app)\n\n"
+        "if __name__ == \"__main__\":\n"
+        "    app.run()\n",
+        encoding="utf-8"
+    )
+    
+    # Generate models
+    (base_dir / "models" / "__init__.py").touch()
+    (base_dir / "models" / "data.py").write_text(
+        "from sistine import query\n\n"
+        "@query\n"
+        "def get_welcome_message():\n"
+        "    return \"Welcome to Sistine Layered Architecture!\"\n",
+        encoding="utf-8"
+    )
+    
+    # Generate views
+    (base_dir / "views" / "__init__.py").touch()
+    (base_dir / "views" / "pages.py").write_text(
+        "from sistine import el\n\n"
+        "def HomePage(message: str):\n"
+        "    return el.div(cls=\"min-h-screen bg-gray-50 flex items-center justify-center p-4\")(\n"
+        "        el.div(cls=\"bg-white p-10 rounded-2xl shadow-xl text-center\")(\n"
+        "            el.h1(cls=\"text-4xl font-extrabold text-blue-600 mb-4\")(\"Hello Sistine\"),\n"
+        "            el.p(cls=\"text-gray-700 text-lg\")(message)\n"
+        "        )\n"
+        "    )\n",
+        encoding="utf-8"
+    )
+    
+    # Generate controllers
+    (base_dir / "controllers" / "__init__.py").touch()
+    (base_dir / "controllers" / "home.py").write_text(
+        "from models.data import get_welcome_message\n"
+        "from views.pages import HomePage\n\n"
+        "def register_routes(app):\n"
+        "    @app.sistine(\"/\")\n"
+        "    def index():\n"
+        "        msg = get_welcome_message()\n"
+        "        return str(HomePage(msg))\n",
+        encoding="utf-8"
+    )
+    
+    print(f"Successfully initialized Sistine project in '{project_name}'")
+    print("Run your app with:")
+    if project_name != ".":
+        print(f"  cd {project_name}")
+    print("  sistine run")
+
+
+def cmd_run(args: argparse.Namespace) -> None:
+    script = args.script
+    if not os.path.exists(script):
+        print(f"Error: {script} not found")
+        sys.exit(1)
+
+    import subprocess
+    sys.exit(subprocess.call([sys.executable, "-m", "streamlit", "run", script]))
+
+
+def cmd_build(args: argparse.Namespace) -> None:
+    script = args.script
+    if not os.path.exists(script):
+        print(f"Error: {script} not found")
+        sys.exit(1)
+
+    out = args.out or "dist"
+
+    sys.argv[1:] = []
+    mod = runpy.run_path(script, run_name="__sistine_build__")
+
+    found = None
+    for name, val in mod.items():
+        if type(val).__name__ == "Sistine":
+            found = val
+            break
+
+    if found is None:
+        print("Error: no Sistine app instance found in", script)
+        sys.exit(1)
+
+    out_dir = Path(out)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    built = 0
+    for route in found._routes:
+        path = route.strip("/") or "index"
+        html = found._serve(route)
+        filepath = out_dir / f"{path}.html"
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        filepath.write_text(html, encoding="utf-8")
+        print(f"  Built  {filepath}")
+        built += 1
+
+    print(f"\nBuilt {built} page(s) → {out_dir}/")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="sistine", description="Sistine CLI")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    init_p = sub.add_parser("init", help="Initialize a new Sistine project with layered architecture")
+    init_p.add_argument("name", nargs="?", default=".", help="Project directory name (default: current directory)")
+
+    run_p = sub.add_parser("run", help="Run a Sistine app")
+    run_p.add_argument("script", nargs="?", default="main.py", help="Path to Python script (default: main.py)")
+
+    build_p = sub.add_parser("build", help="Build static HTML from a Sistine app")
+    build_p.add_argument("script", nargs="?", default="main.py", help="Path to Python script (default: main.py)")
+    build_p.add_argument("--out", default="dist", help="Output directory (default: dist)")
+
+    args = parser.parse_args()
+
+    if args.command == "init":
+        cmd_init(args)
+    elif args.command == "run":
+        cmd_run(args)
+    elif args.command == "build":
+        cmd_build(args)
+
+
+if __name__ == "__main__":
+    main()

sistine-0.1.0/src/sistine/el.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+_SELF_CLOSING = {
+    "area", "base", "br", "col", "embed", "hr", "img", "input",
+    "link", "meta", "param", "source", "track", "wbr",
+}
+
+
+class _HTML:
+    __slots__ = ("_html", "_tag", "_attrs", "_children")
+
+    def __init__(
+        self,
+        html: str,
+        tag: str | None = None,
+        attrs: dict[str, Any] | None = None,
+        children: tuple[Any, ...] | None = None,
+    ) -> None:
+        self._html = html
+        self._tag = tag
+        self._attrs = attrs or {}
+        self._children = children or ()
+
+    def __str__(self) -> str:
+        return self._html
+
+    def __repr__(self) -> str:
+        return self._html
+
+    def __add__(self, other: Any) -> str:
+        return str(self) + str(other)
+
+    def __radd__(self, other: Any) -> str:
+        return str(other) + str(self)
+
+    def __call__(self, *children: Any, **attrs: Any) -> _HTML:
+        if self._tag is None:
+            raise TypeError("Cannot chain call on raw HTML")
+        
+        new_attrs = self._attrs.copy()
+        new_attrs.update(attrs)
+        new_children = self._children + children
+        
+        return _build_tag(self._tag, *new_children, **new_attrs)
+
+
+def _attr_name(key: str) -> str:
+    if key == "cls" or key == "className" or key == "class_name":
+        return "class"
+    if key == "html_for":
+        return "for"
+    result: list[str] = []
+    for char in key:
+        if char.isupper():
+            result.append("-")
+            result.append(char.lower())
+        elif char == "_":
+            result.append("-")
+        else:
+            result.append(char)
+    return "".join(result).lstrip("-")
+
+
+def _style_str(style: dict[str, str]) -> str:
+    return "; ".join(f"{_attr_name(k)}: {v}" for k, v in style.items())
+
+
+def _escape(text: str) -> str:
+    return (
+        text.replace("&", "&")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+    )
+
+
+def _build_tag(tag: str, *children: Any, **attrs: Any) -> _HTML:
+    parts: list[str] = [f"<{tag}"]
+
+    style = attrs.pop("style", None)
+    if style:
+        attrs["style"] = _style_str(style)
+
+    for key, value in attrs.items():
+        attr = _attr_name(key)
+        if value is None:
+            continue
+        if isinstance(value, bool):
+            if value:
+                parts.append(f' {attr}')
+        elif isinstance(value, (int, float)):
+            parts.append(f' {attr}="{value}"')
+        else:
+            parts.append(f' {attr}="{_escape(str(value))}"')
+
+    parts.append(">")
+
+    if tag in _SELF_CLOSING:
+        return _HTML("".join(parts), tag=tag, attrs=attrs, children=children)
+
+    for child in children:
+        if isinstance(child, _HTML):
+            parts.append(child._html)
+        elif isinstance(child, str):
+            parts.append(_escape(child))
+        elif isinstance(child, (int, float)):
+            parts.append(str(child))
+        elif child is None:
+            continue
+        else:
+            parts.append(str(child))
+
+    parts.append(f"</{tag}>")
+    return _HTML("".join(parts), tag=tag, attrs=attrs, children=children)
+
+
+class _ElementBuilder:
+    def __getattr__(self, tag: str) -> Any:
+        def builder(*children: Any, **attrs: Any) -> _HTML:
+            return _build_tag(tag, *children, **attrs)
+
+        return builder
+
+
+el = _ElementBuilder()

sistine-0.1.0/src/sistine/query.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import Any, Callable, TypeVar, overload
+
+try:
+    import streamlit as st
+except ImportError:
+    st = None
+
+F = TypeVar('F', bound=Callable[..., Any])
+
+class Query:
+    def __init__(self, fn: Callable[..., Any]) -> None:
+        if st is not None:
+            # Wrap with Streamlit's cache_data for automatic API/data caching!
+            self.fn = st.cache_data(fn)
+        else:
+            self.fn = fn
+            
+        self.__doc__ = fn.__doc__
+        self.__name__ = fn.__name__
+        self.__qualname__ = fn.__qualname__
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return self.fn(*args, **kwargs)
+
+@overload
+def query(fn: F) -> F: ...
+
+@overload
+def query() -> Callable[[F], F]: ...
+
+def query(fn: Any = None) -> Any:
+    if fn is None:
+        return lambda f: Query(f) # type: ignore
+    return Query(fn)

sistine-0.1.0/src/sistine/server.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import os
+import sys
+from typing import TYPE_CHECKING, Any, Callable
+
+try:
+    import streamlit as st
+    import streamlit.components.v1 as components
+except ImportError:
+    st = None
+    components = None
+
+if TYPE_CHECKING:
+    from .app import Sistine
+
+
+def is_running_in_streamlit() -> bool:
+    if st is None:
+        return False
+    try:
+        from streamlit.runtime.scriptrunner import get_script_run_ctx
+
+        return get_script_run_ctx() is not None
+    except Exception:
+        return False
+
+
+class StreamlitServer:
+    def __init__(self, app: Sistine) -> None:
+        self._app = app
+
+    def _render_page(self, route_path: str, html_str: str) -> None:
+        if st is None:
+            return
+
+        # Hide default Streamlit paddings/styles to make it look like a custom app
+        st.markdown(
+            """
+            <style>
+            .block-container {
+                padding-top: 0rem;
+                padding-bottom: 0rem;
+                padding-left: 0rem;
+                padding-right: 0rem;
+                max-width: 100%;
+            }
+            header {visibility: hidden;}
+            #MainMenu {visibility: hidden;}
+            footer {visibility: hidden;}
+            </style>
+            """,
+            unsafe_allow_html=True,
+        )
+
+        # Render the HTML using components.html for isolation
+        # Height is large to simulate a full page, scrolling handles internal scroll
+        assert components is not None
+        components.html(html_str, height=1200, scrolling=True)
+
+    def run(self, host: str = "127.0.0.1", port: int = 8080) -> None:
+        if not is_running_in_streamlit():
+            # Not in Streamlit, restart using streamlit run
+            script = sys.argv[0]
+            print(
+                f"\n  \033[1mSistine v0.1.0\033[0m — Starting Streamlit backend on http://{host}:{port}...\n"
+            )
+
+            import subprocess
+
+            cmd = [
+                sys.executable,
+                "-m",
+                "streamlit",
+                "run",
+                script,
+                "--server.address",
+                host,
+                "--server.port",
+                str(port),
+            ]
+            sys.exit(subprocess.call(cmd))
+
+        # We ARE in Streamlit.
+        assert st is not None
+        import inspect
+        import re
+
+        query_params = st.query_params
+        route = query_params.get("route", "/")
+
+        matched_fn = None
+        matched_kwargs = {}
+
+        for pattern, fn in self._app._routes.items():
+            # Convert `{id}` to `(?P<id>[^/]+)`
+            regex_pattern = re.sub(r"\{([^/]+)\}", r"(?P<\1>[^/]+)", pattern)
+            regex_pattern = f"^{regex_pattern}$"
+
+            match = re.match(regex_pattern, route)
+            if match:
+                matched_fn = fn
+                matched_kwargs = match.groupdict()
+                break
+
+        if matched_fn:
+            try:
+                sig = inspect.signature(matched_fn)
+                for k, v in matched_kwargs.items():
+                    if k in sig.parameters:
+                        anno = sig.parameters[k].annotation
+                        if anno is int:
+                            matched_kwargs[k] = int(v)
+                        elif anno is float:
+                            matched_kwargs[k] = float(v)
+
+                content = matched_fn(**matched_kwargs)
+            except Exception as e:
+                content = f"<h1>500</h1><p>{e}</p>"
+        else:
+            content = "<h1>404</h1><p>Page not found</p>"
+
+        html = self._app._render(str(content))
+        self._render_page(route, html)

sistine-0.1.0/src/sistine.egg-info/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: sistine
+Version: 0.1.0
+Summary: React-like framework for Python - return HTML/CSS/JS like React, route like Next.js
+Author: ararya
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ararya/sistine
+Project-URL: Repository, https://github.com/ararya/sistine
+Keywords: react,html,css,js,web,ui,framework,streamlit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: starlette>=0.40.0
+Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: streamlit>=1.28.0
+
+# Sistine
+
+<img width="1620" height="1620" alt="sistine-fibel" src="https://github.com/user-attachments/assets/84af899f-9fc2-418f-af78-f9408bc33d03" />
+
+> React-like UI framework for Python, powered by **Streamlit**. Build incredibly flexible, custom-designed UIs with HTML/Tailwind, while leveraging Streamlit's native widgets and data caching.
+
+## Why Sistine?
+
+Streamlit is fantastic for data apps, but often developers complain:
+- Hard to customize CSS/Layouts or use Tailwind.
+- Complex nested UIs are difficult to build.
+- UI elements lack flexibility.
+
+**Sistine fixes this!** You can write full custom HTML, inject Tailwind CSS, and separate your concerns using a React-like component approach, all while letting Streamlit handle the backend server, caching, and state management.
+
+## Installation
+
+```bash
+pip install sistine
+```
+
+## Features
+
+- **React-like Syntax (Chaining)**: Write clean components `el.div(cls="...")(children)`.
+- **Tailwind CSS Built-in**: One command `app.use_tailwind()` to enable utility classes.
+- **Native Streamlit Interoperability**: Mix `st.write()` or Streamlit buttons alongside Sistine components!
+- **Auto-caching**: Use `@query` to fetch API/Database, and it automatically hooks into `st.cache_data`.
+- **MVC Modularity**: Fully supports splitting code into Models, Views, and Controllers.
+
+## Quick Start
+
+```python
+from sistine import streamlit as st, Sistine, el
+
+app = Sistine(title="My App")
+app.use_tailwind()
+
+# 1. Modular React-like Component using Chaining Syntax
+def Card(title: str, description: str):
+    return el.div(cls="bg-white p-6 rounded-xl shadow-md")(
+        el.h2(cls="text-2xl font-bold text-gray-800")(title),
+        el.p(cls="text-gray-600 mt-2")(description)
+    )
+
+# 2. Define Routes Easily
+@app.sistine("/")
+def home():
+    # You can still use Streamlit native features!
+    st.toast("Welcome to Sistine!")
+    
+    return str(
+        el.div(cls="min-h-screen bg-gray-50 p-10 flex flex-col items-center justify-center")(
+            el.h1(cls="text-4xl font-extrabold text-blue-600 mb-8")("Hello Sistine!"),
+            Card("Awesome Framework", "Return HTML/Tailwind seamlessly inside Streamlit.")
+        )
+    )
+
+if __name__ == "__main__":
+    app.run(port=8080)
+```
+
+Run your app normally:
+```bash
+python app.py
+```
+
+## The Power of `@query`
+
+Say goodbye to slow apps! Use `@query` for any API calls or expensive database queries. Sistine automatically caches it using `st.cache_data` in the background.
+
+```python
+from sistine import query
+import requests
+
+@query
+def fetch_users():
+    # Only hits the network once, subsequent calls are instantly cached!
+    res = requests.get("https://jsonplaceholder.typicode.com/users")
+    return res.json()
+```
+
+## Streamlit State & Widgets
+
+Sistine runs *inside* Streamlit. You can use `st.session_state` to make your Sistine UI reactive!
+
+```python
+from sistine import streamlit as st, Sistine, el
+
+app = Sistine()
+
+if "count" not in st.session_state:
+    st.session_state.count = 0
+
+@app.sistine("/")
+def counter():
+    # Native Streamlit Widget
+    if st.button("Add +1"):
+        st.session_state.count += 1
+        
+    # Sistine UI that reacts to Streamlit state!
+    return str(
+        el.h1(cls="text-3xl")(f"Count is: {st.session_state.count}")
+    )
+```
+
+## Examples
+
+Check out the [`examples/`](examples) directory for complete applications:
+- `tailwind_app.py` - Basic Tailwind setup.
+- `routing_app.py` - Multi-page routing with URL parameters (`/user/{id}`).
+- `dashboard_app.py` - Complex UI layout (sidebar, grid cards).
+- `pokeapi_app.py` - Working API integration showcasing `@query`.
+- `state_app.py` - Interactivity using Streamlit's `session_state`.
+- `mvc_app/` - Example of organizing a massive Sistine app using MVC pattern.

sistine-0.1.0/src/sistine.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/sistine/__init__.py
+src/sistine/__main__.py
+src/sistine/app.py
+src/sistine/cli.py
+src/sistine/el.py
+src/sistine/query.py
+src/sistine/server.py
+src/sistine.egg-info/PKG-INFO
+src/sistine.egg-info/SOURCES.txt
+src/sistine.egg-info/dependency_links.txt
+src/sistine.egg-info/entry_points.txt
+src/sistine.egg-info/requires.txt
+src/sistine.egg-info/top_level.txt

sistine-0.1.0/src/sistine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sistine-0.1.0/src/sistine.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sistine = sistine.cli:main

sistine-0.1.0/src/sistine.egg-info/requires.txt

@@ -0,0 +1,3 @@
+starlette>=0.40.0
+uvicorn>=0.30.0
+streamlit>=1.28.0

sistine-0.1.0/src/sistine.egg-info/top_level.txt

@@ -0,0 +1 @@
+sistine