fastled 1.2.79__tar.gz → 1.2.80__tar.gz

{fastled-1.2.79 → fastled-1.2.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.2.79
+Version: 1.2.80
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies

{fastled-1.2.79 → fastled-1.2.80}/compiler/compile.py

@@ -21,6 +21,7 @@ import shutil  # noqa: E402
 import subprocess  # noqa: E402
 import sys  # noqa: E402
 import traceback  # noqa: E402
+import warnings  # noqa: E402
 from dataclasses import dataclass  # noqa: E402
 from datetime import datetime  # noqa: E402
 from enum import Enum  # noqa: E402
@@ -51,10 +52,7 @@ _FILE_EXTENSIONS = [".ino", ".h", ".hpp", ".cpp"]
 _FASTLED_OUTPUT_DIR_NAME = "fastled_js"
 
 
-@dataclass
-class DateLine:
-    dt: datetime
-    line: str
+# DateLine class removed as it's no longer needed with streaming timestamps
 
 
 class BuildMode(Enum):
@@ -87,6 +85,8 @@ def copy_files(src_dir: Path, js_src: Path) -> None:
         else:
             print(f"Copying file: {item}")
             shutil.copy2(item, js_src / item.name)
+    else:
+        warnings.warn("No files found in the mapped directory.")
 
 
 def _banner(msg: str) -> str:
@@ -172,19 +172,23 @@ def compile(
         )
         return out
 
-    output_lines = []
     for attempt in range(1, max_attempts + 1):
         try:
             print(f"Attempting compilation (attempt {attempt}/{max_attempts})...")
             process = _open_process()
             assert process.stdout is not None
+
+            # Create a new timestamper for this compilation attempt
+            timestamper = StreamingTimestamper()
+
+            # Process and print each line as it comes in with relative timestamp
             line: str
             for line in process.stdout:
-                timestamped_line = _timestamp_output(line)
-                output_lines.append(timestamped_line)
+                timestamped_line = timestamper.timestamp_line(line)
+                print(timestamped_line)
+
             process.wait()
-            relative_output = _make_timestamps_relative("\n".join(output_lines))
-            _chunked_print(relative_output)
+
             if process.returncode == 0:
                 print(_banner(f"Compilation successful on attempt {attempt}"))
                 return 0
@@ -264,51 +268,25 @@ def process_ino_files(src_dir: Path) -> None:
     print(_banner("Transform to cpp and insert header operations completed."))
 
 
-def _make_timestamps_relative(stdout: str) -> str:
-    def parse(line: str) -> DateLine:
-        parts = line.split(" ")
-        if len(parts) < 2:
-            raise ValueError(f"Invalid line: {line}")
-
-        date_str, time_str = parts[:2]
-        rest = " ".join(parts[2:])
-        # Parse with microsecond precision
-        dt = datetime.strptime(f"{date_str} {time_str}", "%Y-%m-%d %H:%M:%S.%f")
-        return DateLine(dt, rest)
-
-    lines = stdout.split("\n")
-    if not lines:
-        return stdout
-    parsed: list[DateLine] = []
-    for line in lines:
-        if not line.strip():  # Skip empty lines
-            continue
-        try:
-            parsed.append(parse(line))
-        except ValueError:
-            print(f"Failed to parse line: {line}")
-            continue
-
-    if not parsed:
-        return stdout
+class StreamingTimestamper:
+    """
+    A class that provides streaming relative timestamps for output lines.
+    Instead of processing all lines at the end, this timestamps each line
+    as it's received with a relative time from when the object was created.
+    """
 
-    outlines: list[str] = []
-    start_time = parsed[0].dt
+    def __init__(self):
+        self.start_time = datetime.now()
 
-    # Calculate relative times with
-    for p in parsed:
-        delta = p.dt - start_time
+    def timestamp_line(self, line: str) -> str:
+        """
+        Add a relative timestamp to a line of text.
+        The timestamp shows seconds elapsed since the StreamingTimestamper was created.
+        """
+        now = datetime.now()
+        delta = now - self.start_time
         seconds = delta.total_seconds()
-        line_str = f"{seconds:3.2f} {p.line}"
-        outlines.append(line_str)
-
-    return "\n".join(outlines)
-
-
-def _timestamp_output(line: str) -> str:
-    now = datetime.now()
-    timestamp = now.strftime("%Y-%m-%d %H:%M:%S.%f")
-    return f"{timestamp} {line.rstrip()}"
+        return f"{seconds:3.2f} {line.rstrip()}"
 
 
 @dataclass

fastled-1.2.80/compiler/debug.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+# Run this when you want to debug the compiler and you are in interactive
+# mode at /js
+
+python compile.py --debug --keep

{fastled-1.2.79 → fastled-1.2.80}/compiler/init_runtime.py

@@ -9,10 +9,13 @@ COMPILER_DIR = COMPILER_ROOT / "compiler"
 
 SRC_MAPPED_HOST_COMPLER_DIR = Path("/host/fastled/src/platforms/wasm/compiler")
 if SRC_MAPPED_HOST_COMPLER_DIR.exists():
+    print(f"Using mapped host compiler directory: {SRC_MAPPED_HOST_COMPLER_DIR}")
     FASTLED_COMPILER_DIR = SRC_MAPPED_HOST_COMPLER_DIR
 else:
+    print(f"Using standard host compiler directory: {SRC_MAPPED_HOST_COMPLER_DIR}")
     FASTLED_COMPILER_DIR = COMPILER_ROOT / "fastled/src/platforms/wasm/compiler"
 
+
 HERE = Path(__file__).parent
 
 

{fastled-1.2.79 → fastled-1.2.80}/compiler/paths.py

@@ -4,11 +4,12 @@ UPLOAD_DIR = Path("/uploads")
 TEMP_DIR = Path("/tmp")
 OUTPUT_DIR = Path("/output")
 
-
 COMPILER_ROOT = Path("/js")
+FASTLED_SRC = COMPILER_ROOT / "fastled" / "src"
+
+
 SKETCH_SRC = COMPILER_ROOT / "src"
 VOLUME_MAPPED_SRC = Path("/host/fastled/src")
-RSYNC_DEST = COMPILER_ROOT / "fastled" / "src"
 SKETCH_CACHE_FILE = OUTPUT_DIR / "compile_cache.db"
 LIVE_GIT_FASTLED_DIR = Path("/git/fastled")
 

{fastled-1.2.79 → fastled-1.2.80}/compiler/run.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from typing import Tuple
 
 from code_sync import CodeSync
-from paths import RSYNC_DEST, VOLUME_MAPPED_SRC
+from paths import FASTLED_SRC, VOLUME_MAPPED_SRC
 
 _PORT = os.environ.get("PORT", 80)
 
@@ -106,7 +106,7 @@ def main() -> int:
 
     code_sync = CodeSync(
         volume_mapped_src=VOLUME_MAPPED_SRC,
-        rsync_dest=RSYNC_DEST,
+        rsync_dest=FASTLED_SRC,
     )
     code_sync.sync_source_directory_if_volume_is_mapped()
 

{fastled-1.2.79 → fastled-1.2.80}/compiler/server.py

@@ -28,10 +28,10 @@ from fastapi import (  # type: ignore
     UploadFile,
 )
 from fastapi.responses import FileResponse, RedirectResponse, Response  # type: ignore
+from paths import FASTLED_SRC  # The folder where the actual source code is located.
 from paths import (
     LIVE_GIT_FASTLED_DIR,
     OUTPUT_DIR,
-    RSYNC_DEST,
     SKETCH_CACHE_FILE,
     TEMP_DIR,
     UPLOAD_DIR,
@@ -131,7 +131,7 @@ class UploadSizeMiddleware(BaseHTTPMiddleware):
 
 _CODE_SYNC = CodeSync(
     volume_mapped_src=VOLUME_MAPPED_SRC,
-    rsync_dest=RSYNC_DEST,
+    rsync_dest=FASTLED_SRC,
 )
 
 
@@ -226,12 +226,12 @@ def sync_live_git_to_target() -> None:
 
     _CODE_SYNC.sync_src_to_target(
         volume_mapped_src=LIVE_GIT_FASTLED_DIR / "src",
-        rsync_dest=RSYNC_DEST,
+        rsync_dest=FASTLED_SRC,
         callback=on_files_changed,
     )
     _CODE_SYNC.sync_src_to_target(
         volume_mapped_src=LIVE_GIT_FASTLED_DIR / "examples",
-        rsync_dest=RSYNC_DEST.parent / "examples",
+        rsync_dest=FASTLED_SRC.parent / "examples",
         callback=on_files_changed,
     )
     # Basically a setTimeout() in JS.
@@ -598,6 +598,38 @@ def project_init_example(
     )
 
 
+@app.get("/static/{file_path:path}")
+async def static_files(file_path: str) -> Response:
+    """Serve static files."""
+    print(f"Endpoint accessed: /static/{file_path}")
+
+    # Check if path matches the pattern js/fastled/src/...
+    if file_path.startswith("js/fastled/src/"):
+        # Extract the path after "js/fastled/src/"
+        relative_path = file_path[len("js/fastled/src/") :]
+        full_path = FASTLED_SRC / relative_path
+
+        if full_path.exists() and full_path.is_file():
+            content = full_path.read_bytes()
+            # Determine media type based on file extension
+            media_type = "text/plain"
+            if full_path.suffix in [".h", ".cpp"]:
+                media_type = "text/plain"
+            elif full_path.suffix == ".html":
+                media_type = "text/html"
+            elif full_path.suffix == ".js":
+                media_type = "application/javascript"
+            elif full_path.suffix == ".css":
+                media_type = "text/css"
+
+            return Response(content=content, media_type=media_type)
+
+    # If file not found or path doesn't match expected format
+    return Response(
+        content=f"File not found: {file_path}", media_type="text/plain", status_code=404
+    )
+
+
 @app.get("/info")
 def info_examples() -> dict:
     """Get a list of examples."""

{fastled-1.2.79 → fastled-1.2.80}/src/fastled/__init__.py

@@ -14,7 +14,7 @@ from .types import BuildMode, CompileResult, CompileServerError
 # 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.79"
+__version__ = "1.2.80"
 
 
 class Api:
@@ -194,14 +194,19 @@ class Test:
     def spawn_http_server(
         directory: Path | str = Path("."),
         port: int | None = None,
+        compile_server_port: int | None = None,
         open_browser: bool = True,
     ) -> Process:
         from fastled.open_browser import open_browser_process
 
+        compile_server_port = compile_server_port or -1
         if isinstance(directory, str):
             directory = Path(directory)
         proc: Process = open_browser_process(
-            directory, port=port, open_browser=open_browser
+            directory,
+            port=port,
+            compile_server_port=compile_server_port,
+            open_browser=open_browser,
         )
         return proc
 

{fastled-1.2.79 → fastled-1.2.80}/src/fastled/client_server.py

@@ -188,6 +188,15 @@ def run_client(
         return DEFAULT_URL
 
     url = get_url()
+    # parse out the port from the url
+    # use a standard host address parser to grab it
+    import urllib.parse
+
+    parsed_url = urllib.parse.urlparse(url)
+    if parsed_url.port is not None:
+        port = parsed_url.port
+    else:
+        port = 80
 
     try:
 
@@ -214,7 +223,9 @@ def run_client(
 
         browser_proc: Process | None = None
         if open_web_browser:
-            browser_proc = open_browser_process(directory / "fastled_js")
+            browser_proc = open_browser_process(
+                directory / "fastled_js", compile_server_port=port
+            )
         else:
             print("\nCompilation successful.")
             if compile_server:

{fastled-1.2.79 → fastled-1.2.80}/src/fastled/open_browser.py

@@ -14,8 +14,7 @@ PYTHON_EXE = sys.executable
 
 
 def _open_http_server_subprocess(
-    fastled_js: Path,
-    port: int,
+    fastled_js: Path, port: int, compile_server_port: int
 ) -> None:
     print("\n################################################################")
     print(f"# Opening browser to {fastled_js} on port {port}")
@@ -30,6 +29,8 @@ def _open_http_server_subprocess(
             str(fastled_js),
             "--port",
             str(port),
+            "--compile-server-port",
+            str(compile_server_port),
         ]
         # Pass SSL flags if available
         if ssl:
@@ -89,6 +90,7 @@ def wait_for_server(port: int, timeout: int = 10) -> None:
 
 def open_browser_process(
     fastled_js: Path,
+    compile_server_port: int,
     port: int | None = None,
     open_browser: bool = True,
 ) -> Process:
@@ -100,7 +102,7 @@ def open_browser_process(
 
     proc = Process(
         target=_open_http_server_subprocess,
-        args=(fastled_js, port),
+        args=(fastled_js, port, compile_server_port),
         daemon=True,
     )
     proc.start()

{fastled-1.2.79 → fastled-1.2.80}/src/fastled/server_flask.py

@@ -2,12 +2,14 @@ import argparse
 from multiprocessing import Process
 from pathlib import Path
 
+import requests
 from livereload import Server
 
 
 def _run_flask_server(
     fastled_js: Path,
     port: int,
+    compile_server_port: int,
     certfile: Path | None = None,
     keyfile: Path | None = None,
 ) -> None:
@@ -27,10 +29,38 @@ def _run_flask_server(
         # Must be a full path or flask will fail to find the file.
         fastled_js = fastled_js.resolve()
 
+        print(f"Compile server port is at {compile_server_port}")
+
         @app.route("/")
         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"""
+            from flask import Response, request
+
+            # Forward the request to the compile server
+            target_url = f"http://localhost:{compile_server_port}/static/{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
+
         @app.route("/<path:path>")
         def serve_files(path):
             response = send_from_directory(fastled_js, path)
@@ -83,11 +113,15 @@ def _run_flask_server(
 
 
 def run(
-    port: int, cwd: Path, certfile: Path | None = None, keyfile: Path | None = None
+    port: int,
+    cwd: Path,
+    compile_server_port: int,
+    certfile: Path | None = None,
+    keyfile: Path | None = None,
 ) -> None:
     """Run the Flask server."""
     try:
-        _run_flask_server(cwd, port, certfile, keyfile)
+        _run_flask_server(cwd, port, compile_server_port, certfile, keyfile)
         import warnings
 
         warnings.warn("Flask server has stopped")
@@ -128,15 +162,15 @@ def parse_args() -> argparse.Namespace:
 
 def run_flask_server_process(
     port: int,
-    cwd: Path | None = None,
+    cwd: Path,
+    compile_server_port: int,
     certfile: Path | None = None,
     keyfile: Path | None = None,
 ) -> Process:
     """Run the Flask server in a separate process."""
-    cwd = cwd or Path(".")
     process = Process(
         target=run,
-        args=(port, cwd, certfile, keyfile),
+        args=(port, cwd, compile_server_port, certfile, keyfile),
     )
     process.start()
     return process

{fastled-1.2.79 → fastled-1.2.80}/src/fastled/server_start.py

@@ -9,7 +9,11 @@ from fastled.server_flask import run_flask_server_process
 
 
 def run_server_process(
-    port: int, cwd: Path, certfile: Path | None = None, keyfile: Path | None = None
+    port: int,
+    cwd: Path,
+    compile_server_port: int,
+    certfile: Path | None = None,
+    keyfile: Path | None = None,
 ) -> Process:
     """Run the server in a separate process."""
     if True:
@@ -17,6 +21,7 @@ def run_server_process(
         process = run_flask_server_process(
             port=port,
             cwd=cwd,
+            compile_server_port=compile_server_port,
             certfile=certfile,
             keyfile=keyfile,
         )
@@ -45,19 +50,18 @@ def get_asset_path(filename: str) -> Path | None:
 def start_process(
     path: Path,
     port: int,
-    certfile: Path | None = None,
-    keyfile: Path | None = None,
+    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
-    if certfile is None:
-        certfile = get_asset_path("localhost.pem")
-    if keyfile is None:
-        keyfile = get_asset_path("localhost-key.pem")
 
     # _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)
+    proc = run_server_process(
+        port=port, cwd=path, compile_server_port=compile_server_port
+    )
     # try:
     #     proc.join()
     # except KeyboardInterrupt:
@@ -71,6 +75,7 @@ def start_process(
 class Args:
     fastled_js: Path
     port: int
+    compile_server_port: int
     cert: Path | None
     key: Path | None
 
@@ -89,6 +94,12 @@ def parse_args() -> Args:
         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)"
     )
@@ -99,6 +110,7 @@ def parse_args() -> 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,
     )
@@ -116,6 +128,7 @@ def main() -> None:
     proc = start_process(
         path=fastled_js,
         port=port,
+        compile_server_port=args.compile_server_port,
         certfile=cert,
         keyfile=key,
     )

{fastled-1.2.79 → fastled-1.2.80}/src/fastled.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.2.79
+Version: 1.2.80
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies

{fastled-1.2.79 → fastled-1.2.80}/src/fastled.egg-info/SOURCES.txt

@@ -41,10 +41,10 @@ compiler/build_fast.sh
 compiler/code_sync.py
 compiler/compile.py
 compiler/compile_lock.py
+compiler/debug.sh
 compiler/entrypoint.sh
 compiler/final_prewarm.sh
 compiler/init_runtime.py
-compiler/init_runtime2.py
 compiler/install-arduino-cli.sh
 compiler/paths.py
 compiler/pre-process.sh

fastled-1.2.79/compiler/init_runtime2.py

@@ -1,79 +0,0 @@
-import glob
-import os
-import warnings
-from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
-
-SRC_MAPPED_HOST_COMPLER_DIR = Path("/host/fastled/src/platforms/wasm/compiler")
-SRC_STANDARD_HOST_COMPILER_DIR = Path(
-    "/js/compiler/fastled/src/platforms/wasm/compiler"
-)
-
-COMPILER_TARGET = Path("/js")
-
-if SRC_MAPPED_HOST_COMPLER_DIR.exists():
-    SRC_COMPILER_DIR = SRC_MAPPED_HOST_COMPLER_DIR
-else:
-    SRC_COMPILER_DIR = SRC_STANDARD_HOST_COMPILER_DIR
-
-HERE = Path(__file__).parent
-
-
-def copy_task(src: str | Path) -> None:
-    src = Path(src)
-    if "entrypoint.sh" in str(src):
-        return
-    link_dst = COMPILER_TARGET / src.name
-
-    # Handle shell scripts
-    if src.suffix == ".sh":
-        os.system(f"dos2unix {src} && chmod +x {src}")
-
-    # if link exists, remove it
-    if link_dst.exists():
-        print(f"Removing existing link {link_dst}")
-        try:
-            os.remove(link_dst)
-        except Exception as e:
-            warnings.warn(f"Failed to remove {link_dst}: {e}")
-
-    if not link_dst.exists():
-        print(f"Linking {src} to {link_dst}")
-        try:
-            os.symlink(str(src), str(link_dst))
-        except FileExistsError:
-            print(f"Target {link_dst} already exists")
-    else:
-        print(f"Target {link_dst} already exists")
-
-
-def make_links() -> None:
-    # Define file patterns to include
-    patterns = [
-        "*.h",
-        "*.hpp",
-        "*.cpp",
-        "*.py",
-        "*.sh",
-        "*.ino",
-        "*.ini",
-        "*.txt",
-    ]
-
-    # Get all matching files in compiler directory
-    files = []
-    for pattern in patterns:
-        files.extend(glob.glob(str(SRC_COMPILER_DIR / pattern)))
-
-    # Process files in parallel using ThreadPoolExecutor
-    with ThreadPoolExecutor(max_workers=16) as executor:
-        executor.map(copy_task, files)
-
-
-def init_runtime() -> None:
-    os.chdir(str(HERE))
-    make_links()
-
-
-if __name__ == "__main__":
-    init_runtime()