fastled 1.2.5__py3-none-any.whl → 1.2.7__py3-none-any.whl

fastled/__init__.py

@@ -1,6 +1,7 @@
 """FastLED Wasm Compiler package."""
 
 # context
+import subprocess
 from contextlib import contextmanager
 from pathlib import Path
 from typing import Generator
@@ -13,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.5"
+__version__ = "1.2.7"
 
 
 class Api:
@@ -131,17 +132,160 @@ class Docker:
         from fastled.docker_manager import DockerManager
         from fastled.settings import CONTAINER_NAME
 
-        docker = DockerManager()
+        docker_mgr = DockerManager()
         container_name = container_name or CONTAINER_NAME
-        return docker.is_container_running(container_name)
+        return docker_mgr.is_container_running(container_name)
 
     @staticmethod
     def purge() -> None:
         from fastled.docker_manager import DockerManager
-        from fastled.settings import CONTAINER_NAME
+        from fastled.settings import IMAGE_NAME
+
+        docker_mgr = DockerManager()
+        docker_mgr.purge(image_name=IMAGE_NAME)
+
+    @staticmethod
+    def build_from_github(
+        url: str = "https://github.com/fastled/fastled",
+        output_dir: Path | str = Path(".cache/fastled"),
+    ) -> str:
+        """Build the FastLED WASM compiler Docker image from a GitHub repository.
+
+        Args:
+            url: GitHub repository URL (default: https://github.com/fastled/fastled)
+            output_dir: Directory to clone the repo into (default: .cache/fastled)
+
+        Returns:
+            Container name.
+        """
 
-        docker = DockerManager()
-        docker.purge(CONTAINER_NAME)
+        from fastled.docker_manager import DockerManager
+        from fastled.settings import CONTAINER_NAME, IMAGE_NAME
+
+        if isinstance(output_dir, str):
+            output_dir = Path(output_dir)
+
+        # Create output directory if it doesn't exist
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Clone or update the repository
+        if (output_dir / ".git").exists():
+            print(f"Updating existing repository in {output_dir}")
+            # Reset local changes and move HEAD back to handle force pushes
+            subprocess.run(
+                ["git", "reset", "--hard", "HEAD~10"],
+                cwd=output_dir,
+                check=True,
+                capture_output=True,  # Suppress output of reset
+            )
+            subprocess.run(
+                ["git", "pull", "origin", "master"], cwd=output_dir, check=True
+            )
+        else:
+            print(f"Cloning {url} into {output_dir}")
+            subprocess.run(["git", "clone", url, str(output_dir)], check=True)
+
+        dockerfile_path = (
+            output_dir / "src" / "platforms" / "wasm" / "compiler" / "Dockerfile"
+        )
+
+        if not dockerfile_path.exists():
+            raise FileNotFoundError(
+                f"Dockerfile not found at {dockerfile_path}. "
+                "This may not be a valid FastLED repository."
+            )
+
+        docker_mgr = DockerManager()
+
+        platform_tag = ""
+        # if "arm" in docker_mgr.architecture():
+        if (
+            "arm"
+            in subprocess.run(["uname", "-m"], capture_output=True).stdout.decode()
+        ):
+            platform_tag = "-arm64"
+
+        # Build the image
+        docker_mgr.build_image(
+            image_name=IMAGE_NAME,
+            tag="main",
+            dockerfile_path=dockerfile_path,
+            build_context=output_dir,
+            build_args={"NO_PREWARM": "1"},
+            platform_tag=platform_tag,
+        )
+
+        # Run the container and return it
+        container = docker_mgr.run_container_detached(
+            image_name=IMAGE_NAME,
+            tag="main",
+            container_name=CONTAINER_NAME,
+            command=None,  # Use default command from Dockerfile
+            volumes=None,  # No volumes needed for build
+            ports=None,  # No ports needed for build
+            remove_previous=True,  # Remove any existing container
+        )
+
+        return container.name
+
+    @staticmethod
+    def build_from_fastled_repo(
+        project_root: Path | str = Path("."), platform_tag: str = ""
+    ) -> str:
+        """Build the FastLED WASM compiler Docker image, which will be tagged as "main".
+
+        Args:
+            project_root: Path to the FastLED project root directory
+            platform_tag: Optional platform tag (e.g. "-arm64" for ARM builds)
+
+        Returns:
+            The string name of the docker container.
+        """
+        from fastled.docker_manager import DockerManager
+        from fastled.settings import CONTAINER_NAME, IMAGE_NAME
+
+        if isinstance(project_root, str):
+            project_root = Path(project_root)
+
+        dockerfile_path = (
+            project_root / "src" / "platforms" / "wasm" / "compiler" / "Dockerfile"
+        )
+
+        docker_mgr = DockerManager()
+
+        platform_tag = ""
+        # if "arm" in docker_mgr.architecture():
+        if (
+            "arm"
+            in subprocess.run(["uname", "-m"], capture_output=True).stdout.decode()
+        ):
+            platform_tag = "-arm64"
+
+        # if image exists, remove it
+        docker_mgr.purge(image_name=IMAGE_NAME)
+
+        # Build the image
+        docker_mgr.build_image(
+            image_name=IMAGE_NAME,
+            tag="main",
+            dockerfile_path=dockerfile_path,
+            build_context=project_root,
+            build_args={"NO_PREWARM": "1"},
+            platform_tag=platform_tag,
+        )
+
+        # Run the container and return it
+        container = docker_mgr.run_container_detached(
+            image_name=IMAGE_NAME,
+            tag="main",
+            container_name=CONTAINER_NAME,
+            command=None,  # Use default command from Dockerfile
+            volumes=None,  # No volumes needed for build
+            ports=None,  # No ports needed for build
+            remove_previous=True,  # Remove any existing container
+        )
+        container_name = f"{container.name}"
+        return container_name
 
 
 class Test:
