wysebee 0.2.0__tar.gz

wysebee-0.2.0/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: wysebee
+Version: 0.2.0
+Summary: A simple cross-platform framework for your AI project.
+Author-email: Jeff Xu <zxu@wysebee.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Dist: pyside6>=6.9.0
+Requires-Dist: Jinja2>=3.1.2
+Requires-Dist: typer>=0.15.2
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: watchdog==6.0.0
+Project-URL: Homepage, https://github.com/wysebee/wysebee
+Project-URL: Issues, https://github.com/wysebee/wysebee/issues
+
+# Wysebee
+
+**Wysebee** is a cross-platform application framework for building modern apps with web-technology UIs and Python backends. Write your frontend in HTML/CSS/JS (React, Vanilla, or TypeScript via Vite) and your backend in Python — ship it as a native desktop app powered by **PySide (Qt)**, or as a **FastAPI** web service, from a single project layout.
+
+---
+
+## Features
+
+- **One project, two targets.** Generate a desktop (PySide/Qt) or web (FastAPI) app with the same `wyse init` command.
+- **Vite-powered frontends.** First-class support for `react`, `react-ts`, `vanilla`, and `vanilla-ts` templates.
+- **Python ↔ JS bridge.** Desktop apps come wired with a `QWebChannel` bridge so your frontend can call Python methods and receive signals.
+- **Native app menus.** Declare your menu bar in `menu/menu.json`; Wysebee wires each item to a backend method for you.
+- **Drop-in backend.** Subclass `WysebeeBackend` and add `@Slot()` methods — they're instantly callable from JavaScript.
+- **Hot reload in dev.** `wyse dev` watches your UI source and rebuilds/reloads the browser view automatically.
+
+---
+
+## Installation
+
+```bash
+pip install wysebee
+```
+
+This installs the `wyse` CLI alongside the `wysebee` Python package.
+
+---
+
+## Quick start
+
+### 1. Create a new app
+
+```bash
+wyse init my-app
+```
+
+You'll be prompted to choose `desktop` or `web`. To select a Vite template other than the default React:
+
+```bash
+wyse init my-app --template vanilla-ts
+```
+
+Supported templates: `react` (default), `react-ts`, `vanilla`, `vanilla-ts`.
+
+### 2. Run it
+
+```bash
+cd my-app
+python main.py
+```
+
+For live reload during development:
+
+```bash
+wyse dev
+```
+
+### 3. Build the UI
+
+```bash
+wyse build --ui
+```
+
+---
+
+## Generated project layout
+
+### Desktop app
+
+```
+my-app/
+├── main.py              # Entry point (QApplication + Wysebee + WysebeeAppMenu)
+├── menu/
+│   └── menu.json        # Declarative menu bar wired to backend methods
+├── src/
+│   ├── __init__.py
+│   └── backend.py       # MyBackend(WysebeeBackend) — customize Python-side logic
+├── ui/                  # Vite project (your frontend)
+│   ├── index.html
+│   ├── src/
+│   └── templates/       # Built output loaded by the desktop window
+└── requirements.txt
+```
+
+### Web app
+
+```
+my-app/
+├── main.py              # FastAPI app serving the built UI
+├── ui/                  # Vite project
+│   └── templates/       # Built output mounted as static files
+└── requirements.txt
+```
+
+---
+
+## Wiring a native menu (desktop)
+
+`menu/menu.json` maps menu items to methods on your backend by name:
+
+```json
+[
+  {
+    "label": "File",
+    "submenu": [
+      { "label": "Open", "action": "on_open" },
+      { "label": "Save", "action": "on_save" },
+      { "separator": true },
+      { "label": "Exit", "action": "on_exit" }
+    ]
+  }
+]
+```
+
+Implement those methods on your backend:
+
+```python
+from PySide6.QtWidgets import QApplication, QFileDialog
+from PySide6.QtCore import Slot
+from wysebee import WysebeeBackend
+
+class MyBackend(WysebeeBackend):
+    @Slot()
+    def on_open(self):
+        file_path, _ = QFileDialog.getOpenFileName(None, "Open File")
+        # ...
+
+    @Slot()
+    def on_exit(self):
+        QApplication.quit()
+```
+
+---
+
+## Calling Python from JavaScript (desktop)
+
+Wysebee exposes your backend to the frontend through `QWebChannel`. The generated `index.html` initializes it and attaches the backend to `window.wysebee`:
+
+```js
+window.wysebee.sendMessage("Hello from the frontend!");
+```
+
+Any `@Slot(str, result=str)` method on your backend is callable this way.
+
+---
+
+## CLI reference
+
+| Command | Description |
+| --- | --- |
+| `wyse init <name> [--template ...]` | Scaffold a new desktop or web app. |
+| `wyse dev` | Build the UI and run the app in development mode (hot reload). |
+| `wyse build --ui` | Build only the frontend (`npm run build` inside `ui/`). |
+
+---
+
+## Links
+
+- Homepage: [wysebee.io](https://wysebee.io)
+- Source: [github.com/wysebee/wysebee-io](https://github.com/wysebee/wysebee-io)
+- Issues: [github.com/wysebee/wysebee-io/issues](https://github.com/wysebee/wysebee-io/issues)
+
+---
+
+## License
+
+MIT
+

wysebee-0.2.0/README.md

@@ -0,0 +1,166 @@
+# Wysebee
+
+**Wysebee** is a cross-platform application framework for building modern apps with web-technology UIs and Python backends. Write your frontend in HTML/CSS/JS (React, Vanilla, or TypeScript via Vite) and your backend in Python — ship it as a native desktop app powered by **PySide (Qt)**, or as a **FastAPI** web service, from a single project layout.
+
+---
+
+## Features
+
+- **One project, two targets.** Generate a desktop (PySide/Qt) or web (FastAPI) app with the same `wyse init` command.
+- **Vite-powered frontends.** First-class support for `react`, `react-ts`, `vanilla`, and `vanilla-ts` templates.
+- **Python ↔ JS bridge.** Desktop apps come wired with a `QWebChannel` bridge so your frontend can call Python methods and receive signals.
+- **Native app menus.** Declare your menu bar in `menu/menu.json`; Wysebee wires each item to a backend method for you.
+- **Drop-in backend.** Subclass `WysebeeBackend` and add `@Slot()` methods — they're instantly callable from JavaScript.
+- **Hot reload in dev.** `wyse dev` watches your UI source and rebuilds/reloads the browser view automatically.
+
+---
+
+## Installation
+
+```bash
+pip install wysebee
+```
+
+This installs the `wyse` CLI alongside the `wysebee` Python package.
+
+---
+
+## Quick start
+
+### 1. Create a new app
+
+```bash
+wyse init my-app
+```
+
+You'll be prompted to choose `desktop` or `web`. To select a Vite template other than the default React:
+
+```bash
+wyse init my-app --template vanilla-ts
+```
+
+Supported templates: `react` (default), `react-ts`, `vanilla`, `vanilla-ts`.
+
+### 2. Run it
+
+```bash
+cd my-app
+python main.py
+```
+
+For live reload during development:
+
+```bash
+wyse dev
+```
+
+### 3. Build the UI
+
+```bash
+wyse build --ui
+```
+
+---
+
+## Generated project layout
+
+### Desktop app
+
+```
+my-app/
+├── main.py              # Entry point (QApplication + Wysebee + WysebeeAppMenu)
+├── menu/
+│   └── menu.json        # Declarative menu bar wired to backend methods
+├── src/
+│   ├── __init__.py
+│   └── backend.py       # MyBackend(WysebeeBackend) — customize Python-side logic
+├── ui/                  # Vite project (your frontend)
+│   ├── index.html
+│   ├── src/
+│   └── templates/       # Built output loaded by the desktop window
+└── requirements.txt
+```
+
+### Web app
+
+```
+my-app/
+├── main.py              # FastAPI app serving the built UI
+├── ui/                  # Vite project
+│   └── templates/       # Built output mounted as static files
+└── requirements.txt
+```
+
+---
+
+## Wiring a native menu (desktop)
+
+`menu/menu.json` maps menu items to methods on your backend by name:
+
+```json
+[
+  {
+    "label": "File",
+    "submenu": [
+      { "label": "Open", "action": "on_open" },
+      { "label": "Save", "action": "on_save" },
+      { "separator": true },
+      { "label": "Exit", "action": "on_exit" }
+    ]
+  }
+]
+```
+
+Implement those methods on your backend:
+
+```python
+from PySide6.QtWidgets import QApplication, QFileDialog
+from PySide6.QtCore import Slot
+from wysebee import WysebeeBackend
+
+class MyBackend(WysebeeBackend):
+    @Slot()
+    def on_open(self):
+        file_path, _ = QFileDialog.getOpenFileName(None, "Open File")
+        # ...
+
+    @Slot()
+    def on_exit(self):
+        QApplication.quit()
+```
+
+---
+
+## Calling Python from JavaScript (desktop)
+
+Wysebee exposes your backend to the frontend through `QWebChannel`. The generated `index.html` initializes it and attaches the backend to `window.wysebee`:
+
+```js
+window.wysebee.sendMessage("Hello from the frontend!");
+```
+
+Any `@Slot(str, result=str)` method on your backend is callable this way.
+
+---
+
+## CLI reference
+
+| Command | Description |
+| --- | --- |
+| `wyse init <name> [--template ...]` | Scaffold a new desktop or web app. |
+| `wyse dev` | Build the UI and run the app in development mode (hot reload). |
+| `wyse build --ui` | Build only the frontend (`npm run build` inside `ui/`). |
+
+---
+
+## Links
+
+- Homepage: [wysebee.io](https://wysebee.io)
+- Source: [github.com/wysebee/wysebee-io](https://github.com/wysebee/wysebee-io)
+- Issues: [github.com/wysebee/wysebee-io/issues](https://github.com/wysebee/wysebee-io/issues)
+
+---
+
+## License
+
+MIT

wysebee-0.2.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "wysebee"
+version = "0.2.0"
+authors = [
+  { name="Jeff Xu", email="zxu@wysebee.com" },
+]
+description = "A simple cross-platform framework for your AI project."
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+
+dependencies = [
+    "pyside6>=6.9.0",
+    "Jinja2>=3.1.2",
+    "typer>=0.15.2",
+    "colorama>=0.4.6",
+    "watchdog==6.0.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/wysebee/wysebee"
+Issues = "https://github.com/wysebee/wysebee/issues"
+
+[build-system]
+requires = ["flit_core<4"]
+build-backend = "flit_core.buildapi"
+
+[tool.flit.module]
+name = "wysebee"
+
+[project.scripts]
+wyse = "wysebee.cli.main:app"
+wyse-web = "wysebee.cli.main:app_web"
+wyse-desktop = "wysebee.cli.main:app_desktop"

wysebee-0.2.0/src/wysebee/__init__.py

@@ -0,0 +1,9 @@
+from .desktop.wysebee import Wysebee
+from .desktop.wysebee_webview import WysebeeWebView
+from .desktop.wysebee_webengine_page import WysebeeWebEnginePage
+from .desktop.wysebee_backend import WysebeeBackend
+from .desktop.singleton import singleton
+from .desktop.temp_helper import TempFileHelper
+from .desktop.wysebee_webpopup import WysebeeWebPopup
+from .desktop.wysebee_app_menu import WysebeeAppMenu
+from .desktop.filesystem import *

wysebee-0.2.0/src/wysebee/cli/_uv.py

@@ -0,0 +1,31 @@
+import shutil
+import subprocess
+from pathlib import Path
+
+from colorama import Fore
+
+
+def ensure_uv_available() -> bool:
+    """Return True if `uv` is on PATH, otherwise print an error and return False."""
+    if shutil.which("uv") is None:
+        print(
+            Fore.RED
+            + "uv is not installed or not on PATH. Install it from https://docs.astral.sh/uv/ and re-run."
+        )
+        return False
+    return True
+
+
+def bootstrap_uv_project(project_dir: Path) -> bool:
+    """Run `uv venv` and `uv sync` inside the given project directory."""
+    if not ensure_uv_available():
+        return False
+    try:
+        print(Fore.YELLOW + f"Creating virtualenv in {project_dir} with uv...")
+        subprocess.run(["uv", "venv"], cwd=project_dir, check=True)
+        print(Fore.YELLOW + f"Installing dependencies in {project_dir} with uv...")
+        subprocess.run(["uv", "sync"], cwd=project_dir, check=True)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(Fore.RED + f"uv bootstrap failed: {e}")
+        return False

wysebee-0.2.0/src/wysebee/cli/_vite.py

@@ -0,0 +1,74 @@
+"""Shared Vite setup helpers: fresh vite.config.js + multi-page entries."""
+
+import subprocess
+from pathlib import Path
+
+from colorama import Fore
+
+from .templates import (
+    render_page_html,
+    render_react_entry,
+    render_vanilla_settings_entry,
+)
+
+
+def _vite_config(template: str, platform: str) -> str:
+    """Return a fresh vite.config.js body for the given template + platform.
+
+    - Desktop uses base './' so the PySide WebView can load assets via file:// URLs.
+    - Web uses base '/' so both `/` and `/settings` can share absolute asset paths.
+    """
+    base = "./" if platform == "desktop" else "/"
+    is_react = template in ("react", "react-ts")
+
+    plugin_import = "import react from '@vitejs/plugin-react'\n" if is_react else ""
+    plugins_line = "  plugins: [react()],\n" if is_react else ""
+
+    return f"""import {{ defineConfig }} from 'vite'
+{plugin_import}
+// https://vitejs.dev/config/
+export default defineConfig({{
+{plugins_line}  base: '{base}',
+  build: {{
+    outDir: 'templates',
+    emptyOutDir: true,
+    rollupOptions: {{
+      input: {{
+        main: 'index.html',
+        settings: 'settings.html',
+      }},
+    }},
+  }},
+}})
+"""
+
+
+def setup_vite_pages(template: str, platform: str) -> None:
+    """Write vite.config.js, index.html, settings.html, and entry modules.
+
+    Assumes the current working directory is the `ui/` folder containing the
+    just-initialized Vite project.
+    """
+    Path("vite.config.js").write_text(_vite_config(template, platform))
+    print(Fore.YELLOW + f"Wrote vite.config.js (multi-page, base={'./'if platform == 'desktop' else '/'})")
+
+    Path("index.html").write_text(render_page_html(template, platform, "index"))
+    Path("settings.html").write_text(render_page_html(template, platform, "settings"))
+    print(Fore.YELLOW + f"Wrote index.html and settings.html for {platform} ({template})")
+
+    if template in ("react", "react-ts"):
+        ext = "tsx" if template == "react-ts" else "jsx"
+        Path(f"src/main.{ext}").write_text(render_react_entry(template, "index"))
+        Path(f"src/settings.{ext}").write_text(render_react_entry(template, "settings"))
+        print(Fore.YELLOW + f"Wrote src/main.{ext} and src/settings.{ext} with HashRouter")
+    elif template in ("vanilla", "vanilla-ts"):
+        ext = "ts" if template == "vanilla-ts" else "js"
+        Path(f"src/settings.{ext}").write_text(render_vanilla_settings_entry(template))
+        print(Fore.YELLOW + f"Wrote src/settings.{ext}")
+
+
+def install_router_if_react(template: str) -> None:
+    """Install react-router-dom if the template is a react template."""
+    if template in ("react", "react-ts"):
+        print(Fore.YELLOW + "Installing react-router-dom...")
+        subprocess.run(["npm", "install", "react-router-dom"], check=True)

wysebee-0.2.0/src/wysebee/cli/desktop.py

@@ -0,0 +1,188 @@
+import json
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from colorama import Fore
+
+from ._uv import bootstrap_uv_project
+from ._vite import install_router_if_react, setup_vite_pages
+
+
+def _generate_ui_template(name: str, ui_dir: str, template: str):
+    # Change to UI directory and initialize vite
+    try:
+        print(Fore.YELLOW + f"Setting up Vite in UI folder...")
+        original_dir = os.getcwd()
+        os.chdir(ui_dir)
+        if template:
+            subprocess.run(
+                ["npm", "create", "vite@latest", ".", "--", "--template", template],
+                input="n\n",
+                text=True,
+                check=True,
+            )
+        else:
+            subprocess.run(
+                ["npm", "create", "vite@latest", "."],
+                input="n\n",
+                text=True,
+                check=True,
+            )
+
+        subprocess.run(["npm", "install"], check=True)
+        install_router_if_react(template)
+
+        # Write fresh vite.config.js + index/settings pages + entry modules
+        setup_vite_pages(template, platform="desktop")
+
+        subprocess.run(["npm", "run", "build"], check=True)
+        os.chdir(original_dir)
+        print(Fore.YELLOW + f"Successfully set up Vite in {name}/ui!")
+    except subprocess.CalledProcessError as e:
+        print(Fore.RED + f"Error running npm create vite: {e}")
+        os.chdir(original_dir)
+    except Exception as e:
+        print(Fore.RED + f"Unexpected error: {e}")
+        os.chdir(original_dir)
+
+
+def _generate_app_menu_template(desktop_dir: Path):
+    """Create a menu folder with a sample menu.json inside the desktop folder."""
+    menu_dir = desktop_dir / "menu"
+    menu_dir.mkdir(exist_ok=True)
+    menu_file = menu_dir / "menu.json"
+    menu_file.write_text(
+        json.dumps(
+            [
+                {
+                    "label": "File",
+                    "submenu": [
+                        {"label": "Open", "action": "on_open"},
+                        {"label": "Save", "action": "on_save"},
+                        {"separator": True},
+                        {"label": "Exit", "action": "on_exit"},
+                    ],
+                },
+            ],
+            indent=2,
+        )
+    )
+    print(Fore.YELLOW + f"Created menu/menu.json in {desktop_dir}")
+
+
+def generate_desktop_app(name: str, app_dir: Path, ui_dir: Path, template: str, project_name: Optional[str] = None) -> None:
+    """Generate a complete desktop app: desktop/{main.py, src/, menu/, pyproject.toml}, UI at root."""
+    if project_name is None:
+        project_name = name
+    # Create the desktop/ subfolder that holds all Python files
+    desktop_dir = app_dir / "desktop"
+    desktop_dir.mkdir(exist_ok=True)
+    print(Fore.YELLOW + f"Created desktop folder in {name}")
+
+    # Create the src subfolder inside desktop/
+    src_dir = desktop_dir / "src"
+    src_dir.mkdir(exist_ok=True)
+    print(Fore.YELLOW + f"Created desktop/src folder in {name}")
+
+    # Generate menu template inside desktop/
+    _generate_app_menu_template(desktop_dir)
+
+    # Create desktop/src/__init__.py
+    init_file = src_dir / "__init__.py"
+    init_file.write_text("")
+
+    # Create desktop/src/backend.py
+    backend_file = src_dir / "backend.py"
+    backend_file.write_text(
+        """import logging
+from PySide6.QtWidgets import QApplication, QFileDialog
+from PySide6.QtCore import Slot
+from wysebee import WysebeeBackend
+
+logger = logging.getLogger("wysebee")
+
+
+class MyBackend(WysebeeBackend):
+    def __init__(self, parent):
+        super().__init__(parent)
+
+    @Slot()
+    def on_open(self):
+        file_path, _ = QFileDialog.getOpenFileName(None, "Open File")
+        if file_path:
+            logger.info(f"Opened file: {file_path}")
+
+    @Slot()
+    def on_save(self):
+        file_path, _ = QFileDialog.getSaveFileName(None, "Save File")
+        if file_path:
+            logger.info(f"Saved file: {file_path}")
+
+    @Slot()
+    def on_exit(self):
+        logger.info("Exiting application")
+        QApplication.quit()
+"""
+    )
+    print(Fore.YELLOW + f"Created desktop/src/backend.py in {name}")
+
+    # Create desktop/main.py for desktop app. Paths are relative to this file:
+    #   menu -> menu/menu.json (same dir)
+    #   ui   -> ../ui/templates/index.html (ui lives at project root)
+    main_file = desktop_dir / "main.py"
+    main_file.write_text(
+        """
+import sys
+import os
+from PySide6.QtWidgets import QApplication
+from wysebee import Wysebee, WysebeeAppMenu
+from src.backend import MyBackend
+
+def main():
+    app = QApplication(sys.argv)
+    wysebee = Wysebee(app)
+    backend = MyBackend(app)
+    browser = wysebee.initialize_window(width=1280, height=800, backend=backend)
+    menu_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "menu/menu.json"))
+    app_menu = WysebeeAppMenu(browser, backend, menu_path)
+    html_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../ui/templates/index.html"))
+    wysebee.launch(html_path)
+    app_menu.show()
+
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    main()
+"""
+    )
+    print(Fore.YELLOW + f"Created desktop/main.py file in {name}")
+
+    # Write desktop/pyproject.toml (uv-managed)
+    pyproject_file = desktop_dir / "pyproject.toml"
+    pyproject_file.write_text(
+        f"""[project]
+name = "{project_name}-desktop"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = [
+    "PySide6",
+    "Wysebee",
+]
+"""
+    )
+    print(Fore.YELLOW + f"Created desktop/pyproject.toml in {name}")
+
+    # Build the UI first (ui/ stays at project root)
+    _generate_ui_template(name, ui_dir, template)
+
+    # Bootstrap the uv venv + install dependencies
+    if bootstrap_uv_project(desktop_dir):
+        print(Fore.GREEN + f"Now you are ready!")
+        print(Fore.GREEN + f" To run the app, use:")
+        if name != ".":
+            print(Fore.GREEN + f"   cd {name}/desktop")
+        else:
+            print(Fore.GREEN + f"   cd desktop")
+        print(Fore.GREEN + f"   uv run python main.py")