fastled 1.2.81__py3-none-any.whl → 1.2.83__py3-none-any.whl

fastled/__init__.py

@@ -14,7 +14,7 @@ from .types import BuildMode, CompileResult, CompileServerError, FileResponse
 # IMPORTANT! There's a bug in github which will REJECT any version update
 # that has any other change in the repo. Please bump the version as the
 # ONLY change in a commit, or else the pypi update and the release will fail.
-__version__ = "1.2.81"
+__version__ = "1.2.83"
 
 
 class Api:
@@ -65,6 +65,9 @@ class Api:
         keep_running=True,
         build_mode=BuildMode.QUICK,
         profile=False,
+        http_port: (
+            int | None
+        ) = None,  # None means auto select a free port. -1 means no server.
     ) -> LiveClient:
         return LiveClient(
             sketch_directory=sketch_directory,
@@ -75,6 +78,7 @@ class Api:
             keep_running=keep_running,
             build_mode=build_mode,
             profile=profile,
+            http_port=http_port,
         )
 
     @staticmethod
@@ -197,12 +201,12 @@ class Test:
         compile_server_port: int | None = None,
         open_browser: bool = True,
     ) -> Process:
-        from fastled.open_browser import open_browser_process
+        from fastled.open_browser import spawn_http_server
 
         compile_server_port = compile_server_port or -1
         if isinstance(directory, str):
             directory = Path(directory)