@@ -173,6 +317,7 @@ class Test:
 __all__ = [
     "Api",
     "Test",
+    "Build",
     "CompileServer",
     "CompileResult",
     "CompileServerError",

fastled/app.py

@@ -51,6 +51,32 @@ def main() -> int:
         print("Finished updating.")
         return 0
 
+    if args.build:
+        try:
+            project_root = Path(".").absolute()
+            print(f"Building Docker image at {project_root}")
+            from fastled import Api, Docker
+
+            docker_image_name = Docker.build_from_fastled_repo(
+                project_root=project_root
+            )
+            print(f"Built Docker image: {docker_image_name}")
+            print("Running server")
+            with Api.server(
+                auto_updates=False, container_name=docker_image_name
+            ) as server:
+                print(f"Server started at {server.url()}")
+                sketch_dir = Path("examples/wasm")
+                with Api.live_client(
+                    sketch_directory=sketch_dir, host=server
+                ) as client:
+                    print(f"Client started at {client.url()}")
+                    while True:
+                        time.sleep(0.1)
+        except KeyboardInterrupt:
+            print("\nExiting from client...")
+            return 1
+
     if args.server:
         print("Running in server only mode.")
         return run_server(args)

fastled/docker_manager.py

@@ -4,6 +4,7 @@ New abstraction for Docker management with improved Ctrl+C handling.
 
 import _thread
 import os
+import platform
 import subprocess
 import sys
 import threading
@@ -97,10 +98,12 @@ class RunningContainer:
 
 class DockerManager:
     def __init__(self) -> None:
+        from docker.errors import DockerException
+
         try:
             self._client: DockerClient | None = None
             self.first_run = False
-        except docker.errors.DockerException as e:
+        except DockerException as e:
             stack = traceback.format_exc()
             warnings.warn(f"Error initializing Docker client: {e}\n{stack}")
             raise
@@ -475,7 +478,7 @@ class DockerManager:
                     print(
                         f"Container {container_name} did not restart within {timeout} seconds."
                     )
-                    container.stop()
+                    container.stop(timeout=0)
                     print(f"Container {container_name} has been stopped.")
                     container.start()
             elif container.status == "paused":
@@ -501,6 +504,7 @@ class DockerManager:
                 tty=True,
                 volumes=volumes,
                 ports=ports,
+                remove=True,
             )
         return container
 
@@ -552,6 +556,8 @@ class DockerManager:
         if isinstance(container, str):
             container = self.get_container(container)
 
