fastled 1.4.45__py3-none-any.whl → 1.4.47__py3-none-any.whl

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.45"
+__version__ = "1.4.47"
 
 __version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

fastled/app.py

@@ -121,7 +121,7 @@ def main() -> int:
             sketch_list: list[Path] = find_sketch_directories()
             if sketch_list:
                 maybe_dir: str | None = select_sketch_directory(
-                    sketch_list, cwd_looks_like_fastled_repo
+                    sketch_list, cwd_looks_like_fastled_repo, is_followup=True
                 )
                 if maybe_dir is not None:
                     directory = Path(maybe_dir)

fastled/client_server.py

@@ -452,7 +452,15 @@ def run_client(
     ) -> tuple[bool, CompileResult]:
         changed_files = debounced_sketch_watcher.get_all_changes()
         if changed_files:
-            print(f"\nChanges detected in {changed_files}")
+            # Filter out any fastled_js changes that slipped through
+            sketch_changes = [
+                f for f in changed_files if "fastled_js" not in Path(f).parts
+            ]
+            if not sketch_changes:
+                # All changes were in fastled_js, ignore them
+                return False, last_compiled_result
+            print(f"\nChanges detected in {sketch_changes}")
+            print("Compiling...")
             last_hash_value = last_compiled_result.hash_value
             out = compile_function(last_hash_value=last_hash_value)
             if not out.success:

fastled/parse_args.py

@@ -8,6 +8,7 @@ from fastled.project_init import project_init
 from fastled.select_sketch_directory import select_sketch_directory
 from fastled.settings import DEFAULT_URL, IMAGE_NAME
 from fastled.sketch import (
+    find_sketch_by_partial_name,
     find_sketch_directories,
     looks_like_fastled_repo,
     looks_like_sketch_directory,
@@ -368,7 +369,7 @@ def parse_args() -> Args:
                 print("Searching for sketch directories...")
                 sketch_directories = find_sketch_directories(maybe_sketch_dir)
                 selected_dir = select_sketch_directory(
-                    sketch_directories, cwd_is_fastled
+                    sketch_directories, cwd_is_fastled, is_followup=True
                 )
                 if selected_dir:
                     print(f"Using sketch directory: {selected_dir}")
@@ -378,10 +379,24 @@ def parse_args() -> Args:
                         "\nYou either need to specify a sketch directory or run in --server mode."
                     )
                     sys.exit(1)
-        elif args.directory is not None and os.path.isfile(args.directory):
-            dir_path = Path(args.directory).parent
-            if looks_like_sketch_directory(dir_path):
-                print(f"Using sketch directory: {dir_path}")
-                args.directory = str(dir_path)
+        elif args.directory is not None:
+            # Check if directory is a file path
+            if os.path.isfile(args.directory):
+                dir_path = Path(args.directory).parent
+                if looks_like_sketch_directory(dir_path):
+                    print(f"Using sketch directory: {dir_path}")
+                    args.directory = str(dir_path)
+            # Check if directory exists as a path
+            elif not os.path.exists(args.directory):
+                # Directory doesn't exist - try partial name matching
+                try:
+                    matched_dir = find_sketch_by_partial_name(args.directory)
+                    print(
+                        f"Matched '{args.directory}' to sketch directory: {matched_dir}"
+                    )
+                    args.directory = str(matched_dir)
+                except ValueError as e:
+                    print(f"Error: {e}")
+                    sys.exit(1)
 
     return Args.from_namespace(args)

fastled/print_filter.py

