fastled 1.3.33__tar.gz → 1.3.34__tar.gz

{fastled-1.3.33 → fastled-1.3.34}/PKG-INFO

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

{fastled-1.3.33 → fastled-1.3.34}/src/fastled/__init__.py

@@ -64,6 +64,7 @@ class Api:
         http_port: (
             int | None
         ) = None,  # None means auto select a free port. -1 means no server.
+        no_platformio: bool = False,
     ) -> LiveClient:
         return LiveClient(
             sketch_directory=sketch_directory,
@@ -75,6 +76,7 @@ class Api:
             build_mode=build_mode,
             profile=profile,
             http_port=http_port,
+            no_platformio=no_platformio,
         )
 
     @staticmethod
@@ -85,6 +87,7 @@ class Api:
         mapped_dir: Path | None = None,  # Sketch directory.
         container_name: str | None = None,  # Specific docker container name.
         remove_previous: bool = False,
+        no_platformio: bool = False,
     ) -> CompileServer:
         """Uses docker to spawn a compile server from the given name."""
         from fastled.compile_server import CompileServer
@@ -96,6 +99,7 @@ class Api:
             mapped_dir=mapped_dir,
             auto_start=auto_start,
             remove_previous=remove_previous,
+            no_platformio=no_platformio,
         )
         return out
 
@@ -108,6 +112,7 @@ class Api:
         mapped_dir: Path | None = None,  # Sketch directory.
         container_name: str | None = None,  # Specific docker container name.
         remove_previous=False,
+        no_platformio: bool = False,
     ) -> Generator[CompileServer, None, None]:
         server = Api.spawn_server(
             interactive=interactive,
@@ -116,6 +121,7 @@ class Api:
             mapped_dir=mapped_dir,
             container_name=container_name,
             remove_previous=remove_previous,
+            no_platformio=no_platformio,
         )
         try:
             yield server

{fastled-1.3.33 → fastled-1.3.34}/src/fastled/__version__.py

@@ -1,6 +1,6 @@
 # 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.3.33"
+__version__ = "1.3.34"
 
 __version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

{fastled-1.3.33 → fastled-1.3.34}/src/fastled/app.py

@@ -27,6 +27,7 @@ def run_server(args: Args) -> int:
         mapped_dir=mapped_dir,
         auto_start=True,
         remove_previous=args.clear,
+        no_platformio=args.no_platformio,
     )
 
     if not interactive:
@@ -87,7 +88,9 @@ def main() -> int:
 
     if update:
         # Force auto_update to ensure update check happens
-        compile_server = CompileServer(interactive=False, auto_updates=True)
+        compile_server = CompileServer(
+            interactive=False, auto_updates=True, no_platformio=args.no_platformio
+        )
         compile_server.stop()
         print("Finished updating.")
         return 0
@@ -109,6 +112,7 @@ def main() -> int:
             mapped_dir=directory,
             auto_start=False,
             remove_previous=args.clear,
+            no_platformio=args.no_platformio,
         )
 
         server.start(wait_for_startup=False)

{fastled-1.3.33 → fastled-1.3.34}/src/fastled/client_server.py