+        assert container is not None, "Container not found."
+
         print(f"Attaching to container {container.name}...")
 
         first_run = self.first_run
@@ -570,7 +576,11 @@ class DockerManager:
                 print(f"Could not put container {container_name} to sleep.")
                 return
         try:
-            container.pause()
+            if platform.system() == "Windows":
+                container.pause()
+            else:
+                container.stop()
+                container.remove()
             print(f"Container {container.name} has been suspended.")
         except KeyboardInterrupt:
             print(f"Container {container.name} interrupted by keyboard interrupt.")
@@ -583,21 +593,23 @@ class DockerManager:
         """
         if isinstance(container, str):
             container = self.get_container(container)
+        if not container:
+            print(f"Could not resume container {container}.")
+            return
         try:
             container.unpause()
             print(f"Container {container.name} has been resumed.")
         except Exception as e:
             print(f"Failed to resume container {container.name}: {e}")
 
-    def get_container(self, container_name: str) -> Container:
+    def get_container(self, container_name: str) -> Container | None:
         """
         Get a container by name.
         """
         try:
             return self.client.containers.get(container_name)
         except docker.errors.NotFound:
-            print(f"Container {container_name} not found.")
-            raise
+            return None
 
     def is_container_running(self, container_name: str) -> bool:
         """
@@ -610,6 +622,67 @@ class DockerManager:
             print(f"Container {container_name} not found.")
             return False
 
