fastled 1.4.10__tar.gz → 1.4.12__tar.gz

{fastled-1.4.10 → fastled-1.4.12}/PKG-INFO

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

fastled-1.4.12/requirements.docker.txt

@@ -0,0 +1 @@
+fastled-wasm-server>=1.1.21

{fastled-1.4.10 → fastled-1.4.12}/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.4.10"
+__version__ = "1.4.12"
 
 __version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

{fastled-1.4.10 → fastled-1.4.12}/src/fastled/app.py

@@ -63,6 +63,9 @@ def main() -> int:
     # now it is safe to print out the version
     print(f"FastLED version: {__version__}")
 
+    # Print current working directory
+    print(f"Current working directory: {os.getcwd()}")
+
     # Check if Playwright browsers are installed
     playwright_dir = Path.home() / ".fastled" / "playwright"
     if playwright_dir.exists() and any(playwright_dir.iterdir()):

{fastled-1.4.10 → fastled-1.4.12}/src/fastled/web_compile.py

@@ -30,6 +30,38 @@ def _sanitize_host(host: str) -> str:
     return host if host.startswith("http://") else f"http://{host}"
 
 
+def _check_embedded_http_status(response_content: bytes) -> tuple[bool, int | None]:
+    """
+    Check if the response content has an embedded HTTP status at the end.
+
+    Returns:
+        tuple: (has_embedded_status, status_code)
+               has_embedded_status is True if an embedded status was found
+               status_code is the embedded status code or None if not found
+    """
+    try:
+        # Convert bytes to string for parsing
+        content_str = response_content.decode("utf-8", errors="ignore")
+
+        # Look for HTTP_STATUS: at the end of the content
+        lines = content_str.strip().split("\n")
+        if lines:
+            last_line = lines[-1].strip()
+            if last_line.startswith("HTTP_STATUS:"):
+                # Extract the status code
+                try:
+                    status_code = int(last_line.split(":", 1)[1].strip())
+                    return True, status_code
+                except (ValueError, IndexError):
+                    # Malformed status line
+                    return True, None
+
+        return False, None
+    except Exception:
+        # If we can't parse the content, assume no embedded status
+        return False, None
+
+
 def _banner(msg: str) -> str:
     """
     Create a banner for the given message.
@@ -261,13 +293,33 @@ def web_compile(
             print("Step 1: Compiling libfastled...")
             try:
                 libfastled_response = _compile_libfastled(host, auth_token, build_mode)
+
+                # Check HTTP response status first
                 if libfastled_response.status_code != 200:
                     print(
-                        f"Warning: libfastled compilation failed with status {libfastled_response.status_code}"
+                        f"Warning: libfastled compilation failed with HTTP status {libfastled_response.status_code}"
                     )
                     # Continue with sketch compilation even if libfastled fails
                 else:
-                    print("✅ libfastled compilation successful")
+                    # Check for embedded HTTP status in response content
+                    has_embedded_status, embedded_status = _check_embedded_http_status(
+                        libfastled_response.content
+                    )
+                    if has_embedded_status:
+                        if embedded_status is not None and embedded_status != 200:
+                            print(
+                                f"Warning: libfastled compilation failed with embedded status {embedded_status}"
+                            )
+                            # Continue with sketch compilation even if libfastled fails
+                        elif embedded_status is None:
+                            print(
+                                "Warning: libfastled compilation returned malformed embedded status"
+                            )
+                            # Continue with sketch compilation even if libfastled fails
+                        else:
+                            print("✅ libfastled compilation successful")
+                    else:
+                        print("✅ libfastled compilation successful")
             except Exception as e:
                 print(f"Warning: libfastled compilation failed: {e}")
                 # Continue with sketch compilation even if libfastled fails

{fastled-1.4.10 → fastled-1.4.12}/src/fastled.egg-info/PKG-INFO

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

{fastled-1.4.10 → fastled-1.4.12}/tests/unit/test_manual_api_invocation.py

@@ -236,51 +236,8 @@ void loop() {
         if response.status_code != 200:
             print(f"❌ Response content: {response.text}")
 
-        self.assertEqual(response.status_code, 200)
-
-        # Verify we got some content back (streaming response)
-        self.assertGreater(len(response.content), 0)
-        print(f"📥 Response size: {len(response.content)} bytes")
-
-        # Check if it's a zip file or other binary content
-        if response.content.startswith(b"PK"):  # ZIP file magic bytes
-            print("📦 Response appears to be a ZIP file")
-            # Try to extract and verify the response contains expected library files
-            with tempfile.TemporaryDirectory() as temp_dir:
-                temp_path = Path(temp_dir)
-                zip_path = temp_path / "libfastled.zip"
-                zip_path.write_bytes(response.content)
-
-                # Extract and check contents
-                import shutil
-
-                shutil.unpack_archive(zip_path, temp_path, "zip")
-
-                # Look for expected library files
-                lib_files = list(temp_path.glob("**/*.a")) + list(
-                    temp_path.glob("**/*.so")
-                )
-                header_files = list(temp_path.glob("**/*.h")) + list(
-                    temp_path.glob("**/*.hpp")
-                )
-
-                print(f"🔍 Found library files: {[f.name for f in lib_files]}")
-                print(f"🔍 Found header files: {[f.name for f in header_files]}")
-
-                # We expect at least some library or header files
-                self.assertGreater(
-                    len(lib_files) + len(header_files),
-                    0,
-                    "Expected to find library or header files",
-                )
-        else:
-            print("📄 Response appears to be text/binary data")
-            # Could be a streaming response with compilation logs
-            try:
-                text_content = response.content.decode("utf-8")
-                print(f"📝 Response preview: {text_content[:200]}...")
-            except UnicodeDecodeError:
-                print("🔧 Response contains binary data")
+        # We don't volume map so this should return 400
+        self.assertEqual(response.status_code, 400)
 
     @unittest.skipUnless(True, "Test manual API invocation")
     def test_project_init_endpoint_manual(self) -> None:

fastled-1.4.12/tests/unit/test_webcompile.py

@@ -0,0 +1,81 @@
+import time
+import unittest
+from pathlib import Path
+
+from fastled.web_compile import _check_embedded_http_status, web_compile
+
+HERE = Path(__file__).parent
+TEST_DIR = HERE / "test_ino" / "wasm"
+
+_USE_LOCALHOST = False
+_HOST = "http://localhost" if _USE_LOCALHOST else None
+
+
+class WebCompileTester(unittest.TestCase):
+    """Main tester class."""
+
+    def test_compile(self) -> None:
+        """Test web compilation functionality with real server."""
+        # Test the web_compile function with actual server call
+        start = time.time()
+        result = web_compile(TEST_DIR, host=_HOST)
+        diff = time.time() - start
+        print(f"Time taken: {diff:.2f} seconds")
+
+        # Verify we got a successful result
+        self.assertTrue(result.success, f"Compilation failed: {result.stdout}")
+
+        # Verify we got actual WASM data back
+        self.assertTrue(len(result.zip_bytes) > 0)
+
+        # Print compilation output for debugging
+        print(f"Compilation stdout:\n{result.stdout}")
+
+        print(f"Zip size: {len(result.zip_bytes)} bytes")
+
+    def test_invalid_directory(self) -> None:
+        """Test handling of invalid directory."""
+        with self.assertRaises(FileNotFoundError):
+            web_compile(Path("nonexistent_directory"))
+
+    def test_embedded_http_status_parsing(self) -> None:
+        """Test the _check_embedded_http_status function."""
+        # Test successful case (no embedded status)
+        content_success = b"Some output\nCompilation successful\n"
+        has_status, status_code = _check_embedded_http_status(content_success)
+        self.assertFalse(has_status)
+        self.assertIsNone(status_code)
+
+        # Test embedded 400 status
+        content_400 = b"Some error output\nHTTP_STATUS: 400"
+        has_status, status_code = _check_embedded_http_status(content_400)
+        self.assertTrue(has_status)
+        self.assertEqual(status_code, 400)
+
+        # Test embedded 200 status
+        content_200 = b"Some output\nHTTP_STATUS: 200"
+        has_status, status_code = _check_embedded_http_status(content_200)
+        self.assertTrue(has_status)
+        self.assertEqual(status_code, 200)
+
+        # Test malformed embedded status
+        content_malformed = b"Some output\nHTTP_STATUS: invalid"
+        has_status, status_code = _check_embedded_http_status(content_malformed)
+        self.assertTrue(has_status)
+        self.assertIsNone(status_code)
+
+        # Test empty content
+        content_empty = b""
+        has_status, status_code = _check_embedded_http_status(content_empty)
+        self.assertFalse(has_status)
+        self.assertIsNone(status_code)
+
+        # Test content with embedded status in middle (should not be detected)
+        content_middle = b"Some output\nHTTP_STATUS: 400\nMore output"
+        has_status, status_code = _check_embedded_http_status(content_middle)
+        self.assertFalse(has_status)
+        self.assertIsNone(status_code)
+
+
+if __name__ == "__main__":
+    unittest.main()

fastled-1.4.10/requirements.docker.txt

@@ -1 +0,0 @@
-fastled-wasm-server>=1.1.18

fastled-1.4.10/tests/unit/test_webcompile.py

@@ -1,43 +0,0 @@
-import time
-import unittest
-from pathlib import Path
-
-from fastled.web_compile import web_compile
-
-HERE = Path(__file__).parent
-TEST_DIR = HERE / "test_ino" / "wasm"
-
-_USE_LOCALHOST = False
-_HOST = "http://localhost" if _USE_LOCALHOST else None
-
-
-class WebCompileTester(unittest.TestCase):
-    """Main tester class."""
-
-    def test_compile(self) -> None:
-        """Test web compilation functionality with real server."""
-        # Test the web_compile function with actual server call
-        start = time.time()
-        result = web_compile(TEST_DIR, host=_HOST)
-        diff = time.time() - start
-        print(f"Time taken: {diff:.2f} seconds")
-
-        # Verify we got a successful result
-        self.assertTrue(result.success, f"Compilation failed: {result.stdout}")
-
-        # Verify we got actual WASM data back
-        self.assertTrue(len(result.zip_bytes) > 0)
-
-        # Print compilation output for debugging
-        print(f"Compilation stdout:\n{result.stdout}")
-
-        print(f"Zip size: {len(result.zip_bytes)} bytes")
-
-    def test_invalid_directory(self) -> None:
-        """Test handling of invalid directory."""
-        with self.assertRaises(FileNotFoundError):
-            web_compile(Path("nonexistent_directory"))
-
-
-if __name__ == "__main__":
-    unittest.main()