shellac-webview 1.0.1__py3-none-any.whl

shellac/__init__.py

@@ -0,0 +1,5 @@
+from .window import Window
+from .enums import Browser
+from .models import WindowConfig, Event
+
+__all__ = ["Window", "Browser", "WindowConfig", "Event"]

shellac/enums.py

@@ -0,0 +1,11 @@
+from enum import IntEnum
+
+class Browser(IntEnum):
+    NoBrowser = 0
+    AnyBrowser = 1
+    Chrome = 2
+    Firefox = 3
+    Edge = 4
+    Chromium = 6
+    Brave = 8
+    Vivaldi = 9

shellac/launcher.py

@@ -0,0 +1,110 @@
+import platform
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+from selenium import webdriver
+from selenium.webdriver.chrome.service import Service as ChromeService
+from selenium.webdriver.firefox.service import Service as FirefoxService
+from selenium.webdriver.edge.service import Service as EdgeService
+
+from .enums import Browser
+from .models import WindowConfig
+
+class BrowserLauncher:
+    @staticmethod
+    def get_path(browser: Browser) -> Optional[str]:
+        system = platform.system()
+        if system == "Windows":
+            import winreg
+            reg_paths = {
+                Browser.Chrome: r"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe",
+                Browser.Edge: r"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\msedge.exe",
+                Browser.Firefox: r"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\firefox.exe",
+            }
+            if browser in reg_paths:
+                for hive in [winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER]:
+                    try:
+                        with winreg.OpenKey(hive, reg_paths[browser]) as key:
+                            return winreg.QueryValue(key, None)
+                    except FileNotFoundError: continue
+        
+        names = {Browser.Chrome: "google-chrome", Browser.Firefox: "firefox", Browser.Edge: "microsoft-edge"}
+        suffix = ".exe" if system == "Windows" else ""
+        return shutil.which(names.get(browser, "") + suffix) or shutil.which(browser.name.lower() + suffix)
+
+    @staticmethod
+    def prepare_firefox_profile(config: WindowConfig) -> str:
+        temp_dir = tempfile.mkdtemp(prefix="webui_ff_")
+        chrome_dir = Path(temp_dir) / "chrome"
+        chrome_dir.mkdir()
+
+        prefs = {
+            "toolkit.legacyUserProfileCustomizations.stylesheets": "true",
+            "browser.tabs.inTitlebar": "0", 
+            "browser.shell.checkDefaultBrowser": "false",
+            "browser.startup.page": "0",
+            "browser.tabs.warnOnClose": "false",
+            "security.csp.enable": "false",  
+            "security.mixed_content.block_active_content": "false", 
+            "network.websocket.allowInsecureFromHttp": "true",
+            "devtools.chrome.enabled": "true"
+        }
+        
+        with open(Path(temp_dir) / "prefs.js", "w") as f:
+            for k, v in prefs.items():
+                f.write(f'user_pref("{k}", {v});\n')
+
+        if config.hide_controls:
+            with open(chrome_dir / "userChrome.css", "w") as f:
+                f.write("""
+                @namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");
+                #nav-bar, #TabsToolbar, #PersonalToolbar, #sidebar-box, #urlbar-container {
+                    visibility: collapse !important;
+                }
+                """)
+        return temp_dir
+
+    @classmethod
+    def create_driver(cls, browser: Browser, url: str, config: WindowConfig) -> webdriver.Remote:
+        path = cls.get_path(browser)
+        
+        if browser in [Browser.Chrome, Browser.Edge, Browser.Chromium, Browser.Brave, Browser.Vivaldi]:
+            is_edge = browser == Browser.Edge
+            options = webdriver.EdgeOptions() if is_edge else webdriver.ChromeOptions()
+            if path: options.binary_location = path
+            
+            if config.hide_controls:
+                options.add_argument(f"--app={url}")
+            
+            options.add_argument("--disable-web-security")
+            options.add_argument("--allow-running-insecure-content") 
+            options.add_argument("--disable-site-isolation-trials")
+            options.add_argument(f"--user-data-dir={tempfile.mkdtemp()}") 
+            
+            options.add_argument(f"--window-size={config.width},{config.height}")
+            options.add_experimental_option("excludeSwitches", ["enable-automation"])
+            
+            return (webdriver.Edge(options=options) if is_edge else webdriver.Chrome(options=options))
+
+        elif browser == Browser.Firefox:
+            profile_path = cls.prepare_firefox_profile(config) 
+
+            options = webdriver.FirefoxOptions()
+            if path: options.binary_location = path
+            
+            options.add_argument("-profile")
+            options.add_argument(profile_path)
+
+            if config.kiosk:
+                options.add_argument("--kiosk")
+
+            options.set_preference("security.csp.enable", False)
+                
+            service = FirefoxService()
+            driver = webdriver.Firefox(service=service, options=options)
+            driver.set_window_size(config.width, config.height)
+            return driver
+
+        raise ValueError(f"Unsupported browser: {browser}")