@@ -1,52 +1,52 @@
-import re
-from abc import ABC, abstractmethod
-from enum import Enum
-
-
-class PrintFilter(ABC):
-    """Abstract base class for filtering text output."""
-
-    def __init__(self, echo: bool = True) -> None:
-        self.echo = echo
-
-    @abstractmethod
-    def filter(self, text: str) -> str:
-        """Filter the text according to implementation-specific rules."""
-        pass
-
-    def print(self, text: str | bytes) -> str:
-        """Prints the text to the console after filtering."""
-        if isinstance(text, bytes):
-            text = text.decode("utf-8")
-        text = self.filter(text)
-        if self.echo:
-            print(text, end="")
-        return text
-
-
-def _handle_ino_cpp(line: str) -> str:
-    if ".ino.cpp" in line[0:30]:
-        # Extract the filename without path and extension
-        match = re.search(r"src/([^/]+)\.ino\.cpp", line)
-        if match:
-            filename = match.group(1)
-            # Replace with examples/Filename/Filename.ino format
-            line = line.replace(
-                f"src/{filename}.ino.cpp", f"examples/{filename}/{filename}.ino"
-            )
-        else:
-            # Fall back to simple extension replacement if regex doesn't match
-            line = line.replace(".ino.cpp", ".ino")
-    return line
-
-
-class PrintFilterDefault(PrintFilter):
-    """Provides default filtering for FastLED output."""
-
-    def filter(self, text: str) -> str:
-        return text
-
-
-class CompileOrLink(Enum):
-    COMPILE = "compile"
-    LINK = "link"
+import re
+from abc import ABC, abstractmethod
+from enum import Enum
+
+
+class PrintFilter(ABC):
+    """Abstract base class for filtering text output."""
+
+    def __init__(self, echo: bool = True) -> None:
+        self.echo = echo
+
+    @abstractmethod
+    def filter(self, text: str) -> str:
+        """Filter the text according to implementation-specific rules."""
+        pass
+
+    def print(self, text: str | bytes) -> str:
+        """Prints the text to the console after filtering."""
+        if isinstance(text, bytes):
+            text = text.decode("utf-8")
+        text = self.filter(text)
+        if self.echo:
+            print(text, end="")
+        return text
+
+
+def _handle_ino_cpp(line: str) -> str:
+    if ".ino.cpp" in line[0:30]:
+        # Extract the filename without path and extension
+        match = re.search(r"src/([^/]+)\.ino\.cpp", line)
+        if match:
+            filename = match.group(1)
+            # Replace with examples/Filename/Filename.ino format
+            line = line.replace(
+                f"src/{filename}.ino.cpp", f"examples/{filename}/{filename}.ino"
+            )
+        else:
+            # Fall back to simple extension replacement if regex doesn't match
+            line = line.replace(".ino.cpp", ".ino")
+    return line
+
+
+class PrintFilterDefault(PrintFilter):
+    """Provides default filtering for FastLED output."""
+
+    def filter(self, text: str) -> str:
+        return text
+
+
+class CompileOrLink(Enum):
+    COMPILE = "compile"
+    LINK = "link"

fastled/select_sketch_directory.py

