fastled 1.0.15__py2.py3-none-any.whl → 1.0.17__py2.py3-none-any.whl

{fastled → fled}/filewatcher.py

@@ -1,196 +1,146 @@
-"""File system watcher implementation using watchdog
-"""
-
-import hashlib
-import os
-import queue
-import threading
-import time
-from contextlib import redirect_stdout
-from multiprocessing import Process, Queue
-from pathlib import Path
-from queue import Empty
-from typing import Dict, Set
-
-from watchdog.events import FileSystemEvent, FileSystemEventHandler
-from watchdog.observers import Observer
-from watchdog.observers.api import BaseObserver
-
-
-class MyEventHandler(FileSystemEventHandler):
-    def __init__(
-        self,
-        change_queue: queue.Queue,
-        excluded_patterns: Set[str],
-        file_hashes: Dict[str, str],
-    ) -> None:
-        super().__init__()
-        self.change_queue = change_queue
-        self.excluded_patterns = excluded_patterns
-        self.file_hashes = file_hashes
-
-    def _get_file_hash(self, filepath: str) -> str:
-        try:
-            with open(filepath, "rb") as f:
-                return hashlib.md5(f.read()).hexdigest()
-        except Exception:  # pylint: disable=broad-except
-            return ""
-
-    def on_modified(self, event: FileSystemEvent) -> None:
-        if not event.is_directory:
-            path = Path(event.src_path)
-            # Check if any part of the path matches excluded patterns
-            if not any(part in self.excluded_patterns for part in path.parts):
-                new_hash = self._get_file_hash(event.src_path)
-                if new_hash and new_hash != self.file_hashes.get(event.src_path):
-                    self.file_hashes[event.src_path] = new_hash
-                    self.change_queue.put(event.src_path)
-
-
-class FileChangedNotifier(threading.Thread):
-    """Watches a directory for file changes and queues notifications"""
-
-    def __init__(
-        self,
-        path: str,
-        debounce_seconds: float = 1.0,
-        excluded_patterns: list[str] | None = None,
-    ) -> None:
-        """Initialize the notifier with a path to watch
-
-        Args:
-            path: Directory path to watch for changes
-            debounce_seconds: Minimum time between notifications for the same file
-            excluded_patterns: List of directory/file patterns to exclude from watching
-        """
-        super().__init__(daemon=True)
-        self.path = path
-        self.observer: BaseObserver | None = None
-        self.event_handler: MyEventHandler | None = None
-
-        # Combine default and user-provided patterns
-        self.excluded_patterns = (
-            set(excluded_patterns) if excluded_patterns is not None else set()
-        )
-        self.stopped = False
-        self.change_queue: queue.Queue = queue.Queue()
-        self.last_notification: Dict[str, float] = {}
-        self.file_hashes: Dict[str, str] = {}
-        self.debounce_seconds = debounce_seconds
-
-    def stop(self) -> None:
-        """Stop watching for changes"""
-        print("watcher stop")
-        self.stopped = True
-        if self.observer:
-            self.observer.stop()
-            self.observer.join()
-            self.observer = None
-            self.event_handler = None
-
-    def run(self) -> None:
-        """Thread main loop - starts watching for changes"""
-        self.event_handler = MyEventHandler(
-            self.change_queue, self.excluded_patterns, self.file_hashes
-        )
-        self.observer = Observer()
-        self.observer.schedule(self.event_handler, self.path, recursive=True)
-        self.observer.start()
-
-        try:
-            while not self.stopped:
-                time.sleep(0.1)
-        except KeyboardInterrupt:
-            print("File watcher stopped by user.")
-        finally:
-            self.stop()
-
-    def get_next_change(self, timeout: float = 0.001) -> str | None:
-        """Get the next file change event from the queue
-
-        Args:
-            timeout: How long to wait for next change in seconds
-
-        Returns:
-            Changed filepath or None if no change within timeout
-        """
-        try:
-            filepath = self.change_queue.get(timeout=timeout)
-            current_time = time.time()
-
-            # Check if we've seen this file recently
-            last_time = self.last_notification.get(filepath, 0)
-            if current_time - last_time < self.debounce_seconds:
-                return None
-
-            self.last_notification[filepath] = current_time
-            return filepath
-        except KeyboardInterrupt:
-            raise
-        except queue.Empty:
-            return None
-
-    def get_all_changes(self, timeout: float = 0.001) -> list[str]:
-        """Get all file change events from the queue
-
-        Args:
-            timeout: How long to wait for next change in seconds
-
-        Returns:
-            List of changed filepaths
-        """
-        changed_files = []
-        while True:
-            changed_file = self.get_next_change(timeout=timeout)
-            if changed_file is None:
-                break
-            changed_files.append(changed_file)
-        # clear all the changes from the queue
-        self.change_queue.queue.clear()
-        return changed_files
-
-
-def _process_wrapper(root: Path, excluded_patterns: list[str], queue: Queue):
-    with open(os.devnull, "w") as fnull:  # Redirect to /dev/null
-        with redirect_stdout(fnull):
-            watcher = FileChangedNotifier(
-                str(root), excluded_patterns=excluded_patterns
-            )
-            watcher.start()
-            while True:
-                try:
-                    changed_files = watcher.get_all_changes()
-                    for file in changed_files:
-                        queue.put(file)
-                except KeyboardInterrupt:
-                    break
-            watcher.stop()
-
-
-class FileWatcherProcess:
-    def __init__(self, root: Path, excluded_patterns: list[str]) -> None:
-        self.queue: Queue = Queue()
-        self.process = Process(
-            target=_process_wrapper,
-            args=(root, excluded_patterns, self.queue),
-            daemon=True,
-        )
-        self.process.start()
-
-    def stop(self):
-        self.process.terminate()
-        self.process.join()
-        self.queue.close()
-        self.queue.join_thread()
-
-    def get_all_changes(self, timeout: float | None = None) -> list[str]:
-        changed_files = []
-        block = timeout is not None
-
-        while True:
-            try:
-                changed_file = self.queue.get(block=block, timeout=timeout)
-                changed_files.append(changed_file)
-            except Empty:
-                break
-        return changed_files
+"""File system watcher implementation using watchdog
+"""
+
+import hashlib
+import queue
+import threading
+import time
+from pathlib import Path
+from typing import Dict, Set
+
+from watchdog.events import FileSystemEvent, FileSystemEventHandler
+from watchdog.observers import Observer
+from watchdog.observers.api import BaseObserver
+
+
+class MyEventHandler(FileSystemEventHandler):
+    def __init__(
+        self,
+        change_queue: queue.Queue,
+        excluded_patterns: Set[str],
+        file_hashes: Dict[str, str],
+    ) -> None:
+        super().__init__()
+        self.change_queue = change_queue
+        self.excluded_patterns = excluded_patterns
+        self.file_hashes = file_hashes
+
+    def _get_file_hash(self, filepath: str) -> str:
+        try:
+            with open(filepath, "rb") as f:
+                return hashlib.md5(f.read()).hexdigest()
+        except Exception:  # pylint: disable=broad-except
+            return ""
+
+    def on_modified(self, event: FileSystemEvent) -> None:
+        if not event.is_directory:
+            path = Path(event.src_path)
+            # Check if any part of the path matches excluded patterns
+            if not any(part in self.excluded_patterns for part in path.parts):
+                new_hash = self._get_file_hash(event.src_path)
+                if new_hash and new_hash != self.file_hashes.get(event.src_path):
+                    self.file_hashes[event.src_path] = new_hash
+                    self.change_queue.put(event.src_path)
+
+
+class FileChangedNotifier(threading.Thread):
+    """Watches a directory for file changes and queues notifications"""
+
+    def __init__(
+        self,
+        path: str,
+        debounce_seconds: float = 1.0,
+        excluded_patterns: list[str] | None = None,
+    ) -> None:
+        """Initialize the notifier with a path to watch
+
+        Args:
+            path: Directory path to watch for changes
+            debounce_seconds: Minimum time between notifications for the same file
+            excluded_patterns: List of directory/file patterns to exclude from watching
+        """
+        super().__init__(daemon=True)
+        self.path = path
+        self.observer: BaseObserver | None = None
+        self.event_handler: MyEventHandler | None = None
+
+        # Combine default and user-provided patterns
+        self.excluded_patterns = (
+            set(excluded_patterns) if excluded_patterns is not None else set()
+        )
+        self.stopped = False
+        self.change_queue: queue.Queue = queue.Queue()
+        self.last_notification: Dict[str, float] = {}
+        self.file_hashes: Dict[str, str] = {}
+        self.debounce_seconds = debounce_seconds
+
+    def stop(self) -> None:
+        """Stop watching for changes"""
+        print("watcher stop")
+        self.stopped = True
+        if self.observer:
+            self.observer.stop()
+            self.observer.join()
+            self.observer = None
+            self.event_handler = None
+
+    def run(self) -> None:
+        """Thread main loop - starts watching for changes"""
+        self.event_handler = MyEventHandler(
+            self.change_queue, self.excluded_patterns, self.file_hashes
+        )
+        self.observer = Observer()
+        self.observer.schedule(self.event_handler, self.path, recursive=True)
+        self.observer.start()
+
+        try:
+            while not self.stopped:
+                time.sleep(0.1)
+        except KeyboardInterrupt:
+            print("File watcher stopped by user.")
+        finally:
+            self.stop()
+
+    def get_next_change(self, timeout: float = 0.001) -> str | None:
+        """Get the next file change event from the queue
+
+        Args:
+            timeout: How long to wait for next change in seconds
+
+        Returns:
+            Changed filepath or None if no change within timeout
+        """
+        try:
+            filepath = self.change_queue.get(timeout=timeout)
+            current_time = time.time()
+
+            # Check if we've seen this file recently
+            last_time = self.last_notification.get(filepath, 0)
+            if current_time - last_time < self.debounce_seconds:
+                return None
+
+            self.last_notification[filepath] = current_time
+            return filepath
+        except KeyboardInterrupt:
+            raise
+        except queue.Empty:
+            return None
+
+    def get_all_changes(self, timeout: float = 0.001) -> list[str]:
+        """Get all file change events from the queue
+
+        Args:
+            timeout: How long to wait for next change in seconds
+
+        Returns:
+            List of changed filepaths
+        """
+        changed_files = []
+        while True:
+            changed_file = self.get_next_change(timeout=timeout)
+            if changed_file is None:
+                break
+            changed_files.append(changed_file)
+        # clear all the changes from the queue
+        self.change_queue.queue.clear()
+        return changed_files