shellac/models.py

@@ -0,0 +1,25 @@
+from typing import Any, List
+from pydantic import BaseModel, Field, ConfigDict
+
+class WindowConfig(BaseModel):
+    width: int = 1000
+    height: int = 800
+    hide_controls: bool = True 
+    kiosk: bool = False
+
+class Event(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    window: Any  
+    element: str = ""
+    data: List[Any] = Field(default_factory=list)
+
+    def get_string(self, index: int = 0) -> str:
+        return str(self.data[index]) if index < len(self.data) else ""
+        
+    def get_int(self, index: int = 0) -> int:
+        try: return int(self.data[index])
+        except (IndexError, ValueError): return 0
+        
+    def get_dict(self, index: int = 0) -> dict:
+        try: return dict(self.data[index])
+        except (IndexError, ValueError, TypeError): return {}

shellac/window.py

@@ -0,0 +1,297 @@
+import inspect
+import json
+import os
+import socket
+import threading
+import time
+from typing import Any, Callable, Dict, Optional, Union
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse
+from selenium import webdriver
+from selenium.common.exceptions import WebDriverException, NoSuchWindowException
+
+# Note: These imports assume the structure of your package
+from .enums import Browser
+from .models import WindowConfig, Event
+from .launcher import BrowserLauncher
+
+
+class Window:
+    """
+    Represents a WebUI window instance that manages a FastAPI backend 
+    and a Selenium-controlled browser frontend.
+    """
+
+    def __init__(self):
+        """Initializes a new Window instance with default configurations."""
+        self.config = WindowConfig()
+        self.port = self._get_free_port()
+        self.app = FastAPI()
+        self.bindings: Dict[str, Callable] = {}
+        self._html_content: Optional[str] = None
+        self.driver: Optional[webdriver.Remote] = None
+        self._running = False
+        self._setup_routes()
+
+    def _get_free_port(self) -> int:
+        """Finds an available TCP port on the localhost."""
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(('', 0))
+            return s.getsockname()[1]
+
+    def _get_bridge_js(self) -> str:
+        """Returns the JavaScript bridge code for Python-JS communication."""
+        return """
+        if (typeof window.webui === 'undefined') {
+            window._webui_queue = [];
+            window._webui_promises = {};
+            window._webui_call_id = 0;
+            window.webui = {
+                call: (fn, ...args) => {
+                    return new Promise((resolve, reject) => {
+                        const id = window._webui_call_id++;
+                        window._webui_promises[id] = resolve;
+                        window._webui_queue.push({fn: fn, args: args, id: id});
+                    });
+                }
+            };
+            window._webui_resolve = (id, result) => {
+                if (window._webui_promises[id]) {
+                    window._webui_promises[id](result);
+                    delete window._webui_promises[id];
+                }
+            };
+        }
+        """
+
+    def _setup_routes(self):
+        """Configures the internal FastAPI routes."""
+        @self.app.get("/")
+        async def index():
+            content = self._html_content or "<html><body>No Content</body></html>"
+            bridge = f"<script>{self._get_bridge_js()}</script>"
+            if "<head>" in content:
+                return HTMLResponse(content.replace("<head>", f"<head>{bridge}"))
+            return HTMLResponse(bridge + content)
+
+    def _bind_target(self, target: Any, prefix: str = "", exact_name: bool = False):
+        """Internal helper to map functions or class methods to the registry."""
+        if inspect.isfunction(target) or inspect.ismethod(target):
+            name = prefix if (exact_name and prefix) else (f"{prefix}.{target.__name__}" if prefix else target.__name__)
+            self.bindings[name] = target
+        else:
+            if inspect.isclass(target):
+                try:
+                    obj = target()
+                except TypeError as e:
+                    raise ValueError(f"Cannot auto-instantiate class '{target.__name__}'.") from e
+            else:
+                obj = target
+                
+            for name in dir(obj):
+                if not name.startswith('_'): 
+                    attr = getattr(obj, name)
+                    if callable(attr):
+                        bind_name = f"{prefix}.{name}" if prefix else name
+                        self.bindings[bind_name] = attr
+
+    def bind(self, name_or_target: Union[str, Any] = None, target: Optional[Any] = None):
+        """
+        Binds a Python function, class, or instance to be callable from JavaScript.
+
+        This method can be used as a decorator or as a direct function call.
+
+        Args:
+            name_or_target (Union[str, Any], optional): The name/prefix for the binding 
+                or the target itself if no name is provided.
+            target (Any, optional): The function or class instance to bind (only used 
+                if name_or_target is a string).
+
+        Returns:
+            The original target or a decorator function.
+
+        Examples:
+            >>> win.bind("say_hello", lambda e: "Hello!")
+            >>> @win.bind("math")
+            ... class Math:
+            ...     def add(self, e): return e.data[0] + e.data[1]
+        """
+        if isinstance(name_or_target, str) and target is not None:
+            is_func = inspect.isfunction(target) or inspect.ismethod(target)
+            self._bind_target(target, prefix=name_or_target, exact_name=is_func)
+            return target
+            
+        if isinstance(name_or_target, str) and target is None:
+            def decorator(decor_target: Any):
+                is_func = inspect.isfunction(decor_target) or inspect.ismethod(decor_target)
+                self._bind_target(decor_target, prefix=name_or_target, exact_name=is_func)
+                return decor_target
+            return decorator
+            
+        if name_or_target is not None:
+            self._bind_target(name_or_target, exact_name=False)
+            return name_or_target
+            
+        return self
+
+    def navigate(self, url_or_html: str):
+        """
+        Navigates the current window to a new URL, a local file, or raw HTML content.
+
+        Args:
+            url_or_html (str): A web URL (http://...), a path to a .html file, 
+                or a raw HTML string.
+        """
+        if not self.driver:
+            return
+            
+        is_url = url_or_html.startswith(('http://', 'https://', 'file://'))
+        if is_url:
+            self.driver.get(url_or_html)
+        else:
+            try:
+                if len(url_or_html) < 1000 and os.path.exists(url_or_html):
+                    with open(url_or_html, 'r', encoding='utf-8') as f:
+                        self._html_content = f.read()
+                else:
+                    self._html_content = url_or_html
+            except OSError:
+                self._html_content = url_or_html
+                
+            self.driver.get(f"http://127.0.0.1:{self.port}/")
+
+    def run_js(self, script: str) -> Any:
+        """
+        Executes synchronous JavaScript code in the browser.
+
+        Args:
+            script (str): The JavaScript code to execute.
+
+        Returns:
+            Any: The result returned by the JavaScript execution.
+        """
+        if self.driver:
+            try: return self.driver.execute_script(script)
+            except Exception as e: print(f"[WebUI] JS Execution Error: {e}")
+        return None
+
+    def close(self):
+        """Closes the browser window and shuts down the backend server."""
+        self._running = False
+        if self.driver:
+            try: self.driver.quit()
+            except Exception: pass
+            self.driver = None
+
+    def set_size(self, width: int, height: int):
+        """
+        Resizes the browser window.
+
+        Args:
+            width (int): Target width in pixels.
+            height (int): Target height in pixels.
+        """
+        self.config.width = width
+        self.config.height = height
+        if self.driver: self.driver.set_window_size(width, height)
+
+    def set_title(self, title: str):
+        """
+        Updates the browser window title.
+
+        Args:
+            title (str): The new title string.
+        """
+        self.run_js(f"document.title = {json.dumps(title)};")
+
+    def is_running(self) -> bool:
+        """
+        Checks if the window and backend are currently running.
+
+        Returns:
+            bool: True if running, False otherwise.
+        """
+        return self._running
+
+    def _bridge_monitor(self):  
+        """Internal background thread that polls the JS bridge for incoming calls."""
+        while self._running:
+            if self.driver:
+                try:
+                    exists = self.driver.execute_script("return (typeof window.webui !== 'undefined' && typeof window._webui_resolve !== 'undefined');")
+                    if not exists:
+                        self.driver.execute_script(self._get_bridge_js())
+                    
+                    events = self.driver.execute_script("""
+                        var e = window._webui_queue; 
+                        window._webui_queue = []; 
+                        return e;
+                    """)
+                    
+                    for event_data in (events or []):
+                        fn = event_data.get('fn')
+                        call_id = event_data.get('id')
+                        if fn in self.bindings:
+                            event = Event(window=self, element=fn, data=event_data.get('args', []))
+                            cb = self.bindings[fn]
+                            result = cb(event)
+                            result_json = json.dumps(result)
+                            self.driver.execute_script(f"window._webui_resolve({call_id}, {result_json});")
+                            
+                except Exception:
+                    pass
+            time.sleep(0.05) 
+
+    def show(self, content: str, browser: Browser = Browser.AnyBrowser):
+        """
+        Starts the backend server and launches the browser window.
+
+        Args:
+            content (str): The URL, HTML file path, or HTML string to display.
+            browser (Browser): The browser engine to use (defaults to AnyBrowser).
+        """
+        self._running = True
+        is_url = content.startswith(('http://', 'https://', 'file://'))
+        if not is_url:
+            try:
+                if len(content) < 1000 and os.path.exists(content):
+                    with open(content, 'r', encoding='utf-8') as f: self._html_content = f.read()
+                else: self._html_content = content
+            except OSError:
+                self._html_content = content
+            url = f"http://127.0.0.1:{self.port}/"
+        else:
+            url = content
+
+        threading.Thread(target=uvicorn.run, args=(self.app,), 
+                         kwargs={"host": "127.0.0.1", "port": self.port, "log_level": "error"}, 
+                         daemon=True).start()
+
+        target = browser
+        if target == Browser.AnyBrowser:
+            for b in [Browser.Chrome, Browser.Edge, Browser.Firefox]:
+                if BrowserLauncher.get_path(b):
+                    target = b
+                    break
+
+        self.driver = BrowserLauncher.create_driver(target, url, self.config)
+        self.driver.get(url)
+        threading.Thread(target=self._bridge_monitor, daemon=True).start()
+
+    def wait(self):
+        """
+        Blocks the main thread until the browser window is closed.
+        """
+        try:
+            while self._running:
+                if self.driver:
+                    try:
+                        _ = self.driver.window_handles
+                    except (NoSuchWindowException, WebDriverException):
+                        break
+                time.sleep(1)
+        except KeyboardInterrupt: pass
+        finally:
+            self.close()

shellac_webview-1.0.1.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: shellac-webview
+Version: 1.0.1
+Author-email: Sharkow1743 <Sharkow1743@users.noreply.github.com>
+Project-URL: Homepage, https://github.com/Sharkow1743/shellac-webview
+Project-URL: Bug Tracker, https://github.com/Sharkow1743/shellac-webview/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: pydantic
+Requires-Dist: selenium
+
+# Shellac Webview
+
+A Selenium wrapper for building desktop applications using web technologies. It uses FastAPI for backend communication and Selenium for browser automation.
+
+## Installation
+
+```bash
+pip install shellac-webview
+```
+
+## Basic Usage
+
+```python
+from shellac import Window
+
+win = Window()
+
+@win.bind
+def my_function(event):
+    return "Data from Python"
+
+html = """
+<button onclick="run()">Run</button>
+<script>
+    async function run() {
+        const result = await webui.call("my_function");
+        console.log(result);
+    }
+</script>
+"""
+
+win.show(html)
+win.wait()
+```
+
+## Binding
+
+You can bind functions in python to be called from js using `webui.call("func_name")`
+
+### Function Binding
+You can bind a specific function to a name.
+```python
+def my_function(event):
+    return f"Hello, {event.data[0]}!"
+
+win.bind("greet", my_function)
+```
+**JS Usage:**
+```javascript
+const response = await webui.call("greet", "Alice");
+console.log(response); // "Hello, Alice!"
+```
+
+### Decorator Binding
+Use the `@bind` decorator for a cleaner syntax.
+```python
+@win.bind
+def calculate(event):
+    return event.data[0] * 2
+```
+**JS Usage:** `webui.call("calculate", 21);`
+
+### Class/Namespace Binding
+You can bind an entire class or instance. All public methods (not starting with `_`) will be available in JavaScript.
+```python
+@win.bind("db")
+class Database:
+    def get_user(self, event):
+        return {"id": event.data[0], "name": "John Doe"}
+```
+or with
+```python
+win.bind("db", Database())
+```
+**JS Usage:**
+```javascript
+const user = await webui.call("db.get_user", 1);
+```
+
+### Class Mapping
+If you bind a class without a prefix, its methods are mapped to the top-level.
+```python
+class API:
+    def status(self, event):
+        return "Online"
+
+win.bind(API)
+```
+**JS Usage:** `webui.call("status");`
+
+### The `Event` Object
+Every bound Python function receives an `Event` object as its first argument.
+- `event.window`: The `Window` instance.
+- `event.data`: A list of arguments passed from JavaScript.
+- `event.element`: The name of the function called.
+
+## Window Configuration
+
+You can configure the window size and behavior before calling `show()`.
+
+```python
+win = Window()
+win.config.width = 1200
+win.config.height = 900
+win.config.hide_controls = True # Hides address bar/tabs (App Mode)
+win.config.kiosk = False        # Fullscreen mode
+```
+
+## Browser Selection
+
+By default, the library looks for Chrome, Edge, or Firefox. You can force a specific browser:
+
+```python
+from webui import Browser
+
+win.show("index.html", browser=Browser.Firefox)
+```
+
+Available options: `Chrome`, `Firefox`, `Edge`, `Chromium`, `Brave`, `Vivaldi`.
+
+## Other functions
+
+Once the window is running, you can navigate to new pages or execute JavaScript from Python.
+
+```python
+# Navigate to a new URL
+win.navigate("https://google.com")
+
+# Execute JS directly
+win.run_js("alert('Hello from Python!')")
+
+# Change title
+win.set_title("New Title")
+```

shellac_webview-1.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+shellac/__init__.py,sha256=T_0tUvsKypt1skVvX3Nu17VTqSjAKdZZdVOdhhsOR4g,151
+shellac/enums.py,sha256=ak5X3bh5N3T0tF2uUFwJN7PZ7aRkjGPcXM_0M2_Xg44,177
+shellac/launcher.py,sha256=p_bktZ8b9bbNxq4kcM_HGkTgSLwj4DPyWjjdS8itSr0,4747
+shellac/models.py,sha256=LVPbDokc1VHphN47WXFQsErSsji6ZYaXZdaTPwQkWkY,815
+shellac/window.py,sha256=KJ8m-GLYR9A2wwbY-Xkt1Ne89oQKdCBsBO7NdwrZuuc,11264
+shellac_webview-1.0.1.dist-info/METADATA,sha256=904PPg72YZEjEWhQRSwApJYq60f4J7pPVwcbVj01iXg,3385
+shellac_webview-1.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+shellac_webview-1.0.1.dist-info/top_level.txt,sha256=XufVWfhTQ-kO571Rqhkmxx5nMdJnCPuU_UiJLHVF2DU,8
+shellac_webview-1.0.1.dist-info/RECORD,,

shellac_webview-1.0.1.dist-info/WHEEL

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

shellac_webview-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+shellac