fastled 1.2.83__py3-none-any.whl → 1.2.84__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.83"
+__version__ = "1.2.84"
 
 
 class Api:

fastled/client_server.py

@@ -63,6 +63,12 @@ def TEST_BEFORE_COMPILE(url) -> None:
     pass
 
 
+def _chunked_print(stdout: str) -> None:
+    lines = stdout.splitlines()
+    for line in lines:
+        print(line)
+
+
 def _run_web_compiler(
     directory: Path,
     host: str,
@@ -80,7 +86,7 @@ def _run_web_compiler(
     if not web_result.success:
         print("\nWeb compilation failed:")
         print(f"Time taken: {diff:.2f} seconds")
-        print(web_result.stdout)
+        _chunked_print(web_result.stdout)
         # Create error page
         output_dir.mkdir(exist_ok=True)
         error_html = _create_error_html(web_result.stdout)
@@ -117,7 +123,7 @@ def _run_web_compiler(
         # Extract zip contents
         shutil.unpack_archive(temp_zip, output_dir, "zip")
 
-    print(web_result.stdout)
+    _chunked_print(web_result.stdout)
     print_results()
     return web_result
 

fastled/server_flask.py

@@ -1,10 +1,28 @@
 import argparse
+import logging
+import time
 from multiprocessing import Process
 from pathlib import Path
 
-import requests
+import httpx
 from livereload import Server
 
+# Logging configuration
+_ENABLE_LOGGING = False  # Set to False to disable logging
+
+if _ENABLE_LOGGING:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+    logger = logging.getLogger("flask_server")
+else:
+    # Disable all logging
+    logging.getLogger("flask_server").addHandler(logging.NullHandler())
+    logging.getLogger("flask_server").propagate = False
+    logger = logging.getLogger("flask_server")
+    logger.disabled = True
+
 _DRAWF_SOURCE_PREFIX = "drawfsource/js/fastled/src/"
 
 
@@ -24,170 +42,317 @@ def _run_flask_server(
         keyfile: Path to the SSL key file
     """
     try:
-        from flask import Flask, Response, send_from_directory
+        from flask import Flask, Response, request, send_from_directory
 
         app = Flask(__name__)
 
         # 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}")
+        # logger.error(f"Server error: {e}")
+
+        @app.before_request
+        def log_request_info():
+            """Log details of each request before processing"""
+            if _ENABLE_LOGGING:
+                logger.info("=" * 80)
+                logger.info(f"Request: {request.method} {request.url}")
+                logger.info(f"Headers: {dict(request.headers)}")
+                logger.info(f"Args: {dict(request.args)}")
+                if request.is_json:
+                    logger.info(f"JSON: {request.json}")
+                if request.form:
+                    logger.info(f"Form: {dict(request.form)}")
+                logger.info(f"Remote addr: {request.remote_addr}")
+                logger.info(f"User agent: {request.user_agent}")
 
         @app.route("/")
         def serve_index():
-            return send_from_directory(fastled_js, "index.html")
+            if _ENABLE_LOGGING:
+                logger.info("Serving index.html")
+            response = send_from_directory(fastled_js, "index.html")
+            if _ENABLE_LOGGING:
+                logger.info(f"Index response status: {response.status_code}")
+            return response
 
         @app.route("/sourcefiles/<path:path>")
         def serve_source_files(path):
             """Proxy requests to /sourcefiles/* to the compile server"""
             from flask import request
 
+            start_time = time.time()
+            logger.info(f"Serving source file: {path}")
+
             # Forward the request to the compile server
             target_url = f"http://localhost:{compile_server_port}/sourcefiles/{path}"
+            logger.info(f"Forwarding to: {target_url}")
+
+            # Log request headers
+            request_headers = {
+                key: value for key, value in request.headers if key != "Host"
+            }
+            logger.debug(f"Request headers: {request_headers}")
 
             # 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)
-            )
+            try:
+                with httpx.Client() as client:
+                    resp = client.request(
+                        method=request.method,
+                        url=target_url,
+                        headers=request_headers,
+                        content=request.get_data(),
+                        cookies=request.cookies,
+                        follow_redirects=True,
+                    )
 
-            return response
+                logger.info(f"Response status: {resp.status_code}")
+                logger.debug(f"Response headers: {dict(resp.headers)}")
+
+                # Create a Flask Response object from the httpx response
+                raw_data = resp.content
+                logger.debug(f"Response size: {len(raw_data)} bytes")
+
+                response = Response(
+                    raw_data, status=resp.status_code, headers=dict(resp.headers)
+                )
+
+                elapsed_time = time.time() - start_time
+                logger.info(f"Request completed in {elapsed_time:.3f} seconds")
+
+                return response
+
+            except Exception as e:
+                logger.error(f"Error forwarding request: {e}", exc_info=True)
+                return Response(f"Error: {str(e)}", status=500)
 
         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")
+            start_time = time.time()
+            logger.info(f"Processing request: {request.method} {request.url}")
 
             if not path.startswith(_DRAWF_SOURCE_PREFIX):
                 # unexpected
-                print(f"Unexpected path: {path}")
+                error_msg = f"Unexpected path: {path}"
+                logger.error(error_msg)
+                # Logging disabled
                 return Response("Malformed path", status=400)
 
             path = path.replace("drawfsource/js/fastled/src/", "")
+            logger.info(f"Transformed path: {path}")
 
             # 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
+            logger.info(f"Requesting: {target_url}")
+            logger.info(f"Processing dwarfsource request for {path}")
+
+            # Log request headers
+            request_headers = {
+                key: value for key, value in request.headers if key != "Host"
+            }
+            logger.debug(f"Request headers: {request_headers}")
+
+            try:
+                # Forward the request with the same method, headers, and body
+                with httpx.Client() as client:
+                    resp = client.request(
+                        method=request.method,
+                        url=target_url,
+                        headers=request_headers,
+                        content=request.get_data(),
+                        cookies=request.cookies,
+                        follow_redirects=True,
+                    )
+
+                logger.info(f"Response status: {resp.status_code}")
+                logger.debug(f"Response headers: {dict(resp.headers)}")
+
+                # Create a Flask Response object from the httpx response
+                payload = resp.content
+                assert isinstance(payload, bytes)
+
+                # Check if the payload is empty
+                if len(payload) == 0:
+                    logger.error("Empty payload received from compile server")
+                    return Response("Empty payload", status=400)
+
+                response = Response(
+                    payload, status=resp.status_code, headers=dict(resp.headers)
+                )
+
+                elapsed_time = time.time() - start_time
+                logger.info(f"Request completed in {elapsed_time:.3f} seconds")
+
+                return response
+
+            except Exception as e:
+                logger.error(f"Error handling dwarfsource request: {e}", exc_info=True)
+                return Response(f"Error: {str(e)}", status=500)
 
         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")
+            start_time = time.time()
+            logger.info("\n##################################")
+            logger.info(f"# Serving source file /sourcefiles/ {path}")
+            logger.info("##################################\n")
+
+            logger.info(f"Processing sourcefile request for {path}")
 
             # 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
+            logger.info(f"Forwarding to: {target_url}")
+
+            # Log request headers
+            request_headers = {
+                key: value for key, value in request.headers if key != "Host"
+            }
+            logger.debug(f"Request headers: {request_headers}")
+
+            try:
+                # Forward the request with the same method, headers, and body
+                with httpx.Client() as client:
+                    resp = client.request(
+                        method=request.method,
+                        url=target_url,
+                        headers=request_headers,
+                        content=request.get_data(),
+                        cookies=request.cookies,
+                        follow_redirects=True,
+                    )
+
+                logger.info(f"Response status: {resp.status_code}")
+                logger.debug(f"Response headers: {dict(resp.headers)}")
+
+                # Create a Flask Response object from the httpx response
+                raw_data = resp.content
+                logger.debug(f"Response size: {len(raw_data)} bytes")
+
+                response = Response(
+                    raw_data, status=resp.status_code, headers=dict(resp.headers)
+                )
+
+                elapsed_time = time.time() - start_time
+                logger.info(f"Request completed in {elapsed_time:.3f} seconds")
+
+                return response
+
+            except Exception as e:
+                logger.error(f"Error handling sourcefile request: {e}", exc_info=True)
+                return Response(f"Error: {str(e)}", status=500)
 
         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"):
-                response.headers["Content-Type"] = "application/javascript"
-            if path.endswith(".css"):
-                response.headers["Content-Type"] = "text/css"
-            if path.endswith(".wasm"):
-                response.headers["Content-Type"] = "application/wasm"
-            if path.endswith(".json"):
-                response.headers["Content-Type"] = "application/json"
-            if path.endswith(".png"):
-                response.headers["Content-Type"] = "image/png"
-            if path.endswith(".jpg"):
-                response.headers["Content-Type"] = "image/jpeg"
-            if path.endswith(".jpeg"):
-                response.headers["Content-Type"] = "image/jpeg"
-            if path.endswith(".gif"):
-                response.headers["Content-Type"] = "image/gif"
-            if path.endswith(".svg"):
-                response.headers["Content-Type"] = "image/svg+xml"
-            if path.endswith(".ico"):
-                response.headers["Content-Type"] = "image/x-icon"
-            if path.endswith(".html"):
-                response.headers["Content-Type"] = "text/html"
-
-            # now also add headers to force no caching
-            response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
-            response.headers["Pragma"] = "no-cache"
-            response.headers["Expires"] = "0"
-            return response
+            start_time = time.time()
+            logger.info("\n##################################")
+            logger.info(f"# Serving generic file {path}")
+            logger.info("##################################\n")
+
+            logger.info(f"Processing local file request for {path}")
+
+            try:
+                file_path = fastled_js / path
+                logger.info(f"Full file path: {file_path}")
+                logger.info(f"File exists: {file_path.exists()}")
+
+                # Check if file exists before trying to serve it
+                if not file_path.exists():
+                    logger.warning(f"File not found: {file_path}")
+                    return Response(f"File not found: {path}", status=404)
+
+                response = send_from_directory(fastled_js, path)
+
+                # Some servers don't set the Content-Type header for a bunch of files.
+                content_type = None
+                if path.endswith(".js"):
+                    content_type = "application/javascript"
+                elif path.endswith(".css"):
+                    content_type = "text/css"
+                elif path.endswith(".wasm"):
+                    content_type = "application/wasm"
+                elif path.endswith(".json"):
+                    content_type = "application/json"
+                elif path.endswith(".png"):
+                    content_type = "image/png"
+                elif path.endswith(".jpg") or path.endswith(".jpeg"):
+                    content_type = "image/jpeg"
+                elif path.endswith(".gif"):
+                    content_type = "image/gif"
+                elif path.endswith(".svg"):
+                    content_type = "image/svg+xml"
+                elif path.endswith(".ico"):
+                    content_type = "image/x-icon"
+                elif path.endswith(".html"):
+                    content_type = "text/html"
+
+                if content_type:
+                    logger.info(f"Setting Content-Type to {content_type}")
+                    response.headers["Content-Type"] = content_type
+
+                # now also add headers to force no caching
+                response.headers["Cache-Control"] = (
+                    "no-cache, no-store, must-revalidate"
+                )
+                response.headers["Pragma"] = "no-cache"
+                response.headers["Expires"] = "0"
+
+                logger.info(f"Response status: {response.status_code}")
+                logger.debug(f"Response headers: {dict(response.headers)}")
+
+                elapsed_time = time.time() - start_time
+                logger.info(f"Request completed in {elapsed_time:.3f} seconds")
+
+                return response
+
+            except Exception as e:
+                logger.error(f"Error serving local file {path}: {e}", exc_info=True)
+                # Check if this is a FileNotFoundError (which can happen with send_from_directory)
+                if isinstance(e, FileNotFoundError):
+                    return Response(f"File not found: {path}", status=404)
+                return Response(f"Error serving file: {str(e)}", status=500)
 
         @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)
-
+            logger.info(f"Received request for path: {path}")
+
+            try:
+                if path.startswith("drawfsource/"):
+                    logger.info(f"Handling as drawfsource: {path}")
+                    return handle_dwarfsource(path)
+                elif path.startswith("sourcefiles/"):
+                    logger.info(f"Handling as sourcefiles: {path}")
+                    return handle_sourcefile(path)
+                else:
+                    logger.info(f"Handling as local file: {path}")
+                    return handle_local_file_fetch(path)
+            except Exception as e:
+                logger.error(f"Error in serve_files for {path}: {e}", exc_info=True)
+                return Response(f"Server error: {str(e)}", status=500)
+
+        @app.errorhandler(Exception)
+        def handle_exception(e):
+            """Log any uncaught exceptions"""
+            logger.error(f"Unhandled exception: {e}", exc_info=True)
+            return Response(f"Server error: {str(e)}", status=500)
+
+        logger.info("Setting up livereload server")
         server = Server(app.wsgi_app)
         # Watch index.html for changes
         server.watch(str(fastled_js / "index.html"))
         # server.watch(str(fastled_js / "index.js"))
         # server.watch(str(fastled_js / "index.css"))
         # Start the server
+        logger.info(f"Starting server on port {port}")
         server.serve(port=port, debug=True)
     except KeyboardInterrupt:
+        logger.info("Server stopped by keyboard interrupt")
         import _thread
 
         _thread.interrupt_main()
     except Exception as e:
-        print(f"Failed to run Flask server: {e}")
+        logger.error(f"Failed to run Flask server: {e}", exc_info=True)
+        logger.info("Flask server thread running")
         import _thread
 
         _thread.interrupt_main()
@@ -202,15 +367,24 @@ def run_flask_in_thread(
 ) -> None:
     """Run the Flask server."""
     try:
-        _run_flask_server(cwd, port, compile_server_port, certfile, keyfile)
-        import warnings
+        if _ENABLE_LOGGING:
+            logger.info(f"Starting Flask server thread on port {port}")
+            logger.info(f"Serving files from {cwd}")
+            logger.info(f"Compile server port: {compile_server_port}")
+            if certfile:
+                logger.info(f"Using SSL certificate: {certfile}")
+            if keyfile:
+                logger.info(f"Using SSL key: {keyfile}")
 
-        warnings.warn("Flask server has stopped")
+        _run_flask_server(cwd, port, compile_server_port, certfile, keyfile)
     except KeyboardInterrupt:
+        logger.info("Flask server thread stopped by keyboard interrupt")
         import _thread
 
         _thread.interrupt_main()
         pass
+    except Exception as e:
+        logger.error(f"Error in Flask server thread: {e}", exc_info=True)
 
 
 def parse_args() -> argparse.Namespace:
@@ -249,18 +423,39 @@ def run_flask_server_process(
     keyfile: Path | None = None,
 ) -> Process:
     """Run the Flask server in a separate process."""
+    if _ENABLE_LOGGING:
+        logger.info(f"Starting Flask server process on port {port}")
+        logger.info(f"Serving files from {cwd}")
+        logger.info(f"Compile server port: {compile_server_port}")
+
     process = Process(
         target=run_flask_in_thread,
         args=(port, cwd, compile_server_port, certfile, keyfile),
     )
     process.start()
+    if _ENABLE_LOGGING:
+        logger.info(f"Flask server process started with PID {process.pid}")
     return process
 
 
 def main() -> None:
     """Main function."""
+    if _ENABLE_LOGGING:
+        logger.info("Starting main function")
     args = parse_args()
-    run_flask_in_thread(args.port, args.fastled_js, args.certfile, args.keyfile)
+    if _ENABLE_LOGGING:
+        logger.info(f"Arguments: port={args.port}, fastled_js={args.fastled_js}")
+        if args.certfile:
+            logger.info(f"Using SSL certificate: {args.certfile}")
+        if args.keyfile:
+            logger.info(f"Using SSL key: {args.keyfile}")
+        logger.warning("Note: main() is missing compile_server_port parameter")
+
+    # Note: This call is missing the compile_server_port parameter
+    # This is a bug in the original code
+    run_flask_in_thread(args.port, args.fastled_js, 0, args.certfile, args.keyfile)
+    if _ENABLE_LOGGING:
+        logger.info("Main function completed")
 
 
 if __name__ == "__main__":

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

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

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

@@ -1,9 +1,9 @@
-fastled/__init__.py,sha256=GFW1WwdYsAv_gygWIQ047oPRT6sjzh7WgDAYVNyInSo,7044
+fastled/__init__.py,sha256=hVVZOZS8MY35SzgumbD6jMLfUY0Kg34cBiADzA5cV3Q,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=xQIWJEejZtafCnO2fnO4k_owIzPydvXpEJTjVHpzMlA,17183
+fastled/client_server.py,sha256=4oRDccFMifTZPPtOYIfo4xJBJ8oE7gylVF75Rhytwig,17319
 fastled/compile_server.py,sha256=sRiXYzw7lv9vcWJWGPUkzOGZPmvZGV_TGwbHYoRc15s,3155
 fastled/compile_server_impl.py,sha256=t7y19DDB0auH1MmYLCi4yjc_ZyDUJ-WHy14QWTJ-pq8,13043
 fastled/docker_manager.py,sha256=SC_qV6grNTGh0QD1ubKrULQblrN-2PORocISlaZg9NQ,35156
@@ -17,7 +17,7 @@ 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_flask.py,sha256=qPY72qJ4qOI3Llj3VG0CGvEnJ0ibMcprykAG6o9Sexk,9050
+fastled/server_flask.py,sha256=a8IOX7cgXB9agwF9hlMuAk5fNMAoclSprl0iECcH4qo,17617
 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
@@ -33,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.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-1.2.84.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.2.84.dist-info/METADATA,sha256=C02EyZg2HxA80WF2AV5tcPt7kxys7h9caPt_gYiEQCM,21940
+fastled-1.2.84.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+fastled-1.2.84.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.2.84.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
+fastled-1.2.84.dist-info/RECORD,,