fastled 1.3.30__py3-none-any.whl → 1.4.50__py3-none-any.whl

fastled/sketch.py

@@ -25,10 +25,27 @@ def find_sketch_directories(directory: Path | None = None) -> list[Path]:
             if looks_like_sketch_directory(path, quick=True):
                 sketch_directories.append(path)
             if dir_name.lower() == "examples":
-                for example in path.iterdir():
-                    if example.is_dir():
-                        if looks_like_sketch_directory(example, quick=True):
-                            sketch_directories.append(example)
+                # Recursively search examples directory for sketch directories
+                def search_examples_recursive(
+                    examples_path: Path, depth: int = 0, max_depth: int = 3
+                ):
+                    nonlocal file_count
+                    if depth >= max_depth:
+                        return
+                    for example in examples_path.iterdir():
+                        if example.is_dir():
+                            if str(example.name).startswith("."):
+                                continue
+                            file_count += 1
+                            if file_count > _MAX_FILES_SEARCH_LIMIT:
+                                return
+                            if looks_like_sketch_directory(example, quick=True):
+                                sketch_directories.append(example)
+                            else:
+                                # Keep searching deeper if this isn't a sketch directory
+                                search_examples_recursive(example, depth + 1, max_depth)
+
+                search_examples_recursive(path)
     # make relative to cwd
     sketch_directories = [p.relative_to(directory) for p in sketch_directories]
     return sketch_directories
@@ -100,3 +117,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/string_diff.py