-        proc: Process = open_browser_process(
+        proc: Process = spawn_http_server(
             directory,
             port=port,
             compile_server_port=compile_server_port,

fastled/client_server.py

@@ -2,6 +2,7 @@ import shutil
 import tempfile
 import threading
 import time
+import warnings
 from multiprocessing import Process
 from pathlib import Path
 
@@ -9,7 +10,7 @@ from fastled.compile_server import CompileServer
 from fastled.docker_manager import DockerManager
 from fastled.filewatcher import DebouncedFileWatcherProcess, FileWatcherProcess
 from fastled.keyboard import SpaceBarWatcher
-from fastled.open_browser import open_browser_process
+from fastled.open_browser import spawn_http_server
 from fastled.parse_args import Args
 from fastled.settings import DEFAULT_URL
 from fastled.sketch import looks_like_sketch_directory
@@ -165,6 +166,45 @@ def _try_start_server_or_get_url(
             return (DEFAULT_URL, None)
 
 
+def _try_make_compile_server() -> CompileServer | None:
+    if not DockerManager.is_docker_installed():
+        return None
+    try:
+        print(
+            "\nNo host specified, but Docker is installed, attempting to start a compile server using Docker."
+        )
+        from fastled.util import find_free_port
+
+        free_port = find_free_port(start_port=9723, end_port=9743)
+        if free_port is None:
+            return None
+        compile_server = CompileServer(auto_updates=False)
+        print("Waiting for the local compiler to start...")
+        if not compile_server.ping():
+            print("Failed to start local compiler.")
+            raise CompileServerError("Failed to start local compiler.")
+        return compile_server
+    except KeyboardInterrupt:
+        import _thread
+
+        _thread.interrupt_main()
+        raise
+    except Exception as e:
+        warnings.warn(f"Error starting local compile server: {e}")
+        return None
+
+
+def _is_local_host(host: str) -> bool:
+    return (
+        host.startswith("http://localhost")
+        or host.startswith("http://127.0.0.1")
+        or host.startswith("http://0.0.0.0")
+        or host.startswith("http://[::]")
+        or host.startswith("http://[::1]")
+        or host.startswith("http://[::ffff:127.0.0.1]")
+    )
+
+
 def run_client(
     directory: Path,
     host: str | CompileServer | None,
@@ -173,14 +213,24 @@ def run_client(
     build_mode: BuildMode = BuildMode.QUICK,
     profile: bool = False,
     shutdown: threading.Event | None = None,
+    http_port: (
+        int | None
+    ) = None,  # None means auto select a free port, http_port < 0 means no server.
 ) -> int:
+    compile_server: CompileServer | None = None
+
+    if host is None:
+        # attempt to start a compile server if docker is installed.
+        compile_server = _try_make_compile_server()
+        if compile_server is None:
+            host = DEFAULT_URL
+    elif isinstance(host, CompileServer):
+        # if the host is a compile server, use that
+        compile_server = host
 
-    compile_server: CompileServer | None = (
-        host if isinstance(host, CompileServer) else None
-    )
     shutdown = shutdown or threading.Event()
 
-    def get_url() -> str:
+    def get_url(host=host, compile_server=compile_server) -> str:
         if compile_server is not None:
             return compile_server.url()
         if isinstance(host, str):
@@ -196,6 +246,11 @@ def run_client(
     if parsed_url.port is not None:
         port = parsed_url.port
     else:
+        if _is_local_host(url):
+            raise ValueError(
+                "Cannot use local host without a port. Please specify a port."
+            )
+        # Assume default port for www
         port = 80
 
     try:
@@ -221,10 +276,20 @@ def run_client(
         if not result.success:
             print("\nCompilation failed.")
 
-        browser_proc: Process | None = None
-        if open_web_browser:
-            browser_proc = open_browser_process(
-                directory / "fastled_js", compile_server_port=port
+        use_http_server = http_port is None or http_port >= 0
+        if not use_http_server and open_web_browser:
+            warnings.warn(
+                f"Warning: --http-port={http_port} specified but open_web_browser is False, ignoring --http-port."
+            )
+            use_http_server = False
+
+        http_proc: Process | None = None
+        if use_http_server:
+            http_proc = spawn_http_server(
+                directory / "fastled_js",
+                port=http_port,
+                compile_server_port=port,
+                open_browser=open_web_browser,
             )
         else:
             print("\nCompilation successful.")
@@ -234,8 +299,8 @@ def run_client(
             return 0
 
         if not keep_running or shutdown.is_set():
-            if browser_proc:
-                browser_proc.kill()
+            if http_proc:
+                http_proc.kill()
             return 0 if result.success else 1
     except KeyboardInterrupt:
         print("\nExiting from main")
@@ -346,8 +411,8 @@ def run_client(
         debounced_sketch_watcher.stop()
         if compile_server:
             compile_server.stop()
-        if browser_proc:
-            browser_proc.kill()
+        if http_proc:
+            http_proc.kill()
 
 
 def run_client_server(args: Args) -> int:

fastled/compile_server_impl.py

@@ -18,6 +18,7 @@ from fastled.docker_manager import (
 from fastled.settings import DEFAULT_CONTAINER_NAME, IMAGE_NAME, SERVER_PORT
 from fastled.sketch import looks_like_fastled_repo
 from fastled.types import BuildMode, CompileResult, CompileServerError, FileResponse
+from fastled.util import port_is_free
 
 SERVER_OPTIONS = [
     "--allow-shutdown",  # Allow the server to be shut down without a force kill.
@@ -36,32 +37,6 @@ def _try_get_fastled_src(path: Path) -> Path | None:
     return None
 
 
-def _port_is_free(port: int) -> bool:
-    """Check if a port is free."""
-    import socket
-
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-        try:
-            _ = sock.bind(("localhost", port)) and sock.bind(("0.0.0.0", port))
-            return True
-        except OSError:
-            return False
-
-
-def _find_free_port() -> int:
-    """Find a free port on the system."""
-
-    start_port = 49152
-    tries = 10
-
-    for port in range(start_port, start_port + tries):
-        if _port_is_free(port):
-            return port
-    raise RuntimeError(
-        f"No free port found in the range {start_port}-{start_port + tries - 1}"
-    )
-
-
 class CompileServerImpl:
     def __init__(
         self,
@@ -250,7 +225,7 @@ class CompileServerImpl:
             image_name=IMAGE_NAME, tag="latest", upgrade=upgrade
         )
         DISK_CACHE.put("last-update", now_str)
-        CLIENT_PORT = 80  # TODO: Don't use port 80.
+        INTERNAL_DOCKER_PORT = 80
 
         print("Docker image now validated")
         port = SERVER_PORT
@@ -262,7 +237,7 @@ class CompileServerImpl:
             print("Disabling port forwarding in interactive mode")
             ports = {}
         else:
-            ports = {CLIENT_PORT: port}
+            ports = {INTERNAL_DOCKER_PORT: port}
         volumes = []
         if self.fastled_src_dir:
             print(
@@ -341,11 +316,11 @@ class CompileServerImpl:
             print("Compile server starting")
             return port
         else:
-            client_port_mapped = CLIENT_PORT in ports
-            port_is_free = _port_is_free(CLIENT_PORT)
-            if client_port_mapped and port_is_free:
+            client_port_mapped = INTERNAL_DOCKER_PORT in ports
+            free_port = port_is_free(INTERNAL_DOCKER_PORT)
+            if client_port_mapped and free_port:
                 warnings.warn(
-                    f"Can't expose port {CLIENT_PORT}, disabling port forwarding in interactive mode"
+                    f"Can't expose port {INTERNAL_DOCKER_PORT}, disabling port forwarding in interactive mode"
                 )
                 ports = {}
             self.docker.run_container_interactive(

fastled/live_client.py

@@ -16,6 +16,9 @@ class LiveClient:
         auto_start: bool = True,
         auto_updates: bool = True,
         open_web_browser: bool = True,
+        http_port: (
+            int | None
+        ) = None,  # None means auto select a free port. -1 means no server.
         keep_running: bool = True,
         build_mode: BuildMode = BuildMode.QUICK,
         profile: bool = False,
@@ -23,6 +26,7 @@ class LiveClient:
         self.sketch_directory = sketch_directory
         self.host = host
         self.open_web_browser = open_web_browser
+        self.http_port = http_port
         self.keep_running = keep_running
         self.build_mode = build_mode
         self.profile = profile
@@ -47,6 +51,7 @@ class LiveClient:
             build_mode=self.build_mode,
             profile=self.profile,
             shutdown=self.shutdown,
+            http_port=self.http_port,
         )
         return rtn
 

fastled/open_browser.py

@@ -1,51 +1,36 @@
-import subprocess
+import atexit
+import random
 import sys
 import time
+import weakref
 from multiprocessing import Process
 from pathlib import Path
 
-from fastled.keyz import get_ssl_config
+from fastled.server_flask import run_flask_in_thread
 
 DEFAULT_PORT = 8089  # different than live version.
 PYTHON_EXE = sys.executable
 
+# Use a weak reference set to track processes without preventing garbage collection
+_WEAK_CLEANUP_SET = weakref.WeakSet()
 
-# print(f"SSL Config: {SSL_CONFIG.certfile}, {SSL_CONFIG.keyfile}")
 
+def add_cleanup(proc: Process) -> None:
+    """Add a process to the cleanup list using weak references"""
+    _WEAK_CLEANUP_SET.add(proc)
 
-def _open_http_server_subprocess(
-    fastled_js: Path, port: int, compile_server_port: int
-) -> None:
-    print("\n################################################################")
-    print(f"# Opening browser to {fastled_js} on port {port}")
-    print("################################################################\n")
-    ssl = get_ssl_config()
-    try:
-        # Fallback to our Python server
-        cmd = [
-            PYTHON_EXE,
-            "-m",
-            "fastled.server_start",
-            str(fastled_js),
-            "--port",
-            str(port),
-            "--compile-server-port",
-            str(compile_server_port),
-        ]
-        # Pass SSL flags if available
-        if ssl:
-            raise NotImplementedError("SSL is not implemented yet")
-        print(f"Running server on port {port}.")
-        print(f"Command: {subprocess.list2cmdline(cmd)}")
-        # Suppress output
-        subprocess.run(
-            cmd,
-            stdout=subprocess.DEVNULL,
-            # stderr=subprocess.DEVNULL,
-        )  # type ignore
-    except KeyboardInterrupt:
-        print("Exiting from server...")
-        sys.exit(0)
+    # Register a cleanup function that checks if the process is still alive
+    def cleanup_if_alive():
+        if proc.is_alive():
+            try:
+                proc.terminate()
+                proc.join(timeout=1.0)
+                if proc.is_alive():
+                    proc.kill()
+            except Exception:
+                pass
+
+    atexit.register(cleanup_if_alive)
 
 
 def is_port_free(port: int) -> bool:
@@ -88,7 +73,7 @@ def wait_for_server(port: int, timeout: int = 10) -> None:
     raise TimeoutError("Could not connect to server")
 
 
-def open_browser_process(
+def spawn_http_server(
     fastled_js: Path,
     compile_server_port: int,
     port: int | None = None,
@@ -98,14 +83,26 @@ def open_browser_process(
     if port is not None and not is_port_free(port):
         raise ValueError(f"Port {port} was specified but in use")
     if port is None:
-        port = find_free_port(DEFAULT_PORT)
+        offset = random.randint(0, 100)
+        port = find_free_port(DEFAULT_PORT + offset)
+
+    # port: int,
+    # cwd: Path,
+    # compile_server_port: int,
+    # certfile: Path | None = None,
+    # keyfile: Path | None = None,
 
     proc = Process(
-        target=_open_http_server_subprocess,
-        args=(fastled_js, port, compile_server_port),
+        target=run_flask_in_thread,
+        args=(port, fastled_js, compile_server_port),
         daemon=True,
     )
+    add_cleanup(proc)
     proc.start()
+
+    # Add to cleanup set with weak reference
+    add_cleanup(proc)
+
     wait_for_server(port)
     if open_browser:
         print(f"Opening browser to http://localhost:{port}")
@@ -136,5 +133,5 @@ if __name__ == "__main__":
     )
     args = parser.parse_args()
 
-    proc = open_browser_process(args.fastled_js, args.port, open_browser=True)
+    proc = spawn_http_server(args.fastled_js, args.port, open_browser=True)
     proc.join()

fastled/server_flask.py

@@ -5,6 +5,8 @@ from pathlib import Path
 import requests
 from livereload import Server
 
+_DRAWF_SOURCE_PREFIX = "drawfsource/js/fastled/src/"
+
 
 def _run_flask_server(
     fastled_js: Path,
@@ -22,7 +24,7 @@ def _run_flask_server(
         keyfile: Path to the SSL key file
     """
     try:
-        from flask import Flask, send_from_directory
+        from flask import Flask, Response, send_from_directory
 
         app = Flask(__name__)
 
@@ -35,13 +37,78 @@ def _run_flask_server(
         def serve_index():
             return send_from_directory(fastled_js, "index.html")
 
-        @app.route("/static/<path:path>")
-        def proxy_static(path):
-            """Proxy requests to /static/* to the compile server"""
+        @app.route("/sourcefiles/<path:path>")
+        def serve_source_files(path):
+            """Proxy requests to /sourcefiles/* to the compile server"""
+            from flask import request
+
+            # Forward the request to the compile server
+            target_url = f"http://localhost:{compile_server_port}/sourcefiles/{path}"
+
+            # Forward the request with the same method, headers, and body
+            resp = requests.request(
+                method=request.method,
+                url=target_url,
+                headers={key: value for key, value in request.headers if key != "Host"},
+                data=request.get_data(),
+                cookies=request.cookies,
+                allow_redirects=True,
+                stream=False,
+            )
+
+            # Create a Flask Response object from the requests response
+            response = Response(
+                resp.raw.read(), status=resp.status_code, headers=dict(resp.headers)
+            )
+
+            return response
+
+        def handle_dwarfsource(path: str) -> Response:
+            """Handle requests to /drawfsource/js/fastled/src/"""
+            from flask import request
+
+            print("\n##################################")
+            print(f"# Serving source file /drawfsource/ {path}")
+            print("##################################\n")
+
+            if not path.startswith(_DRAWF_SOURCE_PREFIX):
+                # unexpected
+                print(f"Unexpected path: {path}")
+                return Response("Malformed path", status=400)
+
+            path = path.replace("drawfsource/js/fastled/src/", "")
+
+            # Forward the request to the compile server
+            target_url = f"http://localhost:{compile_server_port}/sourcefiles/{path}"
+
+            # Forward the request with the same method, headers, and body
+            resp = requests.request(
+                method=request.method,
+                url=target_url,
+                headers={key: value for key, value in request.headers if key != "Host"},
+                data=request.get_data(),
+                cookies=request.cookies,
+                allow_redirects=True,
+                stream=False,
+            )
+
+            # Create a Flask Response object from the requests response
+            response = Response(
+                resp.raw.read(), status=resp.status_code, headers=dict(resp.headers)
+            )
+
+            return response
+
+        def handle_sourcefile(path: str) -> Response:
+            """Handle requests to /sourcefiles/*"""
             from flask import Response, request
 
+            print("\n##################################")
+            print(f"# Serving source file /sourcefiles/ {path}")
+            print("##################################\n")
+
             # Forward the request to the compile server
-            target_url = f"http://localhost:{compile_server_port}/static/{path}"
+            target_url = f"http://localhost:{compile_server_port}/sourcefiles/{path}"
 
             # Forward the request with the same method, headers, and body
             resp = requests.request(
@@ -61,8 +128,12 @@ def _run_flask_server(
 
             return response
 
-        @app.route("/<path:path>")
-        def serve_files(path):
+        def handle_local_file_fetch(path: str) -> Response:
+
+            print("\n##################################")
+            print(f"# Servering generic file {path}")
+            print("##################################\n")
+
             response = send_from_directory(fastled_js, path)
             # Some servers don't set the Content-Type header for a bunch of files.
             if path.endswith(".js"):
@@ -94,6 +165,16 @@ def _run_flask_server(
             response.headers["Expires"] = "0"
             return response
 
+        @app.route("/<path:path>")
+        def serve_files(path: str):
+
+            if path.startswith("drawfsource/"):
+                return handle_dwarfsource(path)
+            elif path.startswith("sourcefiles/"):
+                return handle_sourcefile(path)
+            else:
+                return handle_local_file_fetch(path)
+
         server = Server(app.wsgi_app)
         # Watch index.html for changes
         server.watch(str(fastled_js / "index.html"))
@@ -112,7 +193,7 @@ def _run_flask_server(
         _thread.interrupt_main()
 
 
-def run(
+def run_flask_in_thread(
     port: int,
     cwd: Path,
     compile_server_port: int,
@@ -169,7 +250,7 @@ def run_flask_server_process(
 ) -> Process:
     """Run the Flask server in a separate process."""
     process = Process(
-        target=run,
+        target=run_flask_in_thread,
         args=(port, cwd, compile_server_port, certfile, keyfile),
     )
     process.start()
@@ -179,7 +260,7 @@ def run_flask_server_process(
 def main() -> None:
     """Main function."""
     args = parse_args()
-    run(args.port, args.fastled_js, args.certfile, args.keyfile)
+    run_flask_in_thread(args.port, args.fastled_js, args.certfile, args.keyfile)
 
 
 if __name__ == "__main__":

fastled/server_start.py

@@ -1,145 +1,21 @@
-import argparse
-import importlib.resources as pkg_resources
-from dataclasses import dataclass
-from multiprocessing import Process
 from pathlib import Path
 
-from fastled.server_fastapi_cli import run_fastapi_server_process
-from fastled.server_flask import run_flask_server_process
+from fastled.server_flask import run_flask_in_thread
 
 
-def run_server_process(
+def start_server_in_thread(
     port: int,
-    cwd: Path,
+    fastled_js: Path,
     compile_server_port: int,
     certfile: Path | None = None,
     keyfile: Path | None = None,
-) -> Process:
-    """Run the server in a separate process."""
-    if True:
-        # Use Flask server
-        process = run_flask_server_process(
-            port=port,
-            cwd=cwd,
-            compile_server_port=compile_server_port,
-            certfile=certfile,
-            keyfile=keyfile,
-        )
-    else:
-        # Use FastAPI server
-        process = run_fastapi_server_process(
-            port=port,
-            cwd=cwd,
-            certfile=certfile,
-            keyfile=keyfile,
-        )
-    return process
+) -> None:
+    """Start the server in a separate thread."""
 
-
-def get_asset_path(filename: str) -> Path | None:
-    """Locate a file from the fastled.assets package resources."""
-    try:
-        resource = pkg_resources.files("fastled.assets").joinpath(filename)
-        # Convert to Path for file-system access
-        path = Path(str(resource))
-        return path if path.exists() else None
-    except (ModuleNotFoundError, AttributeError):
-        return None
-
-
-def start_process(
-    path: Path,
-    port: int,
-    compile_server_port: int,
-    certfile: Path | None = None,  # reserved for future use
-    keyfile: Path | None = None,  # reserved for future use
-) -> Process:
-    """Run the server, using package assets if explicit paths are not provided"""
-    # Use package resources if no explicit path
-
-    # _run_flask_server(path, port, certfile, keyfile)
-    # run_fastapi_server_process(port=port, path=path, certfile=certfile, keyfile=keyfile)
-    proc = run_server_process(
-        port=port, cwd=path, compile_server_port=compile_server_port
-    )
-    # try:
-    #     proc.join()
-    # except KeyboardInterrupt:
-    #     import _thread
-
-    #     _thread.interrupt_main()
-    return proc
-
-
-@dataclass
-class Args:
-    fastled_js: Path
-    port: int
-    compile_server_port: int
-    cert: Path | None
-    key: Path | None
-
-
-def parse_args() -> Args:
-    parser = argparse.ArgumentParser(
-        description="Open a browser to the fastled_js directory"
-    )
-    parser.add_argument(
-        "fastled_js", type=Path, help="Path to the fastled_js directory"
-    )
-    parser.add_argument(
-        "--port",
-        "-p",
-        type=int,
-        default=5500,
-        help="Port to run the server on (default: 5500)",
-    )
-    parser.add_argument(
-        "--compile-server-port",
-        type=int,
-        required=True,
-        help="Used to forward requests to the compile server",
-    )
-    parser.add_argument(
-        "--cert", type=Path, help="(Optional) Path to SSL certificate (PEM format)"
-    )
-    parser.add_argument(
-        "--key", type=Path, help="(Optional) Path to SSL private key (PEM format)"
-    )
-    args = parser.parse_args()
-    out: Args = Args(
-        fastled_js=args.fastled_js,
-        port=args.port,
-        compile_server_port=args.compile_server_port,
-        cert=args.cert,
-        key=args.key,
-    )
-    if args.fastled_js is None:
-        raise ValueError("fastled_js directory is required")
-    return out
-
-
-def main() -> None:
-    args: Args = parse_args()
-    fastled_js: Path = args.fastled_js
-    port: int = args.port
-    cert: Path | None = args.cert
-    key: Path | None = args.key
-    proc = start_process(
-        path=fastled_js,
+    run_flask_in_thread(
         port=port,
-        compile_server_port=args.compile_server_port,
-        certfile=cert,
-        keyfile=key,
+        cwd=fastled_js,
+        compile_server_port=compile_server_port,
+        certfile=certfile,
+        keyfile=keyfile,
     )
-    try:
-        proc.join()
-    except KeyboardInterrupt:
-        import _thread
-
-        _thread.interrupt_main()
-        pass
-
-
-if __name__ == "__main__":
-    main()

fastled/util.py

@@ -17,3 +17,29 @@ def banner_string(msg: str) -> str:
     """
     border = "#" * (len(msg) + 4)
     return f"\n{border}\n# {msg}\n{border}\n"
+
+
+def port_is_free(port: int) -> bool:
+    """Check if a port is free."""
+    import socket
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        try:
+            _ = sock.bind(("localhost", port)) and sock.bind(("0.0.0.0", port))
+            return True
+        except OSError:
+            return False
+
+
+def find_free_port(start_port: int, end_port: int) -> int | None:
+    """Find a free port on the system."""
+
+    for port in range(start_port, end_port):
+        if port_is_free(port):
+            return port
+    import warnings
+
+    warnings.warn(
+        f"No free port found in the range {start_port}-{end_port}. Using {start_port}."
+    )
+    return None

{fastled-1.2.81.dist-info → fastled-1.2.83.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.2.81
+Version: 1.2.83
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -13,15 +13,11 @@ License-File: LICENSE
 Requires-Dist: docker>=7.1.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: watchdog>=6.0.0
-Requires-Dist: download>=0.3.5
 Requires-Dist: filelock>=3.16.1
 Requires-Dist: disklru>=2.0.1
 Requires-Dist: appdirs>=1.4.4
 Requires-Dist: rapidfuzz>=3.10.1
 Requires-Dist: progress>=1.6
-Requires-Dist: fastapi>=0.115.12
-Requires-Dist: uvicorn>=0.34.2
-Requires-Dist: pywebview>=5.4
 Requires-Dist: watchfiles>=1.0.5
 Requires-Dist: Flask>=3.0.0
 Requires-Dist: livereload

{fastled-1.2.81.dist-info → fastled-1.2.83.dist-info}/RECORD

@@ -1,32 +1,30 @@
-fastled/__init__.py,sha256=E0yN78HV0eXNtDsCcsGLoJTTdhAaXlsN6B17h7nzmjc,6896
+fastled/__init__.py,sha256=GFW1WwdYsAv_gygWIQ047oPRT6sjzh7WgDAYVNyInSo,7044
 fastled/app.py,sha256=0W8Mbplo5UCRzj7nMVgkmCBddQGufsUQjkUUT4pMp74,4611
 fastled/cli.py,sha256=FjVr31ht0UPlAcmX-84NwfAGMQHTkrCe4o744jCAxiw,375
 fastled/cli_test.py,sha256=qJB9yLRFR3OwOwdIWSQ0fQsWLnA37v5pDccufiP_hTs,512
 fastled/cli_test_interactive.py,sha256=BjNhveZOk5aCffHbcrxPQQjWmAuj4ClVKKcKX5eY6yM,542
-fastled/client_server.py,sha256=zQF4ioOkQzHkKAP0A-8mqjVt8aGD9Sj9ijmknsdLW0U,14859
+fastled/client_server.py,sha256=xQIWJEejZtafCnO2fnO4k_owIzPydvXpEJTjVHpzMlA,17183
 fastled/compile_server.py,sha256=sRiXYzw7lv9vcWJWGPUkzOGZPmvZGV_TGwbHYoRc15s,3155
-fastled/compile_server_impl.py,sha256=0xWJg5b6n_Y-BKPI2ToG4bT7bB_ZuGNQy45JjyJDg6o,13659
+fastled/compile_server_impl.py,sha256=t7y19DDB0auH1MmYLCi4yjc_ZyDUJ-WHy14QWTJ-pq8,13043
 fastled/docker_manager.py,sha256=SC_qV6grNTGh0QD1ubKrULQblrN-2PORocISlaZg9NQ,35156
 fastled/filewatcher.py,sha256=3qS3L7zMQhFuVrkeGn1djsB_cB6x_E2YGJmmQWVAU_w,10033
 fastled/keyboard.py,sha256=UTAsqCn1UMYnB8YDzENiLTj4GeL45tYfEcO7_5fLFEg,3556
 fastled/keyz.py,sha256=LO-8m_7CpNDiZLM-FXhQ30f9gN1bUYz5lOsUPTIbI-c,4020
-fastled/live_client.py,sha256=MDauol0mxtXggV1Pv9ahC0Jjg_4wnnV6FjGEtdd9cxU,2763
-fastled/open_browser.py,sha256=6Iu1hVve0g1Hy4L0DcInmZJfeMM5-Dqcwlv9UqfCtCg,3983
+fastled/live_client.py,sha256=yoAul8tVgbbPf1oEC79SUZSHkLECxlrXxgWR9XaBIp4,2957
+fastled/open_browser.py,sha256=DFyMrc1qic4Go7eLNPqMaLuMvTaE73NixdfSKV0yyp8,3709
 fastled/parse_args.py,sha256=waNeATOEz8D50Py5-9p6HcVSa21piTOAWOXS3ag8PYo,9428
 fastled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
 fastled/print_filter.py,sha256=ZpebuqfWEraSBD3Dm0PVZhQVBnU_NSILniwBHwjC1qM,2342
 fastled/project_init.py,sha256=bBt4DwmW5hZkm9ICt9Qk-0Nr_0JQM7icCgH5Iv-bCQs,3984
 fastled/select_sketch_directory.py,sha256=-eudwCns3AKj4HuHtSkZAFwbnf005SNL07pOzs9VxnE,1383
-fastled/server_fastapi.py,sha256=ytsL4poO-yugDIhvYJq6nCNdLZ4fQJ1AFqXkF-uEkqo,1488
-fastled/server_fastapi_cli.py,sha256=fJGLvbJx5ertsZER_lgg0GfkYTX-V2rxzbNO1lEapU0,1392
-fastled/server_flask.py,sha256=Temr1H-JXMOo0KGOs21BYRz0F7shH6Dsh_7T_bVRpsM,5851
-fastled/server_start.py,sha256=muMreRRYvjme-gETWDWzmT4mRGAXpDJkFy_oJ0lJZFY,3895
+fastled/server_flask.py,sha256=qPY72qJ4qOI3Llj3VG0CGvEnJ0ibMcprykAG6o9Sexk,9050
+fastled/server_start.py,sha256=W9yKStkRlRNuXeV6j_6O7HjjFPyVLBHMcF9Uy2QjDWQ,479
 fastled/settings.py,sha256=oezRvRUJWwauO-kpC4LDbKg6Q-ij4d09UtR2vkjSAPU,575
 fastled/sketch.py,sha256=tHckjDj8P6BI_LWzUFM071a9qcqPs-r-qFWIe50P5Xw,3391
 fastled/spinner.py,sha256=VHxmvB92P0Z_zYxRajb5HiNmkHHvZ5dG7hKtZltzpcs,867
 fastled/string_diff.py,sha256=NbtYxvBFxTUdmTpMLizlgZj2ULJ-7etj72GBdWDTGws,2496
 fastled/types.py,sha256=k1j1y5h1zpRonp1mqRXy797mSbLqzf5K1QEgl8f27jQ,4822
-fastled/util.py,sha256=17f2A52TfBErJOEGC_Vs72t1mTDocLVTfnR9hWbXW8A,501
+fastled/util.py,sha256=hw3gxS1qGc5LL_QN88_VIjut6T0-61ImDQpxGp11DXY,1189
 fastled/web_compile.py,sha256=QTYHtcm55zsFxPhdA-qSPfL5Q4lhL3h3oNmir3m-Y3s,11345
 fastled/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
 fastled/assets/localhost-key.pem,sha256=Q-CNO_UoOd8fFNN4ljcnqwUeCMhzTplRjLO2x0pYRlU,1704
@@ -35,9 +33,9 @@ fastled/site/build.py,sha256=2YKU_UWKlJdGnjdbAbaL0co6kceFMSTVYwH1KCmgPZA,13987
 fastled/site/examples.py,sha256=s6vj2zJc6BfKlnbwXr1QWY1mzuDBMt6j5MEBOWjO_U8,155
 fastled/test/can_run_local_docker_tests.py,sha256=LEuUbHctRhNNFWcvnz2kEGmjDJeXO4c3kNpizm3yVJs,400
 fastled/test/examples.py,sha256=GfaHeY1E8izBl6ZqDVjz--RHLyVR4NRnQ5pBesCFJFY,1673
-fastled-1.2.81.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-fastled-1.2.81.dist-info/METADATA,sha256=dJ5jrJBU_ZPYVPE9HHC6S_61BN3-PxC297TXvEpYorc,22065
-fastled-1.2.81.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-fastled-1.2.81.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
-fastled-1.2.81.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
-fastled-1.2.81.dist-info/RECORD,,
+fastled-1.2.83.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.2.83.dist-info/METADATA,sha256=XPce-fPL-Jl0e7rpYRuf-JHiyIJZe44nZiARcxX4S8c,21940
+fastled-1.2.83.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+fastled-1.2.83.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.2.83.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
+fastled-1.2.83.dist-info/RECORD,,

fastled/server_fastapi.py

@@ -1,60 +0,0 @@
-from pathlib import Path
-
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import FileResponse
-
-# your existing MIME mapping, e.g.
-MAPPING = {
-    "js": "application/javascript",
-    "css": "text/css",
-    "wasm": "application/wasm",
-    "json": "application/json",
-    "png": "image/png",
-    "jpg": "image/jpeg",
-    "jpeg": "image/jpeg",
-    "gif": "image/gif",
-    "svg": "image/svg+xml",
-    "ico": "image/x-icon",
-    "html": "text/html",
-}
-
-
-"""Run FastAPI server with live reload or HTTPS depending on args."""
-app = FastAPI(debug=True)
-base = Path(".")
-
-
-def no_cache_headers() -> dict[str, str]:
-    return {
-        "Cache-Control": "no-cache, no-store, must-revalidate",
-        "Pragma": "no-cache",
-        "Expires": "0",
-    }
-
-
-@app.get("/")
-async def serve_index():
-    index_path = base / "index.html"
-    if not index_path.exists():
-        raise HTTPException(status_code=404, detail="index.html not found")
-    return FileResponse(
-        index_path,
-        media_type=MAPPING.get("html"),
-        headers=no_cache_headers(),
-    )
-
-
-@app.get("/{path:path}")
-async def serve_files(path: str):
-    file_path = base / path
-    if not file_path.exists() or not file_path.is_file():
-        raise HTTPException(status_code=404, detail=f"{path} not found")
-
-    ext = path.rsplit(".", 1)[-1].lower()
-    media_type = MAPPING.get(ext)
-
-    return FileResponse(
-        file_path,
-        media_type=media_type,
-        headers=no_cache_headers(),
-    )

fastled/server_fastapi_cli.py

@@ -1,61 +0,0 @@
-from multiprocessing import Process
-from pathlib import Path
-
-import uvicorn
-
-# MAPPING = {
-#     "js": "application/javascript",
-#     "css": "text/css",
-#     "wasm": "application/wasm",
-#     "json": "application/json",
-#     "png": "image/png",
-#     "jpg": "image/jpeg",
-#     "jpeg": "image/jpeg",
-#     "gif": "image/gif",
-#     "svg": "image/svg+xml",
-#     "ico": "image/x-icon",
-#     "html": "text/html",
-# }
-
-
-def _run_fastapi_server(
-    port: int,
-    cwd: Path,
-    certfile: Path | None = None,
-    keyfile: Path | None = None,
-) -> None:
-    # Uvicorn “reload” will watch your Python files for changes.
-    import os
-
-    os.chdir(cwd)
-    uvicorn.run(
-        "fastled.server_fastapi:app",
-        host="127.0.0.1",
-        port=port,
-        reload=False,
-        # reload_includes=["index.html"],
-        ssl_certfile=certfile,
-        ssl_keyfile=keyfile,
-    )
-
-
-def run_fastapi_server_process(
-    port: int,
-    cwd: Path | None = None,
-    certfile: Path | None = None,
-    keyfile: Path | None = None,
-) -> Process:
-    """Run the FastAPI server in a separate process."""
-    cwd = cwd or Path(".")
-    process = Process(
-        target=_run_fastapi_server,
-        args=(port, cwd, certfile, keyfile),
-    )
-    process.start()
-    return process
-
-
-if __name__ == "__main__":
-    # Example usage
-    proc = run_fastapi_server_process(port=8000)
-    proc.join()