+    def build_image(
+        self,
+        image_name: str,
+        tag: str,
+        dockerfile_path: Path,
+        build_context: Path,
+        build_args: dict[str, str] | None = None,
+        platform_tag: str = "",
+    ) -> None:
+        """
+        Build a Docker image from a Dockerfile.
+
+        Args:
+            image_name: Name for the image
+            tag: Tag for the image
+            dockerfile_path: Path to the Dockerfile
+            build_context: Path to the build context directory
+            build_args: Optional dictionary of build arguments
+            platform_tag: Optional platform tag (e.g. "-arm64")
+        """
+        if not dockerfile_path.exists():
+            raise FileNotFoundError(f"Dockerfile not found at {dockerfile_path}")
+
+        if not build_context.exists():
+            raise FileNotFoundError(
+                f"Build context directory not found at {build_context}"
+            )
+
+        print(f"Building Docker image {image_name}:{tag} from {dockerfile_path}")
+
+        # Prepare build arguments
+        buildargs = build_args or {}
+        if platform_tag:
+            buildargs["PLATFORM_TAG"] = platform_tag
+
+        try:
+            cmd_list = [
+                "docker",
+                "build",
+                "-t",
+                f"{image_name}:{tag}",
+            ]
+
+            # Add build args
+            for arg_name, arg_value in buildargs.items():
+                cmd_list.extend(["--build-arg", f"{arg_name}={arg_value}"])
+
+            # Add dockerfile and context paths
+            cmd_list.extend(["-f", str(dockerfile_path), str(build_context)])
+
+            cmd_str = subprocess.list2cmdline(cmd_list)
+            print(f"Running command: {cmd_str}")
+
+            # Run the build command
+            subprocess.run(cmd_list, check=True)
+            print(f"Successfully built image {image_name}:{tag}")
+
+        except subprocess.CalledProcessError as e:
+            print(f"Error building Docker image: {e}")
+            raise
+
     def purge(self, image_name: str) -> None:
         """
         Remove all containers and images associated with the given image name.
@@ -626,11 +699,13 @@ class DockerManager:
                 if any(image_name in tag for tag in container.image.tags):
                     print(f"Removing container {container.name}")
                     container.remove(force=True)
+
         except Exception as e:
             print(f"Error removing containers: {e}")
 
         # Remove all images with this name
         try:
+            self.client.images.prune(filters={"dangling": False})
             images = self.client.images.list()
             for image in images:
                 if any(image_name in tag for tag in image.tags):

fastled/keyboard.py

@@ -6,12 +6,10 @@ import time
 from queue import Empty, Queue
 from threading import Thread
 
-_WHITE_SPACE = [" ", "\r", "\n"]
+_WHITE_SPACE = {" ", "\n", "\r"}  # Including Enter key as whitespace
 
 
-# Original space bar, but now also enter key.
 class SpaceBarWatcher:
-
     @classmethod
     def watch_space_bar_pressed(cls, timeout: float = 0) -> bool:
         watcher = cls()
@@ -32,9 +30,7 @@ class SpaceBarWatcher:
         self.process.start()
 
     def _watch_for_space(self) -> None:
-        # Set stdin to non-blocking mode
         fd = sys.stdin.fileno()
-
         if os.name == "nt":  # Windows
             import msvcrt
 
@@ -51,14 +47,13 @@ class SpaceBarWatcher:
                     char = msvcrt.getch().decode()  # type: ignore
                     if char in _WHITE_SPACE:
                         self.queue.put(ord(" "))
-
         else:  # Unix-like systems
             import termios
             import tty
 
             old_settings = termios.tcgetattr(fd)  # type: ignore
             try:
-                tty.setraw(fd)  # type: ignore
+                tty.setcbreak(fd)  # Use cbreak mode to avoid console issues
                 while True:
                     # Check for cancel signal
                     try:
@@ -70,21 +65,22 @@ class SpaceBarWatcher:
                     # Check if there's input ready
                     if select.select([sys.stdin], [], [], 0.1)[0]:
                         char = sys.stdin.read(1)
-                        if ord(char) == 3:  # ctrl+c on mac, maybe also linux?
+                        if ord(char) == 3:  # Ctrl+C
                             _thread.interrupt_main()
                             break
-
                         if char in _WHITE_SPACE:
                             self.queue.put(ord(" "))
             finally:
-                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)  # type: ignore
+                termios.tcsetattr(
+                    fd, termios.TCSADRAIN, old_settings
+                )  # Restore terminal settings
 
     def space_bar_pressed(self) -> bool:
         found = False
         while not self.queue.empty():
             try:
-                key = self.queue.get(block=False, timeout=0.1)
-                if key == ord(" "):
+                key = self.queue.get(block=False)
+                if key == ord(" "):  # Spacebar
                     found = True
                 self.queue.task_done()
             except Empty:

fastled/live_client.py

@@ -45,6 +45,17 @@ class LiveClient:
         )
         return rtn
 
+    def url(self) -> str:
+        """Get the URL of the server."""
+        if isinstance(self.host, CompileServer):
+            return self.host.url()
+        if self.host is None:
+            import warnings
+
+            warnings.warn("TODO: use the actual host.")
+            return "http://localhost:9021"
+        return self.host
+
     @property
     def running(self) -> bool:
         return self.thread is not None and self.thread.is_alive()
@@ -67,3 +78,9 @@ class LiveClient:
         """Finalize the client."""
         self.stop()
         self.thread = None
+
+    def __enter__(self) -> "LiveClient":
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        self.finalize()

fastled/open_browser.py

@@ -17,7 +17,8 @@ def _open_browser_python(fastled_js: Path) -> None:
         subprocess.run(
             [sys.executable, "-m", "nodejs.npm", "install", "-g", "live-server"]
         )
-    os.system(f"cd {fastled_js} && live-server")
+    proc = subprocess.Popen(["cd", fastled_js, "&&", "live-server"])
+    proc.wait()
 
 
 def _find_open_port(start_port: int) -> int:

fastled/parse_args.py

@@ -79,6 +79,12 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="Use localhost for web compilation from an instance of fastled --server, creating it if necessary",
     )
+    parser.add_argument(
+        "--build",
+        "-b",
+        action="store_true",
+        help="Build the wasm compiler image from the FastLED repo",
+    )
     parser.add_argument(
         "--server",
         "-s",

fastled/site/build.py

@@ -189,21 +189,53 @@ INDEX_TEMPLATE = """<!DOCTYPE html>
             const splashScreen = document.querySelector('.splash-screen');
             const splashText = document.querySelector('.splash-text');
             
