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

fastled/sketch.py

@@ -4,7 +4,9 @@ from pathlib import Path
 _MAX_FILES_SEARCH_LIMIT = 10000
 
 
-def find_sketch_directories(directory: Path) -> list[Path]:
+def find_sketch_directories(directory: Path | None = None) -> list[Path]:
+    if directory is None:
+        directory = Path(".")
     file_count = 0
     sketch_directories: list[Path] = []
     # search all the paths one level deep
@@ -23,10 +25,27 @@ def find_sketch_directories(directory: Path) -> 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
@@ -60,7 +79,7 @@ def get_sketch_files(directory: Path) -> list[Path]:
     return files
 
 
-def looks_like_fastled_repo(directory: Path) -> bool:
+def looks_like_fastled_repo(directory: Path = Path(".")) -> bool:
     libprops = directory / "library.properties"
     if not libprops.exists():
         return False
@@ -72,7 +91,10 @@ def _lots_and_lots_of_files(directory: Path) -> bool:
     return len(get_sketch_files(directory)) > 100
 
 
-def looks_like_sketch_directory(directory: Path, quick=False) -> bool:
+def looks_like_sketch_directory(directory: Path | str | None, quick=False) -> bool:
+    if directory is None:
+        return False
+    directory = Path(directory)
     if looks_like_fastled_repo(directory):
         print("Directory looks like the FastLED repo")
         return False
@@ -95,3 +117,103 @@ def looks_like_sketch_directory(directory: Path, quick=False) -> bool:
     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

@@ -3,6 +3,49 @@ from pathlib import Path
 from rapidfuzz import fuzz
 
 
+def _filter_out_obvious_bad_choices(
+    input_str: str, string_list: list[str]
+) -> list[str]:
+    """
+    Filter out strings that are too different from the input string.
+    This is a heuristic and may not be perfect.
+    """
+    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.lower())
+        common_chars = input_chars.intersection(s_chars)
+        if len(common_chars) >= len(input_chars) / 2:
+            filtered_list.append(s)
+    return filtered_list
+
+
+def is_in_order_match(input_str: str, other: str) -> bool:
+    """
+    Check if the input string is an in-order match for any string in the list.
+    An in-order match means that the characters of the input string appear
+    in the same order in the string from the list, ignoring spaces in the input.
+    """
+
+    # Remove spaces from input string for matching
+    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):
+        if input_chars[input_index] == other_chars[other_index]:
+            input_index += 1
+        other_index += 1
+    # If we reached the end of the input string, it means all characters were found in order
+    if input_index == len(input_chars):
+        return True
+    return False
+
+
 # Returns the min distance strings. If there is a tie, it returns
 # all the strings that have the same min distance.
 # Returns a tuple of index and string.
@@ -13,19 +56,179 @@ def string_diff(
     def normalize(s: str) -> str:
         return s.lower() if ignore_case else s
 
-    # distances = [
-    #     #Levenshtein.distance(normalize(input_string), normalize(s)) for s in string_list
-    #     fuzz.partial_ratio(normalize(input_string), normalize(s)) for s in string_list
-    # ]
+    # 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:
+        map_string = {s.lower(): s for s in string_list}
+    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.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
+    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.
+    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):
         if d == min_distance:
-            out.append((i, string_list[i]))
+            s = string_list[i]
+            s_mapped = map_string.get(s, s)
+            out.append((i, s_mapped))
 
     return out
 
@@ -33,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

@@ -1,8 +1,10 @@
-import argparse
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any
 
+from fastled.args import Args
+from fastled.print_filter import PrintFilterDefault
+
 
 @dataclass
 class CompileResult:
@@ -10,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
@@ -17,6 +23,11 @@ class CompileResult:
     def to_dict(self) -> dict[str, Any]:
         return self.__dict__.copy()
 
+    def __post_init__(self):
+        # Filter the stdout.
+        pf = PrintFilterDefault(echo=False)
+        self.stdout = pf.print(self.stdout)
+
 
 class CompileServerError(Exception):
     """Error class for failing to instantiate CompileServer."""
@@ -38,7 +49,7 @@ class BuildMode(Enum):
             raise ValueError(f"BUILD_MODE must be one of {valid_modes}, got {mode_str}")
 
     @staticmethod
-    def from_args(args: argparse.Namespace) -> "BuildMode":
+    def from_args(args: Args) -> "BuildMode":
         if args.debug:
             return BuildMode.DEBUG
         elif args.release:
@@ -59,3 +70,12 @@ class Platform(Enum):
             raise ValueError(
                 f"Platform must be one of {valid_modes}, got {platform_str}"
             )
+
+
+@dataclass
+class FileResponse:
+    """File response from the server."""
+
+    filename: str
+    content: str
+    mimetype: str

fastled/util.py

@@ -8,3 +8,81 @@ def hash_file(file_path: Path) -> str:
         for chunk in iter(lambda: f.read(4096), b""):
             hasher.update(chunk)
     return hasher.hexdigest()
+
+
+def banner_string(msg: str) -> str:
+    lines = msg.splitlines()
+    max_length = max(len(line) for line in lines)
+    border = "#" * (max_length + 4)
+    out: list[str] = []
+    out.append(border)
+    for line in lines:
+        out.append(f"# {line} " + " " * (max_length - len(line)) + "#")
+    out.append(border)
+    outstr = "\n".join(out)
+    return f"\n{outstr}\n"
+
+
+def print_banner(msg: str) -> None:
+    """Print a message in a banner format."""
+    print(banner_string(msg))
+
+
+def port_is_free(port: int) -> bool:
+    """Check if a port is free."""
+    import socket
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        try:
+            _ = sock.bind(("localhost", port)) and sock.bind(("0.0.0.0", port))
+            return True
+        except OSError:
+            return False
+
+
+def find_free_port(start_port: int, end_port: int) -> int | None:
+    """Find a free port on the system."""
+
+    for port in range(start_port, end_port):
+        if port_is_free(port):
+            return port
+    import warnings
+
+    warnings.warn(
+        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

@@ -0,0 +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()