@@ -130,7 +130,11 @@ def _run_web_compiler(
 
 
 def _try_start_server_or_get_url(
-    auto_update: bool, args_web: str | bool, localhost: bool, clear: bool
+    auto_update: bool,
+    args_web: str | bool,
+    localhost: bool,
+    clear: bool,
+    no_platformio: bool = False,
 ) -> tuple[str, CompileServer | None]:
     is_local_host = localhost or (
         isinstance(args_web, str)
@@ -161,7 +165,9 @@ def _try_start_server_or_get_url(
         try:
             print("No local server found, starting one...")
             compile_server = CompileServer(
-                auto_updates=auto_update, remove_previous=clear
+                auto_updates=auto_update,
+                remove_previous=clear,
+                no_platformio=no_platformio,
             )
             print("Waiting for the local compiler to start...")
             if not compile_server.ping():
@@ -177,7 +183,9 @@ def _try_start_server_or_get_url(
             return (DEFAULT_URL, None)
 
 
-def _try_make_compile_server(clear: bool = False) -> CompileServer | None:
+def _try_make_compile_server(
+    clear: bool = False, no_platformio: bool = False
+) -> CompileServer | None:
     if not DockerManager.is_docker_installed():
         return None
     try:
@@ -189,7 +197,9 @@ def _try_make_compile_server(clear: bool = False) -> CompileServer | None:
         free_port = find_free_port(start_port=9723, end_port=9743)
         if free_port is None:
             return None
-        compile_server = CompileServer(auto_updates=False, remove_previous=clear)
+        compile_server = CompileServer(
+            auto_updates=False, remove_previous=clear, no_platformio=no_platformio
+        )
         print("Waiting for the local compiler to start...")
         if not compile_server.ping():
             print("Failed to start local compiler.")
@@ -228,13 +238,16 @@ def run_client(
         int | None
     ) = None,  # None means auto select a free port, http_port < 0 means no server.
     clear: bool = False,
+    no_platformio: bool = False,
 ) -> int:
     has_checked_newer_version_yet = False
     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(clear=clear)
+        compile_server = _try_make_compile_server(
+            clear=clear, no_platformio=no_platformio
+        )
         if compile_server is None:
             host = DEFAULT_URL
     elif isinstance(host, CompileServer):
@@ -463,6 +476,7 @@ def run_client_server(args: Args) -> int:
     force_compile = bool(args.force_compile)
     open_web_browser = not just_compile and not interactive
     build_mode: BuildMode = BuildMode.from_args(args)
+    no_platformio = bool(args.no_platformio)
 
     if not force_compile and not looks_like_sketch_directory(directory):
         # if there is only one directory in the sketch directory, use that
@@ -492,7 +506,7 @@ def run_client_server(args: Args) -> int:
     compile_server: CompileServer | None = None
     try:
         url, compile_server = _try_start_server_or_get_url(
-            auto_update, web, localhost, args.clear
+            auto_update, web, localhost, args.clear, no_platformio
         )
     except KeyboardInterrupt:
         print("\nExiting from first try...")
@@ -524,6 +538,7 @@ def run_client_server(args: Args) -> int:
             build_mode=build_mode,
             profile=profile,
             clear=args.clear,
+            no_platformio=no_platformio,
         )
     except KeyboardInterrupt:
         return 1

{fastled-1.3.33 → fastled-1.3.34}/src/fastled/compile_server.py

@@ -15,6 +15,7 @@ class CompileServer:
         container_name: str | None = None,
         platform: Platform = Platform.WASM,
         remove_previous: bool = False,
+        no_platformio: bool = False,
     ) -> None:
         from fastled.compile_server_impl import (  # avoid circular import
             CompileServerImpl,
@@ -29,6 +30,7 @@ class CompileServer:
             mapped_dir=mapped_dir,
             auto_start=auto_start,
             remove_previous=remove_previous,
+            no_platformio=no_platformio,
         )
 
     # May throw CompileServerError if server could not be started.

{fastled-1.3.33 → fastled-1.3.34}/src/fastled/compile_server_impl.py

@@ -50,6 +50,7 @@ class CompileServerImpl:
         auto_start: bool = True,
         container_name: str | None = None,
         remove_previous: bool = False,
+        no_platformio: bool = False,
     ) -> None:
         container_name = container_name or DEFAULT_CONTAINER_NAME
         if interactive and not mapped_dir:
@@ -68,6 +69,7 @@ class CompileServerImpl:
         self.running_container: RunningContainer | None = None
         self.auto_updates = auto_updates
         self.remove_previous = remove_previous
+        self.no_platformio = no_platformio
         self._port = 0  # 0 until compile server is started
         if auto_start:
             self.start()
@@ -217,6 +219,8 @@ class CompileServerImpl:
             server_command = ["/bin/bash"]
         else:
             server_command = ["python", "/js/run.py", "server"] + SERVER_OPTIONS
+            if self.no_platformio:
+                server_command.append("--no-platformio")
         if self.interactive:
             print("Disabling port forwarding in interactive mode")
             ports = {}