{fastled → fled}/open_browser.py

@@ -24,11 +24,7 @@ def _open_browser_python(fastled_js: Path, port: int) -> subprocess.Popen:
     ]
 
     # Start the process
-    process = subprocess.Popen(
-        cmd,
-        # stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
+    process = subprocess.Popen(cmd)
     return process
 
 

fled/web_compile.py

@@ -0,0 +1,173 @@
+import shutil
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+import httpx
+
+from fled.build_mode import BuildMode
+
+DEFAULT_HOST = "https://fastled.onrender.com"
+ENDPOINT_COMPILED_WASM = "compile/wasm"
+_TIMEOUT = 60 * 4  # 2 mins timeout
+_AUTH_TOKEN = "oBOT5jbsO4ztgrpNsQwlmFLIKB"
+
+
+@dataclass
+class WebCompileResult:
+    success: bool
+    stdout: str
+    hash_value: str | None
+    zip_bytes: bytes
+
+    def __bool__(self) -> bool:
+        return self.success
+
+
+def _sanitize_host(host: str) -> str:
+    if host.startswith("http"):
+        return host
+    is_local_host = "localhost" in host or "127.0.0.1" in host or "0.0.0.0" in host
+    use_https = not is_local_host
+    if use_https:
+        return host if host.startswith("https://") else f"https://{host}"
+    return host if host.startswith("http://") else f"http://{host}"
+
+
+_CONNECTION_ERROR_MAP: dict[str, bool] = {}
+
+
+def web_compile(
+    directory: Path,
+    host: str | None = None,
+    auth_token: str | None = None,
+    build_mode: BuildMode | None = None,
+    profile: bool = False,
+) -> WebCompileResult:
+    host = _sanitize_host(host or DEFAULT_HOST)
+    auth_token = auth_token or _AUTH_TOKEN
+    # zip up the files
+    print("Zipping files...")
+
+    # Create a temporary zip file
+    with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp_zip:
+        # Create temporary directory for organizing files
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create wasm subdirectory
+            wasm_dir = Path(temp_dir) / "wasm"
+
+            # Copy all files from source to wasm subdirectory, excluding fastled_js
+            def ignore_fastled_js(dir: str, files: list[str]) -> list[str]:
+                if "fastled_js" in dir:
+                    return files
+                if dir.startswith("."):
+                    return files
+                return []
+
+            shutil.copytree(directory, wasm_dir, ignore=ignore_fastled_js)
+            # Create zip archive from the temp directory
+            shutil.make_archive(tmp_zip.name[:-4], "zip", temp_dir)
+
+    print(f"Web compiling on {host}...")
+
+    try:
+        with open(tmp_zip.name, "rb") as zip_file:
+            files = {"file": ("wasm.zip", zip_file, "application/x-zip-compressed")}
+
+            tested = host in _CONNECTION_ERROR_MAP
+            if not tested:
+                test_url = f"{host}/healthz"
+                print(f"Testing connection to {test_url}")
+                timeout = 10
+                with httpx.Client(
+                    transport=httpx.HTTPTransport(local_address="0.0.0.0"),
+                    timeout=timeout,
+                ) as test_client:
+                    test_response = test_client.get(test_url, timeout=timeout)
+                    if test_response.status_code != 200:
+                        print(f"Connection to {test_url} failed")
+                        _CONNECTION_ERROR_MAP[host] = True
+                        return WebCompileResult(
+                            success=False,
+                            stdout="Connection failed",
+                            hash_value=None,
+                            zip_bytes=b"",
+                        )
+                    _CONNECTION_ERROR_MAP[host] = False
+
+            ok = not _CONNECTION_ERROR_MAP[host]
+            if not ok:
+                return WebCompileResult(
+                    success=False,
+                    stdout="Connection failed",
+                    hash_value=None,
+                    zip_bytes=b"",
+                )
+            print(f"Connection to {host} successful")
+            with httpx.Client(
+                transport=httpx.HTTPTransport(local_address="0.0.0.0"),  # forces IPv4
+                timeout=_TIMEOUT,
+            ) as client:
+                url = f"{host}/{ENDPOINT_COMPILED_WASM}"
+                headers = {
+                    "accept": "application/json",
+                    "authorization": auth_token,
+                    "build": (
+                        build_mode.value.lower()
+                        if build_mode
+                        else BuildMode.QUICK.value.lower()
+                    ),
+                    "profile": "true" if profile else "false",
+                }
+                print(f"Compiling on {url}")
+                response = client.post(
+                    url,
+                    files=files,
+                    headers=headers,
+                    timeout=_TIMEOUT,
+                )
+
+                if response.status_code != 200:
+                    json_response = response.json()
+                    detail = json_response.get("detail", "Could not compile")
+                    return WebCompileResult(
+                        success=False, stdout=detail, hash_value=None, zip_bytes=b""
+                    )
+
+                print(f"Response status code: {response}")
+                # Create a temporary directory to extract the zip
+                with tempfile.TemporaryDirectory() as extract_dir:
+                    extract_path = Path(extract_dir)
+
+                    # Write the response content to a temporary zip file
+                    temp_zip = extract_path / "response.zip"
+                    temp_zip.write_bytes(response.content)
+
+                    # Extract the zip
+                    shutil.unpack_archive(temp_zip, extract_path, "zip")
+
+                    # Read stdout from out.txt if it exists
+                    stdout_file = extract_path / "out.txt"
+                    hash_file = extract_path / "hash.txt"
+                    stdout = stdout_file.read_text() if stdout_file.exists() else ""
+                    hash_value = hash_file.read_text() if hash_file.exists() else None
+
+                    return WebCompileResult(
+                        success=True,
+                        stdout=stdout,
+                        hash_value=hash_value,
+                        zip_bytes=response.content,
+                    )
+    except KeyboardInterrupt:
+        print("Keyboard interrupt")
+        raise
+    except httpx.HTTPError as e:
+        print(f"Error: {e}")
+        return WebCompileResult(
+            success=False, stdout=str(e), hash_value=None, zip_bytes=b""
+        )
+    finally:
+        try:
+            Path(tmp_zip.name).unlink()
+        except PermissionError:
+            print("Warning: Could not delete temporary zip file")

fastled/__init__.py

@@ -1,3 +0,0 @@
-"""FastLED Wasm Compiler package."""
-
-__version__ = "1.0.15"

fastled/keyboard.py

@@ -1,91 +0,0 @@
-import os
-import select
-import sys
-import time
-from multiprocessing import Process, Queue
-from queue import Empty
-
-
-class SpaceBarWatcher:
-    def __init__(self) -> None:
-        self.queue: Queue = Queue()
-        self.queue_cancel: Queue = Queue()
-        self.process = Process(target=self._watch_for_space)
-        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
-
-            while True:
-                # Check for cancel signal
-                try:
-                    self.queue_cancel.get(timeout=0.1)
-                    break
-                except Empty:
-                    pass
-
-                # Check if there's input ready
-                if msvcrt.kbhit():  # type: ignore
-                    char = msvcrt.getch().decode()  # type: ignore
-                    if char == " ":
-                        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
-                while True:
-                    # Check for cancel signal
-                    try:
-                        self.queue_cancel.get(timeout=0.1)
-                        break
-                    except Empty:
-                        pass
-
-                    # Check if there's input ready
-                    if select.select([sys.stdin], [], [], 0.1)[0]:
-                        char = sys.stdin.read(1)
-                        if char == " ":
-                            self.queue.put(ord(" "))
-            finally:
-                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)  # type: ignore
-
-    def space_bar_pressed(self) -> bool:
-        found = False
-        while not self.queue.empty():
-            key = self.queue.get()
-            if key == ord(" "):
-                found = True
-        return found
-
-    def stop(self) -> None:
-        self.queue_cancel.put(True)
-        self.process.terminate()
-        self.process.join()
-        self.queue.close()
-        self.queue.join_thread()
-
-
-def main() -> None:
-    watcher = SpaceBarWatcher()
-    try:
-        while True:
-            if watcher.space_bar_pressed():
-                break
-            time.sleep(1)
-    finally:
-        watcher.stop()
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except KeyboardInterrupt:
-        print("Keyboard interrupt detected.")