@@ -101,13 +101,11 @@ def select_sketch_directory(
         print(f"\nUsing sketch directory: {sketch_directories[0]}")
         return str(sketch_directories[0])
     elif len(sketch_directories) > 1:
-        # On first scan with >4 options, don't prompt - return None to signal ambiguity
+        # First scan with >4 directories: return None (too many to auto-select)
         if not is_followup and len(sketch_directories) > 4:
-            print(f"\nFound {len(sketch_directories)} sketch directories.")
-            print("Please specify a sketch directory to avoid ambiguity.")
             return None
 
-        # Otherwise, prompt user to disambiguate
+        # Prompt user to disambiguate
         result = _disambiguate_user_choice(
             sketch_directories,
             option_to_str=lambda x: str(x),

fastled/sketch.py

@@ -100,3 +100,103 @@ def looks_like_sketch_directory(directory: Path | str | None, quick=False) -> bo
     if platformini_file:
         return True
     return False
+
+
+def find_sketch_by_partial_name(
+    partial_name: str, search_dir: Path | None = None
+) -> Path | None:
+    """
+    Find a sketch directory by partial name match.
+
+    Args:
+        partial_name: Partial name to match against sketch directories
+        search_dir: Directory to search in (defaults to current directory)
+
+    Returns:
+        Path to the matching sketch directory, or None if no unique match found
+
+    Raises:
+        ValueError: If multiple matches are found with no clear best match, or no matches found
+    """
+    if search_dir is None:
+        search_dir = Path(".")
+
+    # First, find all sketch directories
+    sketch_directories = find_sketch_directories(search_dir)
+
+    # Normalize the partial name to use forward slashes for cross-platform matching
+    partial_name_normalized = partial_name.replace("\\", "/").lower()
+
+    # Get the set of characters in the partial name for similarity check
+    partial_chars = set(partial_name_normalized)
+
+    # Find matches where the partial name appears in the path
+    matches = []
+    for sketch_dir in sketch_directories:
+        # Normalize the sketch directory path to use forward slashes
+        sketch_str_normalized = str(sketch_dir).replace("\\", "/").lower()
+
+        # Character similarity check: at least 50% of partial name chars must be in target
+        target_chars = set(sketch_str_normalized)
+        matching_chars = partial_chars & target_chars
+        similarity = (
+            len(matching_chars) / len(partial_chars) if len(partial_chars) > 0 else 0
+        )
+
+        # Check if partial_name matches the directory name or any part of the path
+        # AND has sufficient character similarity
+        if partial_name_normalized in sketch_str_normalized and similarity >= 0.5:
+            matches.append(sketch_dir)
+
+    if len(matches) == 0:
+        # Check if this is a total mismatch (low character similarity with all sketches)
+        all_low_similarity = True
+        for sketch_dir in sketch_directories:
+            sketch_str_normalized = str(sketch_dir).replace("\\", "/").lower()
+            target_chars = set(sketch_str_normalized)
+            matching_chars = partial_chars & target_chars
+            similarity = (
+                len(matching_chars) / len(partial_chars)
+                if len(partial_chars) > 0
+                else 0
+            )
+            if similarity > 0.5:
+                all_low_similarity = False
+                break
+
+        if all_low_similarity and len(sketch_directories) > 0:
+            # List all available sketches
+            sketches_str = "\n  ".join(str(s) for s in sketch_directories)
+            raise ValueError(
+                f"'{partial_name}' does not look like any of the available sketches.\n\n"
+                f"Available sketches:\n  {sketches_str}"
+            )
+        else:
+            raise ValueError(f"No sketch directory found matching '{partial_name}'")
+    elif len(matches) == 1:
+        return matches[0]
+    else:
+        # Multiple matches - try to find the best match
+        # Best match criteria: exact match of the final directory name
+        exact_matches = []
+        for match in matches:
+            # Get the final directory name
+            final_dir_name = match.name.lower()
+            if final_dir_name == partial_name_normalized:
+                exact_matches.append(match)
+
+        if len(exact_matches) == 1:
+            # Found exactly one exact match - this is the best match
+            return exact_matches[0]
+        elif len(exact_matches) > 1:
+            # Multiple exact matches - still ambiguous
+            matches_str = "\n  ".join(str(m) for m in exact_matches)
+            raise ValueError(
+                f"Multiple sketch directories found matching '{partial_name}':\n  {matches_str}"
+            )
+        else:
+            # No exact match - ambiguous partial matches
+            matches_str = "\n  ".join(str(m) for m in matches)
+            raise ValueError(
+                f"Multiple sketch directories found matching '{partial_name}':\n  {matches_str}"
+            )

fastled/version.py

@@ -1,41 +1,41 @@
-from concurrent.futures import Future, ThreadPoolExecutor
-
-import httpx
-
-from fastled.__version__ import __version_url_latest__
-
-
-def _fetch_version() -> str | Exception:
-    """
-    Helper function to fetch the latest version from the GitHub repository.
-    """
-    try:
-        response = httpx.get(__version_url_latest__)
-        response.raise_for_status()
-        # Extract the version string from the response text
-        version_line = response.text.split("__version__ = ")[1].split('"')[1]
-        return version_line
-    except Exception as e:
-        return e
-
-
-def get_latest_version() -> Future[str | Exception]:
-    """
-    Fetch the latest version from the GitHub repository.
-    Returns a future that will resolve with the version string or an exception.
-    """
-    executor = ThreadPoolExecutor()
-    return executor.submit(_fetch_version)
-
-
-def unit_test() -> None:
-    future = get_latest_version()
-    latest_version = future.result()  # Wait for the future to complete
-    if isinstance(latest_version, Exception):
-        print(f"Error fetching latest version: {latest_version}")
-    else:
-        print(f"Latest version: {latest_version}")
-
-
-if __name__ == "__main__":
-    unit_test()
+from concurrent.futures import Future, ThreadPoolExecutor
+
+import httpx
+
+from fastled.__version__ import __version_url_latest__
+
+
+def _fetch_version() -> str | Exception:
+    """
+    Helper function to fetch the latest version from the GitHub repository.
+    """
+    try:
+        response = httpx.get(__version_url_latest__)
+        response.raise_for_status()
+        # Extract the version string from the response text
+        version_line = response.text.split("__version__ = ")[1].split('"')[1]
+        return version_line
+    except Exception as e:
+        return e
+
+
+def get_latest_version() -> Future[str | Exception]:
+    """
+    Fetch the latest version from the GitHub repository.
+    Returns a future that will resolve with the version string or an exception.
+    """
+    executor = ThreadPoolExecutor()
+    return executor.submit(_fetch_version)
+
+
+def unit_test() -> None:
+    future = get_latest_version()
+    latest_version = future.result()  # Wait for the future to complete
+    if isinstance(latest_version, Exception):
+        print(f"Error fetching latest version: {latest_version}")
+    else:
+        print(f"Latest version: {latest_version}")
+
+
+if __name__ == "__main__":
+    unit_test()

fastled/web_compile.py

@@ -437,21 +437,23 @@ def web_compile(
             response, zip_result, start_time, zip_time, libfastled_time, sketch_time
         )
 
-    except ConnectionError as e:
-        _print_banner(str(e))
+    except KeyboardInterrupt:
+        print("Keyboard interrupt")
+        raise
+    except (ConnectionError, httpx.RemoteProtocolError, httpx.RequestError) as e:
+        # Handle connection and server disconnection issues
+        error_msg = f"Server connection error: {e}"
+        _print_banner(error_msg)
         return CompileResult(
             success=False,
-            stdout=str(e),
+            stdout=error_msg,
             hash_value=None,
             zip_bytes=b"",
             zip_time=zip_time,
             libfastled_time=libfastled_time,
             sketch_time=sketch_time,
-            response_processing_time=0.0,  # No response processing in connection error case
+            response_processing_time=0.0,
         )
-    except KeyboardInterrupt:
-        print("Keyboard interrupt")
-        raise
     except httpx.HTTPError as e:
         print(f"Error: {e}")
         return CompileResult(