streamlit2stlite 0.1.0__tar.gz

streamlit2stlite-0.1.0/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: streamlit2stlite
+Version: 0.1.0
+Summary: Convert Streamlit Python apps to stlite HTML apps
+Project-URL: Homepage, https://github.com/caggionim/streamlit2stlite
+Project-URL: Bug Tracker, https://github.com/caggionim/streamlit2stlite/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+# 🔦 streamlit2stlite
+
+**Turn your Streamlit apps into standalone HTML files in seconds.**
+
+`streamlit2stlite` is a simple tool that bundles your Streamlit application and all its dependencies into a single HTML file. This file can be opened in any modern browser, running entirely purely on the client side using WebAssembly (via [stlite](https://github.com/whitphx/stlite)). **No server, no hosting costs, no deployment headaches.**
+
+> 💡 Perfect for sharing data dashboards, prototypes, and tools with colleagues or clients who don't have Python installed.
+
+## 🚀 Quick Start
+
+1.  **Install** the tool:
+    ```bash
+    pip install streamlit2stlite
+    ```
+
+2.  **Convert** your app:
+    ```bash
+    streamlit2stlite my_app.py
+    ```
+
+3.  **Open** `my_app.html` in your browser. That's it!
+
+---
+
+## ✨ Features
+
+*   **📦 Auto-Magic Dependency Detection**: Automatically scans your imports to determine which packages to install in the browser (e.g., proper handling of `pandas`, `numpy`, `scipy` for `lmfit`, etc.).
+*   **� LaTeX Support**: Correctly handles backslashes in your math equations so they render perfectly.
+*   **�️ Smart Titles**: Automatically detects your app's title from `st.set_page_config()` or `st.title()`.
+*   **🛠️ Full Control**: Override requirements, titles, or the stlite version via CLI flags if you need to.
+
+## � Usage Guide
+
+### Basic Conversion
+The simplest way to use it. Defaults to creating an HTML file with the same name as your script.
+
+```bash
+streamlit2stlite dashboard.py
+# -> Creates dashboard.html
+```
+
+### Custom Output Name
+Specify exactly where you want the file to go.
+
+```bash
+streamlit2stlite script.py -o ./dist/awesome_dashboard.html
+```
+
+### Managing Dependencies
+We try to guess your dependencies, but sometimes you need to be specific.
+
+**Add extra packages:**
+```bash
+streamlit2stlite app.py --add-requirements "scikit-learn,purple-air"
+```
+
+**Override completely:**
+```bash
+streamlit2stlite app.py --requirements "streamlit,pandas,numpy"
+```
+
+### Full CLI Options
+
+```text
+usage: streamlit2stlite [-h] [-o OUTPUT] [-r REQUIREMENTS] [-t TITLE]
+                        [--stlite-version STLITE_VERSION]
+                        [--add-requirements ADD_REQUIREMENTS] [-v]
+                        input
+
+positional arguments:
+  input                 Path to the input Streamlit Python file
+
+options:
+  -h, --help            show this help message
+  -o, --output          Path to the output HTML file
+  -r, --requirements    Comma-separated list of packages to install
+  -t, --title           Title for the HTML page
+  --add-requirements    Additional packages to add to auto-detected ones
+  -v, --verbose         Print verbose output
+```
+
+## ❓ FAQ
+
+**How does this work?**
+It embeds your Python code into a template that loads `stlite` (a port of Streamlit to WebAssembly). When you open the HTML file, your browser downloads a mini Python environment (Pyodide) and runs your code locally.
+
+**Can I read local files?**
+Because this runs in the browser, it cannot read files from your hard drive directly (sandbox security). You should use `st.file_uploader` to let users provide files, or embed data directly into your script.
+
+**Does it support all Python packages?**
+It supports packages available in [Pyodide](https://pyodide.org/en/stable/usage/packages-in-pyodide.html) (including numpy, pandas, scipy, matplotlib, scikit-learn) and pure Python packages from PyPI (micropip).
+
+## 📄 License
+
+MIT License. Feel free to use this for whatever you want!

streamlit2stlite-0.1.0/README.md

@@ -0,0 +1,95 @@
+# 🔦 streamlit2stlite
+
+**Turn your Streamlit apps into standalone HTML files in seconds.**
+
+`streamlit2stlite` is a simple tool that bundles your Streamlit application and all its dependencies into a single HTML file. This file can be opened in any modern browser, running entirely purely on the client side using WebAssembly (via [stlite](https://github.com/whitphx/stlite)). **No server, no hosting costs, no deployment headaches.**
+
+> 💡 Perfect for sharing data dashboards, prototypes, and tools with colleagues or clients who don't have Python installed.
+
+## 🚀 Quick Start
+
+1.  **Install** the tool:
+    ```bash
+    pip install streamlit2stlite
+    ```
+
+2.  **Convert** your app:
+    ```bash
+    streamlit2stlite my_app.py
+    ```
+
+3.  **Open** `my_app.html` in your browser. That's it!
+
+---
+
+## ✨ Features
+
+*   **📦 Auto-Magic Dependency Detection**: Automatically scans your imports to determine which packages to install in the browser (e.g., proper handling of `pandas`, `numpy`, `scipy` for `lmfit`, etc.).
+*   **� LaTeX Support**: Correctly handles backslashes in your math equations so they render perfectly.
+*   **�️ Smart Titles**: Automatically detects your app's title from `st.set_page_config()` or `st.title()`.
+*   **🛠️ Full Control**: Override requirements, titles, or the stlite version via CLI flags if you need to.
+
+## � Usage Guide
+
+### Basic Conversion
+The simplest way to use it. Defaults to creating an HTML file with the same name as your script.
+
+```bash
+streamlit2stlite dashboard.py
+# -> Creates dashboard.html
+```
+
+### Custom Output Name
+Specify exactly where you want the file to go.
+
+```bash
+streamlit2stlite script.py -o ./dist/awesome_dashboard.html
+```
+
+### Managing Dependencies
+We try to guess your dependencies, but sometimes you need to be specific.
+
+**Add extra packages:**
+```bash
+streamlit2stlite app.py --add-requirements "scikit-learn,purple-air"
+```
+
+**Override completely:**
+```bash
+streamlit2stlite app.py --requirements "streamlit,pandas,numpy"
+```
+
+### Full CLI Options
+
+```text
+usage: streamlit2stlite [-h] [-o OUTPUT] [-r REQUIREMENTS] [-t TITLE]
+                        [--stlite-version STLITE_VERSION]
+                        [--add-requirements ADD_REQUIREMENTS] [-v]
+                        input
+
+positional arguments:
+  input                 Path to the input Streamlit Python file
+
+options:
+  -h, --help            show this help message
+  -o, --output          Path to the output HTML file
+  -r, --requirements    Comma-separated list of packages to install
+  -t, --title           Title for the HTML page
+  --add-requirements    Additional packages to add to auto-detected ones
+  -v, --verbose         Print verbose output
+```
+
+## ❓ FAQ
+
+**How does this work?**
+It embeds your Python code into a template that loads `stlite` (a port of Streamlit to WebAssembly). When you open the HTML file, your browser downloads a mini Python environment (Pyodide) and runs your code locally.
+
+**Can I read local files?**
+Because this runs in the browser, it cannot read files from your hard drive directly (sandbox security). You should use `st.file_uploader` to let users provide files, or embed data directly into your script.
+
+**Does it support all Python packages?**
+It supports packages available in [Pyodide](https://pyodide.org/en/stable/usage/packages-in-pyodide.html) (including numpy, pandas, scipy, matplotlib, scikit-learn) and pure Python packages from PyPI (micropip).
+
+## 📄 License
+
+MIT License. Feel free to use this for whatever you want!

streamlit2stlite-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "streamlit2stlite"
+version = "0.1.0"
+description = "Convert Streamlit Python apps to stlite HTML apps"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest"]
+
+[project.scripts]
+streamlit2stlite = "streamlit2stlite.cli:main"
+
+[project.urls]
+"Homepage" = "https://github.com/caggionim/streamlit2stlite"
+"Bug Tracker" = "https://github.com/caggionim/streamlit2stlite/issues"
+
+[tool.setuptools]
+packages = ["streamlit2stlite"]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

streamlit2stlite-0.1.0/setup.cfg

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

streamlit2stlite-0.1.0/streamlit2stlite/__init__.py

@@ -0,0 +1,4 @@
+from .core import convert_streamlit_to_stlite
+from .cli import main
+
+__version__ = "0.1.0"

streamlit2stlite-0.1.0/streamlit2stlite/cli.py

@@ -0,0 +1,152 @@
+import argparse
+import sys
+from pathlib import Path
+from .core import convert_streamlit_to_stlite, extract_imports, STLITE_VERSION
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description='Convert Streamlit Python apps to stlite HTML apps',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  streamlit2stlite my_app.py
+      Converts my_app.py to my_app.html with auto-detected requirements
+
+  streamlit2stlite my_app.py -o output.html
+      Converts my_app.py to output.html
+
+  streamlit2stlite my_app.py --requirements pandas,numpy,plotly
+      Specifies exact requirements to install
+
+  streamlit2stlite my_app.py --title "My Dashboard"
+      Sets a custom page title
+
+  streamlit2stlite my_app.py --stlite-version 0.80.0
+      Uses a specific stlite version
+'''
+    )
+    
+    parser.add_argument(
+        'input',
+        type=str,
+        help='Path to the input Streamlit Python file'
+    )
+    
+    parser.add_argument(
+        '-o', '--output',
+        type=str,
+        default=None,
+        help='Path to the output HTML file (default: same name as input with .html extension)'
+    )
+    
+    parser.add_argument(
+        '-r', '--requirements',
+        type=str,
+        default=None,
+        help='Comma-separated list of pip packages to install (default: auto-detect from imports)'
+    )
+    
+    parser.add_argument(
+        '-t', '--title',
+        type=str,
+        default=None,
+        help='Title for the HTML page (default: auto-detect from code)'
+    )
+    
+    parser.add_argument(
+        '--stlite-version',
+        type=str,
+        default=STLITE_VERSION,
+        help=f'Version of stlite to use (default: {STLITE_VERSION})'
+    )
+    
+    parser.add_argument(
+        '--add-requirements',
+        type=str,
+        default=None,
+        help='Additional requirements to add to auto-detected ones (comma-separated)'
+    )
+    
+    parser.add_argument(
+        '-v', '--verbose',
+        action='store_true',
+        help='Print verbose output'
+    )
+    
+    args = parser.parse_args()
+    
+    # Read input file
+    input_path = Path(args.input)
+    if not input_path.exists():
+        print(f"Error: Input file '{args.input}' not found", file=sys.stderr)
+        sys.exit(1)
+    
+    # Check extension merely as a warning
+    if not input_path.suffix.lower() == '.py':
+        # Just a warning, proceed anyway
+        pass
+    
+    try:
+        python_code = input_path.read_text(encoding='utf-8')
+    except Exception as e:
+        print(f"Error reading input file: {e}", file=sys.stderr)
+        sys.exit(1)
+    
+    # Determine output path
+    if args.output:
+        output_path = Path(args.output)
+    else:
+        output_path = input_path.with_suffix('.html')
+    
+    # Parse requirements
+    requirements = None
+    if args.requirements:
+        requirements = [r.strip() for r in args.requirements.split(',') if r.strip()]
+    
+    # Add additional requirements if specified
+    if args.add_requirements:
+        additional = [r.strip() for r in args.add_requirements.split(',') if r.strip()]
+        if requirements is None:
+            requirements = extract_imports(python_code)
+        requirements = list(set(requirements + additional))
+    
+    # Verbose output
+    if args.verbose:
+        print(f"Input: {input_path}")
+        print(f"Output: {output_path}")
+        if requirements is None:
+            detected_reqs = extract_imports(python_code)
+            print(f"Auto-detected requirements: {detected_reqs}")
+        else:
+            print(f"Using requirements: {requirements}")
+        print(f"stlite version: {args.stlite_version}")
+    
+    # Convert
+    try:
+        html_content = convert_streamlit_to_stlite(
+            python_code=python_code,
+            title=args.title,
+            requirements=requirements,
+            stlite_version=args.stlite_version
+        )
+    except Exception as e:
+        print(f"Error during conversion: {e}", file=sys.stderr)
+        sys.exit(1)
+    
+    # Write output
+    try:
+        output_path.write_text(html_content, encoding='utf-8')
+        print(f"Successfully converted '{input_path}' to '{output_path}'")
+        
+        if args.verbose:
+            # Show final requirements used if we haven't already
+            if requirements is None:
+                 print(f"Final requirements used: {extract_imports(python_code)}")
+            
+    except Exception as e:
+        print(f"Error writing output file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

streamlit2stlite-0.1.0/streamlit2stlite/core.py

@@ -0,0 +1,231 @@
+import re
+from typing import Optional, List, Set, Union
+
+# Default stlite version
+STLITE_VERSION = "1.0.0"
+
+# HTML template header
+HTML_HEADER = '''<!doctype html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, shrink-to-fit=no"
+    />
+    <title>{title}</title>
+    <link
+      rel="stylesheet"
+      href="https://cdn.jsdelivr.net/npm/@stlite/browser@{stlite_version}/build/stlite.css"
+    />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module">
+      import {{ mount }} from "https://cdn.jsdelivr.net/npm/@stlite/browser@{stlite_version}/build/stlite.js";
+
+      // The Streamlit application code is defined here
+      const streamlit_app_code = `'''
+
+# HTML template footer
+HTML_FOOTER = '''`;
+      // Mount the stlite app with the specified requirements and files
+      mount(
+        {{
+          requirements: [{requirements}], // Packages to install
+          entrypoint: "streamlit_app.py", // This field is required
+          files: {{
+            "streamlit_app.py": streamlit_app_code,
+          }},
+        }},
+        document.getElementById("root"),
+      );
+    </script>
+  </body>
+</html>
+'''
+
+
+def escape_for_js_template_literal(python_code: str) -> str:
+    r"""
+    Escape Python code for embedding in a JavaScript template literal.
+    
+    Key transformations:
+    1. Escape backticks (`) as they delimit template literals
+    2. Escape ${} sequences as they are template literal interpolation
+    3. Escape backslashes properly for JavaScript template literals
+    
+    In Python source code:
+    - `\sigma` in source = literal `\sigma` when read
+    - For JS template literal, we need `\\sigma` to represent `\sigma`
+    
+    So when reading a Python file:
+    - Single backslash in the read content needs to become double backslash in JS
+    
+    Args:
+        python_code: The raw Python code to escape
+        
+    Returns:
+        Escaped Python code safe for JS template literal embedding
+    """
+    # First, escape all backslashes for JavaScript template literal
+    # A single backslash in the content needs to be \\ in JS template literal
+    escaped = python_code.replace('\\', '\\\\')
+    
+    # Escape backticks with backslash (they delimit template literals)
+    escaped = escaped.replace('`', '\\`')
+    
+    # Escape template literal interpolation sequences
+    escaped = escaped.replace('${', '\\${')
+    
+    return escaped
+
+
+def extract_imports(python_code: str) -> List[str]:
+    """
+    Extract imported packages from Python code to suggest requirements.
+    
+    Args:
+        python_code: The Python source code
+        
+    Returns:
+        List of package names that should be installed
+    """
+    packages: Set[str] = set()
+    
+    # Common import patterns - extract the top-level package name
+    # Handles: import pkg, import pkg.submodule, from pkg import ..., from pkg.sub import ...
+    import_patterns = [
+        r'^import\s+([\w]+)',              # import package or import package.submodule
+        r'^from\s+([\w]+)(?:\.\w+)*\s+import',  # from package.submodule import ...
+    ]
+    
+    for line in python_code.split('\n'):
+        line = line.strip()
+        for pattern in import_patterns:
+            match = re.match(pattern, line)
+            if match:
+                pkg = match.group(1)
+                # Map common module names to pip package names
+                pkg_mapping = {
+                    'cv2': 'opencv-python',
+                    'sklearn': 'scikit-learn',
+                    'PIL': 'Pillow',
+                    'yaml': 'pyyaml',
+                    'bs4': 'beautifulsoup4',
+                }
+                packages.add(pkg_mapping.get(pkg, pkg))
+    
+    # Remove standard library modules that don't need installation
+    stdlib = {
+        'os', 'sys', 're', 'json', 'datetime', 'time', 'math', 'random',
+        'collections', 'itertools', 'functools', 'operator', 'copy',
+        'io', 'base64', 'hashlib', 'pickle', 'pathlib', 'typing',
+        'abc', 'contextlib', 'dataclasses', 'enum', 'warnings',
+        'threading', 'multiprocessing', 'subprocess', 'socket',
+        'urllib', 'http', 'email', 'html', 'xml', 'csv', 'sqlite3',
+        'logging', 'unittest', 'doctest', 'pdb', 'traceback',
+        'gc', 'inspect', 'importlib', 'pkgutil', 'platform',
+        'struct', 'array', 'decimal', 'fractions', 'statistics',
+        'tempfile', 'shutil', 'glob', 'fnmatch', 'linecache',
+        'textwrap', 'difflib', 'string', 'secrets', 'uuid',
+        'argparse', 'getopt', 'configparser', 'fileinput',
+        'stat', 'filecmp', 'zipfile', 'tarfile', 'gzip', 'bz2', 'lzma',
+        'zlib', 'binascii', 'quopri', 'uu', 'codecs',
+    }
+    
+    # Also remove streamlit since it's built into stlite
+    stdlib.add('streamlit')
+    stdlib.add('st')
+    
+    packages = packages - stdlib
+    
+    # Add common dependencies that aren't directly imported but are needed
+    # These are dependencies of commonly used packages
+    dependency_additions = {
+        'lmfit': ['scipy'],           # lmfit needs scipy
+        'tadatakit': ['pydantic'],    # tadatakit needs pydantic
+        'plotly': [],
+        'pandas': ['xlsxwriter'],
+        'numpy': [],
+        'matplotlib': [],
+    }
+    
+    for pkg in list(packages):
+        if pkg in dependency_additions:
+            packages.update(dependency_additions[pkg])
+    
+    return sorted(list(packages))
+
+
+def detect_title_from_code(python_code: str) -> str:
+    """
+    Try to detect the app title from st.set_page_config or st.title calls.
+    
+    Args:
+        python_code: The Python source code
+        
+    Returns:
+        Detected title or default
+    """
+    # Look for page_title in set_page_config
+    match = re.search(r'page_title\s*=\s*["\']([^"\']+)["\']', python_code)
+    if match:
+        return match.group(1)
+    
+    # Look for st.title
+    match = re.search(r'st\.title\s*\(\s*["\']([^"\']+)["\']', python_code)
+    if match:
+        # Remove emoji prefixes if present
+        title = match.group(1)
+        # Clean up emoji at the start
+        title = re.sub(r'^[^\w\s]+\s*', '', title)
+        return title if title else "Streamlit App"
+    
+    return "Streamlit App"
+
+
+def convert_streamlit_to_stlite(
+    python_code: str,
+    title: Optional[str] = None,
+    requirements: Optional[List[str]] = None,
+    stlite_version: str = STLITE_VERSION
+) -> str:
+    """
+    Convert a Streamlit Python app to an stlite HTML app.
+    
+    Args:
+        python_code: The Streamlit Python source code
+        title: Optional title for the HTML page
+        requirements: Optional list of pip packages to install
+        stlite_version: Version of stlite to use
+        
+    Returns:
+        Complete HTML document with embedded stlite app
+    """
+    # Detect title if not provided
+    if title is None:
+        title = detect_title_from_code(python_code)
+    
+    # Detect requirements if not provided
+    if requirements is None:
+        requirements = extract_imports(python_code)
+    
+    # Escape the Python code for JavaScript template literal
+    escaped_code = escape_for_js_template_literal(python_code)
+    
+    # Format requirements as JavaScript array elements
+    req_str = ', '.join(f'"{pkg}"' for pkg in requirements)
+    
+    # Build the HTML document
+    header = HTML_HEADER.format(
+        title=title,
+        stlite_version=stlite_version
+    )
+    
+    footer = HTML_FOOTER.format(
+        requirements=req_str
+    )
+    
+    return header + escaped_code + footer

streamlit2stlite-0.1.0/streamlit2stlite.egg-info/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: streamlit2stlite
+Version: 0.1.0
+Summary: Convert Streamlit Python apps to stlite HTML apps
+Project-URL: Homepage, https://github.com/caggionim/streamlit2stlite
+Project-URL: Bug Tracker, https://github.com/caggionim/streamlit2stlite/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+# 🔦 streamlit2stlite
+
+**Turn your Streamlit apps into standalone HTML files in seconds.**
+
+`streamlit2stlite` is a simple tool that bundles your Streamlit application and all its dependencies into a single HTML file. This file can be opened in any modern browser, running entirely purely on the client side using WebAssembly (via [stlite](https://github.com/whitphx/stlite)). **No server, no hosting costs, no deployment headaches.**
+
+> 💡 Perfect for sharing data dashboards, prototypes, and tools with colleagues or clients who don't have Python installed.
+
+## 🚀 Quick Start
+
+1.  **Install** the tool:
+    ```bash
+    pip install streamlit2stlite
+    ```
+
+2.  **Convert** your app:
+    ```bash
+    streamlit2stlite my_app.py
+    ```
+
+3.  **Open** `my_app.html` in your browser. That's it!
+
+---
+
+## ✨ Features
+
+*   **📦 Auto-Magic Dependency Detection**: Automatically scans your imports to determine which packages to install in the browser (e.g., proper handling of `pandas`, `numpy`, `scipy` for `lmfit`, etc.).
+*   **� LaTeX Support**: Correctly handles backslashes in your math equations so they render perfectly.
+*   **�️ Smart Titles**: Automatically detects your app's title from `st.set_page_config()` or `st.title()`.
+*   **🛠️ Full Control**: Override requirements, titles, or the stlite version via CLI flags if you need to.
+
+## � Usage Guide
+
+### Basic Conversion
+The simplest way to use it. Defaults to creating an HTML file with the same name as your script.
+
+```bash
+streamlit2stlite dashboard.py
+# -> Creates dashboard.html
+```
+
+### Custom Output Name
+Specify exactly where you want the file to go.
+
+```bash
+streamlit2stlite script.py -o ./dist/awesome_dashboard.html
+```
+
+### Managing Dependencies
+We try to guess your dependencies, but sometimes you need to be specific.
+
+**Add extra packages:**
+```bash
+streamlit2stlite app.py --add-requirements "scikit-learn,purple-air"
+```
+
+**Override completely:**
+```bash
+streamlit2stlite app.py --requirements "streamlit,pandas,numpy"
+```
+
+### Full CLI Options
+
+```text
+usage: streamlit2stlite [-h] [-o OUTPUT] [-r REQUIREMENTS] [-t TITLE]
+                        [--stlite-version STLITE_VERSION]
+                        [--add-requirements ADD_REQUIREMENTS] [-v]
+                        input
+
+positional arguments:
+  input                 Path to the input Streamlit Python file
+
+options:
+  -h, --help            show this help message
+  -o, --output          Path to the output HTML file
+  -r, --requirements    Comma-separated list of packages to install
+  -t, --title           Title for the HTML page
+  --add-requirements    Additional packages to add to auto-detected ones
+  -v, --verbose         Print verbose output
+```
+
+## ❓ FAQ
+
+**How does this work?**
+It embeds your Python code into a template that loads `stlite` (a port of Streamlit to WebAssembly). When you open the HTML file, your browser downloads a mini Python environment (Pyodide) and runs your code locally.
+
+**Can I read local files?**
+Because this runs in the browser, it cannot read files from your hard drive directly (sandbox security). You should use `st.file_uploader` to let users provide files, or embed data directly into your script.
+
+**Does it support all Python packages?**
+It supports packages available in [Pyodide](https://pyodide.org/en/stable/usage/packages-in-pyodide.html) (including numpy, pandas, scipy, matplotlib, scikit-learn) and pure Python packages from PyPI (micropip).
+
+## 📄 License
+
+MIT License. Feel free to use this for whatever you want!

streamlit2stlite-0.1.0/streamlit2stlite.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+streamlit2stlite/__init__.py
+streamlit2stlite/cli.py
+streamlit2stlite/core.py
+streamlit2stlite.egg-info/PKG-INFO
+streamlit2stlite.egg-info/SOURCES.txt
+streamlit2stlite.egg-info/dependency_links.txt
+streamlit2stlite.egg-info/entry_points.txt
+streamlit2stlite.egg-info/requires.txt
+streamlit2stlite.egg-info/top_level.txt
+tests/test_core.py

streamlit2stlite-0.1.0/streamlit2stlite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

streamlit2stlite-0.1.0/streamlit2stlite.egg-info/entry_points.txt

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

streamlit2stlite-0.1.0/streamlit2stlite.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest

streamlit2stlite-0.1.0/streamlit2stlite.egg-info/top_level.txt

@@ -0,0 +1 @@
+streamlit2stlite

streamlit2stlite-0.1.0/tests/test_core.py

@@ -0,0 +1,109 @@
+import pytest
+from streamlit2stlite.core import (
+    escape_for_js_template_literal,
+    extract_imports,
+    detect_title_from_code,
+    convert_streamlit_to_stlite
+)
+
+def test_escape_for_js_template_literal():
+    # Test backslash escaping
+    code = r"print('Hello \n World')"
+    escaped = escape_for_js_template_literal(code)
+    # The result should have double backslashes for the newline char representation in Python string
+    # But effectively passing \\ to JS.
+    # In python string literal r"\\" is actually \
+    assert r"\\" in escaped 
+    
+    # Test backtick escaping
+    code = "print(f`Hello`)"
+    escaped = escape_for_js_template_literal(code)
+    assert r"\`" in escaped
+
+    # Test template interpolation escaping
+    code = "const x = `${variable}`"
+    escaped = escape_for_js_template_literal(code)
+    assert r"\${" in escaped
+    
+    # Combined test
+    code = r"path = 'c:\users\name'"
+    # Expected: c:\\users\\name in the JS string
+    escaped = escape_for_js_template_literal(code)
+    assert r"\\" in escaped
+
+def test_extract_imports():
+    code = """
+import pandas as pd
+import numpy
+from plotly import express
+import cv2
+import os
+import sys
+"""
+    reqs = extract_imports(code)
+    
+    # Check that standard lib is ignored
+    assert "os" not in reqs
+    assert "sys" not in reqs
+    
+    # Check simple imports
+    assert "pandas" in reqs
+    assert "numpy" in reqs
+    
+    # Check from imports
+    assert "plotly" in reqs
+    
+    # Check mapping
+    assert "opencv-python" in reqs
+    assert "cv2" not in reqs
+
+def test_extract_imports_dependencies():
+    code = "import lmfit"
+    reqs = extract_imports(code)
+    assert "lmfit" in reqs
+    assert "scipy" in reqs # lmfit dependency
+
+    # Test pandas -> xlsxwriter
+    code_pandas = "import pandas"
+    reqs_pandas = extract_imports(code_pandas)
+    assert "pandas" in reqs_pandas
+    assert "xlsxwriter" in reqs_pandas
+
+def test_detect_title_from_code():
+    # Test set_page_config
+    code1 = """
+import streamlit as st
+st.set_page_config(page_title="My Cool App")
+"""
+    assert detect_title_from_code(code1) == "My Cool App"
+
+    # Test st.title
+    code2 = """
+import streamlit as st
+st.title("My Title")
+"""
+    assert detect_title_from_code(code2) == "My Title"
+    
+    # Test emoji cleanup
+    code3 = """
+st.title("🚀 Blast Off")
+"""
+    assert detect_title_from_code(code3) == "Blast Off"
+    
+    # Test default
+    code4 = "print('hello')"
+    assert detect_title_from_code(code4) == "Streamlit App"
+
+def test_convert_streamlit_to_stlite():
+    code = "import streamlit as st\nst.write('Hello')"
+    html = convert_streamlit_to_stlite(code, title="Test App")
+    
+    assert "<!doctype html>" in html
+    assert "<title>Test App</title>" in html
+    assert "stlite.js" in html
+    assert "stlite.css" in html
+    assert "streamlit_app_code = `" in html
+    assert "mount(" in html
+    
+    # Check that code is present
+    assert "st.write('Hello')" in html