{fastled-1.3.33 → fastled-1.3.34}/src/fastled/live_client.py

@@ -22,6 +22,7 @@ class LiveClient:
         keep_running: bool = True,
         build_mode: BuildMode = BuildMode.QUICK,
         profile: bool = False,
+        no_platformio: bool = False,
     ) -> None:
         self.sketch_directory = sketch_directory
         self.host = host
@@ -34,6 +35,7 @@ class LiveClient:
         self.shutdown = threading.Event()
         self.thread: threading.Thread | None = None
         self.auto_updates = auto_updates
+        self.no_platformio = no_platformio
         if auto_start:
             self.start()
         if self.auto_updates is False:
@@ -52,6 +54,7 @@ class LiveClient:
             profile=self.profile,
             shutdown=self.shutdown,
             http_port=self.http_port,
+            no_platformio=self.no_platformio,
         )
         return rtn
 

{fastled-1.3.33 → fastled-1.3.34}/src/fastled/server_flask.py

@@ -85,6 +85,14 @@ def _run_flask_server(
 
         # logger.error(f"Server error: {e}")
 
+        @app.after_request
+        def add_security_headers(response):
+            """Add security headers required for cross-origin isolation and audio worklets"""
+            # Required for SharedArrayBuffer and audio worklets
+            response.headers["Cross-Origin-Embedder-Policy"] = "credentialless"
+            response.headers["Cross-Origin-Opener-Policy"] = "same-origin"
+            return response
+
         @app.before_request
         def log_request_info():
             """Log details of each request before processing"""

{fastled-1.3.33 → fastled-1.3.34}/src/fastled.egg-info/PKG-INFO

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

{fastled-1.3.33 → fastled-1.3.34}/src/fastled.egg-info/SOURCES.txt

@@ -101,6 +101,7 @@ tests/unit/test_debug_fetch_source_files.py
 tests/unit/test_docker_linux_on_windows.py
 tests/unit/test_embedded_data.py
 tests/unit/test_filechanger.py
+tests/unit/test_flask_headers.py
 tests/unit/test_http_server.py
 tests/unit/test_manual_api_invocation.py
 tests/unit/test_no_platformio_compile.py

fastled-1.3.34/tests/unit/test_flask_headers.py

@@ -0,0 +1,188 @@
+"""
+Test Flask server HTTP headers including CORS and cross-origin isolation headers.
+"""
+
+import os
+import random
+import time
+import unittest
+from pathlib import Path
+
+import httpx
+
+# Enable Flask server logging for debugging if needed
+os.environ["FLASK_SERVER_LOGGING"] = "0"
+
+from fastled import Test
+
+HERE = Path(__file__).parent
+INDEX_HTML = HERE / "html" / "index.html"
+TIMEOUT = 30
+
+assert INDEX_HTML.exists()
+
+# Use random port to avoid conflicts
+PORT = random.randint(8500, 8600)
+COMPILE_SERVER_PORT = PORT + 1
+
+
+class FlaskHeadersTester(unittest.TestCase):
+    """Test Flask server HTTP headers."""
+
+    def test_cors_headers(self) -> None:
+        """Test that CORS headers are properly set."""
+        port = PORT
+        proc = Test.spawn_http_server(
+            INDEX_HTML.parent,
+            port=port,
+            compile_server_port=COMPILE_SERVER_PORT,
+            open_browser=False,
+        )
+
+        try:
+            # Give server time to start
+            time.sleep(2)
+
+            # Test with OPTIONS request (preflight request)
+            options_response = httpx.options(
+                f"http://localhost:{port}", timeout=TIMEOUT
+            )
+
+            # Check CORS headers
+            self.assertIn("Access-Control-Allow-Origin", options_response.headers)
+            self.assertEqual(
+                options_response.headers["Access-Control-Allow-Origin"], "*"
+            )
+
+            # Test with regular GET request
+            get_response = httpx.get(f"http://localhost:{port}", timeout=TIMEOUT)
+            self.assertEqual(get_response.status_code, 200)
+
+            # Check CORS headers are present in GET response too
+            self.assertIn("Access-Control-Allow-Origin", get_response.headers)
+            self.assertEqual(get_response.headers["Access-Control-Allow-Origin"], "*")
+
+        finally:
+            proc.terminate()
+            time.sleep(1)
+
+    def test_cross_origin_isolation_headers(self) -> None:
+        """Test that cross-origin isolation headers are properly set for audio worklets."""
+        port = PORT + 2
+        proc = Test.spawn_http_server(
+            INDEX_HTML.parent,
+            port=port,
+            compile_server_port=COMPILE_SERVER_PORT + 2,
+            open_browser=False,
+        )
+
+        try:
+            # Give server time to start
+            time.sleep(2)
+
+            response = httpx.get(f"http://localhost:{port}", timeout=TIMEOUT)
+            self.assertEqual(response.status_code, 200)
+
+            # Check cross-origin isolation headers
+            self.assertIn("Cross-Origin-Embedder-Policy", response.headers)
+            self.assertIn("Cross-Origin-Opener-Policy", response.headers)
+
+            # Verify the values
+            coep = response.headers["Cross-Origin-Embedder-Policy"]
+            coop = response.headers["Cross-Origin-Opener-Policy"]
+
+            # Should be either 'credentialless' or 'require-corp'
+            self.assertIn(coep, ["credentialless", "require-corp"])
+            self.assertEqual(coop, "same-origin")
+
+        finally:
+            proc.terminate()
+            time.sleep(1)
+
+    def test_cors_preflight_request(self) -> None:
+        """Test CORS preflight request with custom headers."""
+        port = PORT + 3
+        proc = Test.spawn_http_server(
+            INDEX_HTML.parent,
+            port=port,
+            compile_server_port=COMPILE_SERVER_PORT + 3,
+            open_browser=False,
+        )
+
+        try:
+            # Give server time to start
+            time.sleep(2)
+
+            # Simulate a preflight request with custom headers
+            headers = {
+                "Origin": "https://example.com",
+                "Access-Control-Request-Method": "POST",
+                "Access-Control-Request-Headers": "Content-Type,Authorization",
+            }
+
+            response = httpx.options(
+                f"http://localhost:{port}", headers=headers, timeout=TIMEOUT
+            )
+
+            # Check CORS response headers
+            self.assertIn("Access-Control-Allow-Origin", response.headers)
+            self.assertIn("Access-Control-Allow-Methods", response.headers)
+            self.assertIn("Access-Control-Allow-Headers", response.headers)
+
+            # Verify values - Flask-CORS echoes back the specific origin when provided
+            # This is correct security behavior
+            self.assertEqual(
+                response.headers["Access-Control-Allow-Origin"], "https://example.com"
+            )
+
+            allowed_methods = response.headers["Access-Control-Allow-Methods"]
+            self.assertIn("POST", allowed_methods)
+            self.assertIn("GET", allowed_methods)
+
+            allowed_headers = response.headers["Access-Control-Allow-Headers"]
+            self.assertIn("Content-Type", allowed_headers)
+
+        finally:
+            proc.terminate()
+            time.sleep(1)
+
+    def test_all_headers_on_file_request(self) -> None:
+        """Test that both CORS and cross-origin isolation headers are present on file requests."""
+        port = PORT + 4
+        proc = Test.spawn_http_server(
+            INDEX_HTML.parent,
+            port=port,
+            compile_server_port=COMPILE_SERVER_PORT + 4,
+            open_browser=False,
+        )
+
+        try:
+            # Give server time to start
+            time.sleep(2)
+
+            # Request the index.html file
+            response = httpx.get(f"http://localhost:{port}/index.html", timeout=TIMEOUT)
+            self.assertEqual(response.status_code, 200)
+
+            # Check all important headers are present
+            headers = response.headers
+
+            # CORS headers
+            self.assertIn("Access-Control-Allow-Origin", headers)
+            self.assertEqual(headers["Access-Control-Allow-Origin"], "*")
+
+            # Cross-origin isolation headers
+            self.assertIn("Cross-Origin-Embedder-Policy", headers)
+            self.assertIn("Cross-Origin-Opener-Policy", headers)
+
+            # Cache control headers (should be no-cache for development)
+            self.assertIn("Cache-Control", headers)
+            self.assertIn("no-cache", headers["Cache-Control"])
+
+        finally:
+            proc.terminate()
+            time.sleep(1)
+
+
+if __name__ == "__main__":
+    unittest.main()

{fastled-1.3.33 → fastled-1.3.34}/tests/unit/test_no_platformio_compile.py

@@ -9,8 +9,10 @@ import platform
 import unittest
 from pathlib import Path
 from tempfile import TemporaryDirectory
+from unittest.mock import MagicMock, patch
 
 from fastled import Api, CompileServer
+from fastled.compile_server_impl import CompileServerImpl
 from fastled.docker_manager import DockerManager
 from fastled.types import BuildMode, CompileResult
 
@@ -272,5 +274,199 @@ class NoPlatformIOCompileTester(unittest.TestCase):
         print("- Access advanced build modes not available via standard PlatformIO")
 
 
+class NoPlatformIOCompileTest(unittest.TestCase):
+    """Test cases for --no-platformio flag functionality in compilation."""
+
+    def setUp(self) -> None:
+        """Set up test environment."""
+        pass
+
+    def test_no_platformio_server_command_construction(self) -> None:
+        """Test that --no-platformio flag is added to server command when enabled."""
+
+        # Mock the docker manager and its methods
+        with patch("fastled.compile_server_impl.DockerManager") as mock_docker_manager:
+            mock_docker = MagicMock()
+            mock_docker_manager.return_value = mock_docker
+            mock_docker.is_running.return_value = (True, None)
+            mock_docker.validate_or_download_image.return_value = False
+            mock_docker.run_container_detached.return_value = MagicMock()
+            mock_docker.attach_and_run.return_value = MagicMock()
+
+            # Test with no_platformio=True
+            with patch(
+                "fastled.compile_server_impl._try_get_fastled_src", return_value=None
+            ):
+                server_impl = CompileServerImpl(
+                    auto_start=False, no_platformio=True  # Don't actually start
+                )
+
+                # Mock the parts of _start that we don't want to actually run
+                with patch.object(
+                    server_impl.docker, "is_running", return_value=(True, None)
+                ):
+                    with patch.object(
+                        server_impl.docker,
+                        "validate_or_download_image",
+                        return_value=False,
+                    ):
+                        with patch.object(
+                            server_impl.docker, "run_container_detached"
+                        ) as mock_run:
+                            with patch.object(server_impl.docker, "attach_and_run"):
+                                try:
+                                    server_impl._start()
+                                except Exception:
+                                    pass  # We expect this to fail, we just want to check the command
+
+                                # Verify that run_container_detached was called with --no-platformio in the command
+                                self.assertTrue(
+                                    mock_run.called,
+                                    "run_container_detached should have been called",
+                                )
+
+                                # Get the call arguments
+                                call_args = mock_run.call_args
+                                command = call_args[1][
+                                    "command"
+                                ]  # Get the command from kwargs
+
+                                # Verify --no-platformio is in the command
+                                self.assertIn(
+                                    "--no-platformio",
+                                    command,
+                                    f"--no-platformio should be in server command: {command}",
+                                )
+
+    def test_no_platformio_server_command_without_flag(self) -> None:
+        """Test that --no-platformio flag is NOT added to server command when disabled."""
+
+        # Mock the docker manager and its methods
+        with patch("fastled.compile_server_impl.DockerManager") as mock_docker_manager:
+            mock_docker = MagicMock()
+            mock_docker_manager.return_value = mock_docker
+            mock_docker.is_running.return_value = (True, None)
+            mock_docker.validate_or_download_image.return_value = False
+            mock_docker.run_container_detached.return_value = MagicMock()
+            mock_docker.attach_and_run.return_value = MagicMock()
+
+            # Test with no_platformio=False (default)
+            with patch(
+                "fastled.compile_server_impl._try_get_fastled_src", return_value=None
+            ):
+                server_impl = CompileServerImpl(
+                    auto_start=False, no_platformio=False  # Don't actually start
+                )
+
+                # Mock the parts of _start that we don't want to actually run
+                with patch.object(
+                    server_impl.docker, "is_running", return_value=(True, None)
+                ):
+                    with patch.object(
+                        server_impl.docker,
+                        "validate_or_download_image",
+                        return_value=False,
+                    ):
+                        with patch.object(
+                            server_impl.docker, "run_container_detached"
+                        ) as mock_run:
+                            with patch.object(server_impl.docker, "attach_and_run"):
+                                try:
+                                    server_impl._start()
+                                except Exception:
+                                    pass  # We expect this to fail, we just want to check the command
+
+                                # Verify that run_container_detached was called
+                                self.assertTrue(
+                                    mock_run.called,
+                                    "run_container_detached should have been called",
+                                )
+
+                                # Get the call arguments
+                                call_args = mock_run.call_args
+                                command = call_args[1][
+                                    "command"
+                                ]  # Get the command from kwargs
+
+                                # Verify --no-platformio is NOT in the command
+                                self.assertNotIn(
+                                    "--no-platformio",
+                                    command,
+                                    f"--no-platformio should NOT be in server command: {command}",
+                                )
+
+    @unittest.skipUnless(
+        False, "This test would require actual docker"  # Skip this test for now
+    )
+    def test_no_platformio_compile_success(self) -> None:
+        """Test that a sketch compiles successfully bypassing PlatformIO constraints.
+
+        This test demonstrates compilation equivalent to --no-platformio mode by:
+        1. Using local Docker compilation with custom build environment
+        2. Bypassing standard PlatformIO limitations and constraints
+        3. Providing direct access to compilation flags and toolchain
+        4. Enabling custom build configurations not available via web compiler
+
+        The local Docker compilation effectively provides no-platformio mode by:
+        - Custom toolchain configuration
+        - Direct compiler flag control
+        - Bypass of PlatformIO build restrictions
+        - Access to advanced compilation modes
+        """
+
+        # Ensure test sketch directory exists
+        self.assertTrue(
+            TEST_SKETCH_DIR.exists(),
+            f"Test sketch directory not found: {TEST_SKETCH_DIR}",
+        )
+
+        # Verify test sketch file exists
+        test_sketch_file = TEST_SKETCH_DIR / "wasm.ino"
+        self.assertTrue(
+            test_sketch_file.exists(), f"Test sketch file not found: {test_sketch_file}"
+        )
+
+        # Start local compile server with no-platformio equivalent configuration
+        with Api.server() as server:
+            self.assertIsInstance(server, CompileServer)
+            self.assertTrue(server.running, "No-platformio server should be running")
+
+            # Compile the test sketch using no-platformio equivalent mode
+            result: CompileResult = server.web_compile(
+                directory=TEST_SKETCH_DIR,
+                build_mode=BuildMode.QUICK,  # Use quick mode for faster compilation
+                profile=False,
+            )
+
+            # Verify no-platformio compilation succeeded
+            self.assertTrue(
+                result.success,
+                f"No-platformio compilation failed. Output: {result.stdout}",
+            )
+
+            # Verify we got actual compiled output
+            self.assertTrue(
+                len(result.zip_bytes) > 0,
+                "No compiled output received from no-platformio mode",
+            )
+
+            # Verify stdout contains expected compilation messages
+            self.assertIsNotNone(
+                result.stdout, "No stdout received from no-platformio compilation"
+            )
+
+            # Print no-platformio compilation info for debugging
+            print("No-platformio compilation successful!")
+            print(f"Compiled zip size: {len(result.zip_bytes)} bytes")
+            if result.hash_value:
+                print(f"Hash: {result.hash_value}")
+
+            # Verify compiled WASM output structure
+            if result.zip_bytes:
+                print(
+                    "Successfully received compiled WASM output from no-platformio mode"
+                )
+
+
 if __name__ == "__main__":
     unittest.main()