@@ -10,11 +10,14 @@ def _filter_out_obvious_bad_choices(
     Filter out strings that are too different from the input string.
     This is a heuristic and may not be perfect.
     """
-    input_chars = set(input_str)
+    if not input_str.strip():  # Handle empty input
+        return string_list
+
+    input_chars = set(input_str.lower())
     filtered_list = []
     for s in string_list:
         # Check if at least half of the input characters are in the string
-        s_chars = set(s)
+        s_chars = set(s.lower())
         common_chars = input_chars.intersection(s_chars)
         if len(common_chars) >= len(input_chars) / 2:
             filtered_list.append(s)
@@ -29,8 +32,8 @@ def is_in_order_match(input_str: str, other: str) -> bool:
     """
 
     # Remove spaces from input string for matching
-    input_chars = [c for c in input_str if c != " "]
-    other_chars = list(other)
+    input_chars = [c.lower() for c in input_str if c != " "]
+    other_chars = [c.lower() for c in other]
     input_index = 0
     other_index = 0
     while input_index < len(input_chars) and other_index < len(other_chars):
@@ -53,6 +56,14 @@ def string_diff(
     def normalize(s: str) -> str:
         return s.lower() if ignore_case else s
 
+    # Handle empty input or empty list
+    if not input_string.strip():
+        # Return all strings with equal distance for empty input
+        return [(i, s) for i, s in enumerate(string_list)]
+
+    if not string_list:
+        return []
+
     map_string: dict[str, str] = {}
 
     if ignore_case:
@@ -60,38 +71,157 @@ def string_diff(
     else:
         map_string = {s: s for s in string_list}
 
+    original_string_list = string_list.copy()
     if ignore_case:
         string_list = [s.lower() for s in string_list]
         input_string = input_string.lower()
 
+    # Check for exact matches, but also check if there are other substring matches
+    exact_matches = [s for s in string_list if s == input_string]
+    substring_matches = [s for s in string_list if input_string in s]
+
+    # If there's exactly one exact match, and there are substring matches,
+    # check if we should prioritize the exact match or return all variants
+    if len(exact_matches) == 1 and len(substring_matches) > 1:
+        exact_match = exact_matches[0]
+        other_substring_matches = [s for s in substring_matches if s != exact_match]
+
+        # Prioritize exact match only if it appears at the start of other matches
+        # AND those matches have a camelCase boundary (indicating compound words)
+        # We need to use the original (non-lowercased) strings for camelCase detection
+        should_prioritize_exact = True
+        original_exact_match = map_string[exact_match]  # Get the original casing
+
+        for other_match in other_substring_matches:
+            original_other_match = map_string[other_match]  # Get the original casing
+
+            if not original_other_match.lower().startswith(
+                original_exact_match.lower()
+            ):
+                # If the exact match isn't at the start, don't prioritize
+                should_prioritize_exact = False
+                break
+
+            # Check for camelCase boundary after the exact match in the ORIGINAL string
+            remainder = original_other_match[len(original_exact_match) :]
+            if remainder and remainder[0].isupper():
+                # Only prioritize exact match if the exact match is very short (4 chars or less)
+                # AND the remainder suggests a different concept
+                if len(original_exact_match) <= 4 and len(remainder) >= 6:
+                    # This looks like a camelCase compound word (e.g., "wasm" -> "WasmScreenCoords")
+                    continue
+                else:
+                    # This looks like a variant (e.g., "Noise" -> "NoisePlayground", "Fire2012" -> "Fire2012WithPalette")
+                    should_prioritize_exact = False
+                    break
+            else:
+                # This looks like a variant/extension (e.g., "Blur" -> "Blur2d")
+                should_prioritize_exact = False
+                break
+
+        if should_prioritize_exact:
+            out: list[tuple[float, str]] = []
+            for i, s in enumerate(exact_matches):
+                s_mapped = map_string.get(s, s)
+                out.append((i, s_mapped))
+            return out
+        else:
+            # Apply character count filtering only for very specific compound terms
+            # Main criteria: contains numbers AND ends with numbers/letters (like Wave2d, Fire2012)
+            original_exact_match = map_string[exact_match]
+            should_apply_char_filter = (
+                len(original_exact_match) >= 5  # Longer terms
+                and any(c.isdigit() for c in original_exact_match)  # Contains numbers
+                and (
+                    original_exact_match[-1].isdigit()
+                    or original_exact_match[-1].islower()
+                )  # Ends specifically (compound pattern)
+            )
+
+            if should_apply_char_filter:
+                # Filter substring matches based on extra character count
+                # Use a more lenient threshold for shorter base terms
+                if len(original_exact_match) <= 6:
+                    # For short terms, allow more extra chars (e.g., "Wave2d" + "FxWave2d")
+                    MAX_EXTRA_CHARS = min(10, len(original_exact_match) * 2)
+                else:
+                    # For longer terms, allow significant extensions (e.g., "Fire2012" + "Fire2012WithPalette")
+                    MAX_EXTRA_CHARS = 12
+
+                filtered_matches = []
+
+                for s in substring_matches:
+                    original_s = map_string[s]
+                    if s == exact_match:
+                        # Always include the exact match
+                        filtered_matches.append(s)
+                    else:
+                        # Calculate extra characters
+                        extra_chars = len(original_s) - len(original_exact_match)
+                        if extra_chars <= MAX_EXTRA_CHARS:
+                            filtered_matches.append(s)
+
+                # Return filtered matches
+                out: list[tuple[float, str]] = []
+                for i, s in enumerate(filtered_matches):
+                    s_mapped = map_string.get(s, s) or s
+                    out.append((i, s_mapped))
+                return out
+            else:
+                # Return all substring matches (original behavior for base terms)
+                out: list[tuple[float, str]] = []
+                for i, s in enumerate(substring_matches):
+                    s_mapped = map_string.get(s, s) or s
+                    out.append((i, s_mapped))
+                return out
+
+    # If there's only an exact match and no other substring matches, return just the exact match
+    if exact_matches and len(substring_matches) == 1:
+        out: list[tuple[float, str]] = []
+        for i, s in enumerate(exact_matches):
+            s_mapped = map_string.get(s, s)
+            out.append((i, s_mapped))
+        return out
+
     # Apply set membership filtering for queries with 3+ characters
-    if len(input_string) >= 3:
-        string_list = _filter_out_obvious_bad_choices(input_string, string_list)
+    if len(input_string.strip()) >= 3:
+        filtered = _filter_out_obvious_bad_choices(input_string, string_list)
+        if filtered:  # Only apply filter if it doesn't eliminate everything
+            string_list = filtered
 
     # Second filter: exact substring filtering if applicable
-    is_substring = False
-    for s in string_list:
-        if input_string in s:
-            is_substring = True
-            break
-
-    if is_substring:
-        string_list = [s for s in string_list if input_string in s]
+    if substring_matches:
+        string_list = substring_matches
+        # Return all substring matches
+        out: list[tuple[float, str]] = []
+        for i, s in enumerate(string_list):
+            s_mapped = map_string.get(s, s)
+            out.append((i, s_mapped))
+        return out
 
     # Third filter: in order exact match filtering if applicable.
-    is_in_order = False
-    for s in string_list:
-        if is_in_order_match(input_string, s):
-            is_in_order = True
-            break
-
-    if is_in_order:
-        string_list = [s for s in string_list if is_in_order_match(input_string, s)]
+    in_order_matches = [s for s in string_list if is_in_order_match(input_string, s)]
+    if in_order_matches:
+        string_list = in_order_matches
 
+    # Calculate distances
     distances: list[float] = []
     for s in string_list:
         dist = fuzz.token_sort_ratio(normalize(input_string), normalize(s))
         distances.append(1.0 / (dist + 1.0))
+
+    # Handle case where no strings remain after filtering
+    if not distances:
+        # Fall back to original list and calculate distances
+        string_list = original_string_list.copy()
+        if ignore_case:
+            string_list = [s.lower() for s in string_list]
+
+        distances = []
+        for s in string_list:
+            dist = fuzz.token_sort_ratio(normalize(input_string), normalize(s))
+            distances.append(1.0 / (dist + 1.0))
+
     min_distance = min(distances)
     out: list[tuple[float, str]] = []
     for i, d in enumerate(distances):
@@ -106,10 +236,16 @@ def string_diff(
 def string_diff_paths(
     input_string: str | Path, path_list: list[Path], ignore_case=True
 ) -> list[tuple[float, Path]]:
-    string_list = [str(p) for p in path_list]
-    tmp = string_diff(str(input_string), string_list, ignore_case)
+    # Normalize path separators to forward slashes for consistent comparison
+    string_list = [str(p).replace("\\", "/") for p in path_list]
+    input_str = str(input_string).replace("\\", "/")
+
+    tmp = string_diff(input_str, string_list, ignore_case)
     out: list[tuple[float, Path]] = []
     for i, j in tmp:
-        p = Path(j)
-        out.append((i, p))
+        # Find the original path that matches the normalized result
+        for idx, orig_path in enumerate(path_list):
+            if str(orig_path).replace("\\", "/") == j:
+                out.append((i, orig_path))
+                break
     return out

fastled/test/examples.py

@@ -2,6 +2,8 @@ from tempfile import TemporaryDirectory
 from time import time
 from warnings import warn
 
+from fastled.emoji_util import safe_print
+
 _FILTER = True
 
 
@@ -18,21 +20,21 @@ def test_examples(
         examples.remove("LuminescentGrand")
     with TemporaryDirectory() as tmpdir:
         for example in examples:
-            print(f"Initializing example: {example}")
+            safe_print(f"Initializing example: {example}")
             try:
                 sketch_dir = Api.project_init(example, outputdir=tmpdir, host=host)
             except Exception as e:
                 warn(f"Failed to initialize example: {example}, error: {e}")
                 out[example] = e
                 continue
-            print(f"Project initialized at: {sketch_dir}")
+            safe_print(f"Project initialized at: {sketch_dir}")
             start = time()
-            print(f"Compiling example: {example}")
+            safe_print(f"Compiling example: {example}")
             diff = time() - start
-            print(f"Compilation took: {diff:.2f} seconds")
+            safe_print(f"Compilation took: {diff:.2f} seconds")
             result = Api.web_compile(sketch_dir, host=host)
             if not result.success:
-                print(f"Compilation failed for {example}: {result.stdout}")
+                safe_print(f"Compilation failed for {example}: {result.stdout}")
                 out[example] = Exception(result.stdout)
     return out
 

fastled/types.py

@@ -12,6 +12,10 @@ class CompileResult:
     stdout: str
     hash_value: str | None
     zip_bytes: bytes
+    zip_time: float
+    libfastled_time: float
+    sketch_time: float
+    response_processing_time: float
 
     def __bool__(self) -> bool:
         return self.success

fastled/util.py

@@ -52,3 +52,37 @@ def find_free_port(start_port: int, end_port: int) -> int | None:
         f"No free port found in the range {start_port}-{end_port}. Using {start_port}."
     )
     return None
+
+
+def download_emsdk_headers(base_url: str, filepath: Path) -> None:
+    """Download EMSDK headers from the specified URL and save to filepath.
+
+    Args:
+        base_url: Base URL of the server (e.g., 'http://localhost:8080')
+        filepath: Path where to save the headers ZIP file (must end with .zip)
+
+    Raises:
+        ValueError: If filepath doesn't end with .zip
+        RuntimeError: If download fails or server returns error
+    """
+    if not str(filepath).endswith(".zip"):
+        raise ValueError("Filepath must end with .zip")
+
+    import httpx
+
+    try:
+        timeout = httpx.Timeout(30.0, read=30.0)
+        with httpx.stream(
+            "GET", f"{base_url}/headers/emsdk", timeout=timeout
+        ) as response:
+            if response.status_code == 200:
+                filepath.parent.mkdir(parents=True, exist_ok=True)
+                with open(filepath, "wb") as f:
+                    for chunk in response.iter_bytes(chunk_size=512000):
+                        f.write(chunk)
+            else:
+                raise RuntimeError(
+                    f"Failed to get EMSDK headers: HTTP {response.status_code}"
+                )
+    except Exception as e:
+        raise RuntimeError(f"Error downloading EMSDK headers: {e}") from e

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()