-            // Wait for font to load
-            document.fonts.ready.then(() => {{
-                // Fade in the text
-                splashText.style.opacity = '1';
-                
-                // Wait for page load plus fade-in time before starting fade-out sequence
-                window.addEventListener('load', () => {{
-                    setTimeout(() => {{
-                        splashScreen.style.opacity = '0';
-                        setTimeout(() => {{
-                            splashScreen.style.display = 'none';
-                        }}, 500); // Remove from DOM after fade completes
-                    }}, 1500); // Wait for load + 1.5s (giving time for fade-in)
+            // Ensure splash screen always gets removed
+            const removeSplashScreen = () => {{
+                splashScreen.style.opacity = '0';
+                setTimeout(() => {{
+                    splashScreen.style.display = 'none';
+                }}, 500);
+            }};
+
+            // Set a maximum time the splash screen can stay
+            const maxSplashTime = setTimeout(removeSplashScreen, 2000); // Reduced from 5000ms to 2000ms
+
+            // Try to do nice fade-in/fade-out when possible
+            try {{
+                // Add a fallback timer in case font loading fails silently
+                const fontTimeout = setTimeout(() => {{
+                    splashText.style.opacity = '1';
+                    setTimeout(removeSplashScreen, 1000);
+                }}, 1000);
+
+                Promise.all([
+                    // Wrap font loading in a timeout promise
+                    Promise.race([
+                        document.fonts.ready,
+                        new Promise((_, reject) => setTimeout(reject, 1500))
+                    ]),
+                    new Promise(resolve => {{
+                        if (document.readyState === 'complete') {{
+                            resolve();
+                        }} else {{
+                            window.addEventListener('load', resolve);
+                        }}
+                    }})
+                ]).then(() => {{
+                    clearTimeout(maxSplashTime);
+                    clearTimeout(fontTimeout);
+                    splashText.style.opacity = '1';
+                    setTimeout(removeSplashScreen, 1500);
+                }}).catch(() => {{
+                    // If either promise fails, ensure splash screen is removed
+                    clearTimeout(maxSplashTime);
+                    removeSplashScreen();
                 }});
-            }});
+            }} catch (e) {{
+                // Final fallback if anything goes wrong
+                console.warn('Splash screen error:', e);
+                removeSplashScreen();
+            }}
             const links = document.querySelectorAll('.example-link');
             const iframe = document.getElementById('example-frame');
             const navPane = document.querySelector('.nav-pane');

{fastled-1.2.5.dist-info → fastled-1.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastled
-Version: 1.2.5
+Version: 1.2.7
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -186,6 +186,14 @@ with Api.server() as server:
     client.stop()
 ```
 
+**Build Docker Image from a local copy of the FastLED repo**
+```python
+from fastapi import Docker, Api
+container_name: str = Docker.build_from_fastled_repo()
+with Api.server(container_name=container_name) as server:
+  ...
+```
+
 # Features
 
 ## Hot reload by default
@@ -266,6 +274,8 @@ A: A big chunk of space is being used by unnecessary javascript `emscripten` bun
 
 # Revisions
 
+  * 1.2.7 - A bunch of fixes for MacOS and probably linux.
+  * 1.2.6 - Now builds image from the project root of FastLED.
   * 1.1.25 - Fix up paths for `--init`
   * 1.1.24 - Mac/Linux now properly responds to ctrl-c when waiting for a key event.
   * 1.1.23 - Fixes missing `live-server` on platforms that don't have it already.

{fastled-1.2.5.dist-info → fastled-1.2.7.dist-info}/RECORD

@@ -1,15 +1,15 @@
-fastled/__init__.py,sha256=hCn09t7Zi2h6idcDO0tKMGRnEzotgPzIPaKh6PdEJLM,5300
-fastled/app.py,sha256=Y1Q5mx4zdQbZ2AaB43ZqJo-w_8ehAaWVNtvTyeCRSaE,1970
+fastled/__init__.py,sha256=R6enLMDw9XKm6b_5ACKqjmSWjdXKCwLjk_1PfZuck0s,10260
+fastled/app.py,sha256=H_uUI5YKF6_cjXN3P5PZwLrkQTlSwKVXvveLEK9Kt4c,2973
 fastled/cli.py,sha256=FjVr31ht0UPlAcmX-84NwfAGMQHTkrCe4o744jCAxiw,375
 fastled/client_server.py,sha256=8L62zNtkGtErDtWrr4XVNsv7ji2zoS5rlqfCnwI3VKU,13177
 fastled/compile_server.py,sha256=Z7rHFs3M6QPbSCsbgHAQDk6GTVAJMMPCXtD4Y0mu8RM,2659
 fastled/compile_server_impl.py,sha256=B_7zjdKHxX2JbNcx26hntwtk8-MyQTs6LMZlpOEuloM,8746
-fastled/docker_manager.py,sha256=J6epThU164XAKe8pDsquLs8ytFFn6QAch2PEVeRNY80,26538
+fastled/docker_manager.py,sha256=Nf0x2BpwT1BvSsi63ZkDhQDMhjiWrjFiXxgowtQMrhM,28955
 fastled/filewatcher.py,sha256=LwEQJkqADsArZyY499RLAer6JjJyDwaQBcAvT7xmp3c,6708
-fastled/keyboard.py,sha256=Uwzfgd85BiZTi5D8f3HRQex9cvOuveagUqjULeTEHw4,3423
-fastled/live_client.py,sha256=_KvqmyUyyGpoYET1Z9CdeUVoIbFjIUWwPcTp5XCQuxY,2075
-fastled/open_browser.py,sha256=uhx_UkZ4URUcFn--ZOGMacjL6gFZHwnMu2qYyok2YzE,1620
-fastled/parse_args.py,sha256=nPHmmkr4_izLdrFYFO6_M3JEkL1uO8NThRi29mUPkKw,6707
+fastled/keyboard.py,sha256=Tf_wJDAhaEWGguoBhWUu_9QRvMCPQEqNZckCsBERcGs,3423
+fastled/live_client.py,sha256=b9mVJ-8w_zoEDwKIlAEUC5Q1La5W5rR6ct-exOcgJec,2561
+fastled/open_browser.py,sha256=nlzNheruTXAYyhqafl2hSoBDL7IdE8P4w43GbwNIMaY,1656
+fastled/parse_args.py,sha256=LD2PpSEhyq3ZqPWa_TJ90Fb-O-yldi7rnen2fWLOPjo,6868
 fastled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
 fastled/project_init.py,sha256=bBt4DwmW5hZkm9ICt9Qk-0Nr_0JQM7icCgH5Iv-bCQs,3984
 fastled/select_sketch_directory.py,sha256=TZdCjl1D7YMKjodMTvDRurPcpAmN3x0TcJxffER2NfM,1314
@@ -21,12 +21,12 @@ fastled/types.py,sha256=PpSEtzFCkWtSIEMC0QXGl966R97vLoryVl3yFW0YhTs,1475
 fastled/util.py,sha256=t4M3NFMhnCzfYbLvIyJi0RdFssZqbTN_vVIaej1WV-U,265
 fastled/web_compile.py,sha256=05PeLJ77QQC6PUKjDhsntBmyBola6QQIfF2k-zjYNE4,10261
 fastled/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
-fastled/site/build.py,sha256=vb1np-3rX5lmPX1Be4OazGtlrsZQYnVDmR2sE4Km7Kw,12536
+fastled/site/build.py,sha256=Eq_u3oRxP88twv5IskKfH3tMr6IuT3I5C5zl94TUECw,13854
 fastled/test/can_run_local_docker_tests.py,sha256=LEuUbHctRhNNFWcvnz2kEGmjDJeXO4c3kNpizm3yVJs,400
 fastled/test/examples.py,sha256=6xPwx_k9_XwYTpI1nk4SrYbsJKHJACd30GzD1epGqhY,1597
-fastled-1.2.5.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-fastled-1.2.5.dist-info/METADATA,sha256=oh6UGEkaee1i-kcAAoLjsj4nW3LAPrppoOhAIDroluo,19733
-fastled-1.2.5.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-fastled-1.2.5.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
-fastled-1.2.5.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
-fastled-1.2.5.dist-info/RECORD,,
+fastled-1.2.7.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.2.7.dist-info/METADATA,sha256=2BBOkJJEcFgY-aojh5RagyJHVwSIgLWKeGRof3bw5ms,20082
+fastled-1.2.7.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+fastled-1.2.7.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.2.7.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
+fastled-1.2.7.dist-info/RECORD,,