fastled 1.4.45__tar.gz → 1.4.49__tar.gz

{fastled-1.4.45 → fastled-1.4.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.4.45
+Version: 1.4.49
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -24,6 +24,7 @@ Requires-Dist: livereload
 Requires-Dist: disklru>=2.0.4
 Requires-Dist: playwright>=1.40.0
 Requires-Dist: websockify>=0.13.0
+Requires-Dist: fasteners>=0.20
 Dynamic: home-page
 Dynamic: license-file
 Dynamic: maintainer

{fastled-1.4.45 → fastled-1.4.49}/pyproject.toml

@@ -27,6 +27,7 @@ dependencies = [
     "disklru>=2.0.4",
     "playwright>=1.40.0",
     "websockify>=0.13.0",
+    "fasteners>=0.20",
 ]
 
 dynamic = ["version"]

{fastled-1.4.45 → fastled-1.4.49}/src/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.49"
 
 __version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

{fastled-1.4.45 → fastled-1.4.49}/src/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-1.4.45 → fastled-1.4.49}/src/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-1.4.45 → fastled-1.4.49}/src/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-1.4.45 → fastled-1.4.49}/src/fastled/select_sketch_directory.py

@@ -1,6 +1,8 @@
 from pathlib import Path
 from typing import Callable, TypeVar, Union
 
+from fastled.string_diff import string_diff
+
 T = TypeVar("T")
 
 
@@ -82,6 +84,44 @@ def _disambiguate_user_choice(
             0,  # Reset default to first match
         )
 
+    # Try fuzzy matching as fallback
+    # For better fuzzy matching on paths, extract just the last component (basename)
+    # to avoid the "examples/" prefix interfering with matching
+    from pathlib import Path as PathLib
+
+    option_basenames = []
+    for option in options:
+        option_str = option_to_str(option)
+        # Extract basename for fuzzy matching
+        basename = (
+            PathLib(option_str).name
+            if "/" in option_str or "\\" in option_str
+            else option_str
+        )
+        option_basenames.append(basename)
+
+    fuzzy_results = string_diff(user_input, option_basenames)
+
+    if fuzzy_results:
+        # Map fuzzy results back to original options
+        fuzzy_matches = []
+        for _, matched_basename in fuzzy_results:
+            for i, basename in enumerate(option_basenames):
+                if basename == matched_basename:
+                    fuzzy_matches.append(options[i])
+                    break
+
+        if len(fuzzy_matches) == 1:
+            return fuzzy_matches[0]
+        elif len(fuzzy_matches) > 1:
+            # Recursive disambiguation with fuzzy matches
+            return _disambiguate_user_choice(
+                fuzzy_matches,
+                option_to_str,
+                f"Multiple fuzzy matches for '{user_input}':",
+                0,
+            )
+
     # No match found
     print(f"No match found for '{user_input}'. Please try again.")
     return _disambiguate_user_choice(options, option_to_str, prompt, default_index)
@@ -101,13 +141,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-1.4.49/src/fastled/sketch.py

@@ -0,0 +1,219 @@
+import os
+from pathlib import Path
+
+_MAX_FILES_SEARCH_LIMIT = 10000
+
+
+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
+    for path in directory.iterdir():
+        if path.is_dir():
+            dir_name = path.name
+            if str(dir_name).startswith("."):
+                continue
+            file_count += 1
+            if file_count > _MAX_FILES_SEARCH_LIMIT:
+                print(
+                    f"More than {_MAX_FILES_SEARCH_LIMIT} files found. Stopping search."
+                )
+                break
+
+            if looks_like_sketch_directory(path, quick=True):
+                sketch_directories.append(path)
+            if dir_name.lower() == "examples":
+                # 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
+
+
+def get_sketch_files(directory: Path) -> list[Path]:
+    file_count = 0
+    files: list[Path] = []
+    for root, dirs, filenames in os.walk(directory):
+        # ignore hidden directories
+        dirs[:] = [d for d in dirs if not d.startswith(".")]
+        # ignore fastled_js directory
+        dirs[:] = [d for d in dirs if "fastled_js" not in d]
+        # ignore hidden files
+        filenames = [f for f in filenames if not f.startswith(".")]
+        outer_break = False
+        for filename in filenames:
+            if "platformio.ini" in filename:
+                continue
+            file_count += 1
+            if file_count > _MAX_FILES_SEARCH_LIMIT:
+                print(
+                    f"More than {_MAX_FILES_SEARCH_LIMIT} files found. Stopping search."
+                )
+                outer_break = True
+                break
+            files.append(Path(root) / filename)
+        if outer_break:
+            break
+
+    return files
+
+
+def looks_like_fastled_repo(directory: Path = Path(".")) -> bool:
+    libprops = directory / "library.properties"
+    if not libprops.exists():
+        return False
+    txt = libprops.read_text(encoding="utf-8", errors="ignore")
+    return "FastLED" in txt
+
+
+def _lots_and_lots_of_files(directory: Path) -> bool:
+    return len(get_sketch_files(directory)) > 100
+
+
+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
+
+    if not quick:
+        if _lots_and_lots_of_files(directory):
+            return False
+
+    # walk the path and if there are over 30 files, return False
+    # at the root of the directory there should either be an ino file or a src directory
+    # or some cpp files
+    # if there is a platformio.ini file, return True
+    ino_file_at_root = list(directory.glob("*.ino"))
+    if ino_file_at_root:
+        return True
+    cpp_file_at_root = list(directory.glob("*.cpp"))
+    if cpp_file_at_root:
+        return True
+    platformini_file = list(directory.glob("platformio.ini"))
+    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-1.4.45 → fastled-1.4.49}/src/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(

{fastled-1.4.45 → fastled-1.4.49}/src/fastled.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.4.45
+Version: 1.4.49
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -24,6 +24,7 @@ Requires-Dist: livereload
 Requires-Dist: disklru>=2.0.4
 Requires-Dist: playwright>=1.40.0
 Requires-Dist: websockify>=0.13.0
+Requires-Dist: fasteners>=0.20
 Dynamic: home-page
 Dynamic: license-file
 Dynamic: maintainer

{fastled-1.4.45 → fastled-1.4.49}/src/fastled.egg-info/SOURCES.txt

@@ -133,6 +133,7 @@ tests/unit/test_project_init.py
 tests/unit/test_select_sketch_directory.py
 tests/unit/test_server_and_client_seperatly.py
 tests/unit/test_session_compile.py
+tests/unit/test_sketch_partial_match.py
 tests/unit/test_string_diff.py
 tests/unit/test_string_diff_comprehensive.py
 tests/unit/test_version.py

{fastled-1.4.45 → fastled-1.4.49}/src/fastled.egg-info/requires.txt

@@ -12,3 +12,4 @@ livereload
 disklru>=2.0.4
 playwright>=1.40.0
 websockify>=0.13.0
+fasteners>=0.20

{fastled-1.4.45 → fastled-1.4.49}/tests/unit/test_select_sketch_directory.py

@@ -98,6 +98,66 @@ class TestSelectSketchDirectory(unittest.TestCase):
         # Should be called twice: once for invalid, once for valid
         self.assertEqual(mock_input.call_count, 2)
 
+    @patch("builtins.input", return_value="beats")
+    def test_fuzzy_matching_with_typos(self, mock_input):
+        """Fuzzy matching should handle typos like 'beats' -> 'BeatDetection'."""
+        sketch_dirs = [
+            Path("examples/Audio"),
+            Path("examples/BeatDetection"),
+            Path("examples/Blink"),
+        ]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=False, is_followup=False
+        )
+        # Should fuzzy match "beats" to "BeatDetection"
+        self.assertEqual(str(Path("examples/BeatDetection")), result)
+        mock_input.assert_called_once()
+
+    @patch("builtins.input", return_value="pacifca")
+    def test_fuzzy_matching_with_single_char_typo(self, mock_input):
+        """Fuzzy matching should handle single character typos like 'pacifca' -> 'Pacifica'."""
+        sketch_dirs = [
+            Path("examples/Audio"),
+            Path("examples/Pacifica"),
+            Path("examples/Blink"),
+        ]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=False, is_followup=False
+        )
+        # Should fuzzy match "pacifca" to "Pacifica"
+        self.assertEqual(str(Path("examples/Pacifica")), result)
+        mock_input.assert_called_once()
+
+    @patch("builtins.input", return_value="demreel")
+    def test_fuzzy_matching_missing_char(self, mock_input):
+        """Fuzzy matching should handle missing characters like 'demreel' -> 'DemoReel100'."""
+        sketch_dirs = [
+            Path("examples/Audio"),
+            Path("examples/DemoReel100"),
+            Path("examples/Blink"),
+        ]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=False, is_followup=False
+        )
+        # Should fuzzy match "demreel" to "DemoReel100"
+        self.assertEqual(str(Path("examples/DemoReel100")), result)
+        mock_input.assert_called_once()
+
+    @patch("builtins.input", return_value="cylom")
+    def test_fuzzy_matching_edit_distance(self, mock_input):
+        """Fuzzy matching should handle edit distance like 'cylom' -> 'Cylon'."""
+        sketch_dirs = [
+            Path("examples/Audio"),
+            Path("examples/Cylon"),
+            Path("examples/Blink"),
+        ]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=False, is_followup=False
+        )
+        # Should fuzzy match "cylom" to "Cylon"
+        self.assertEqual(str(Path("examples/Cylon")), result)
+        mock_input.assert_called_once()
+
 
 if __name__ == "__main__":
     unittest.main()

fastled-1.4.49/tests/unit/test_sketch_partial_match.py

@@ -0,0 +1,145 @@
+"""
+Unit tests for find_sketch_by_partial_name to ensure correct partial matching behavior.
+"""
+
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from fastled.sketch import find_sketch_by_partial_name
+
+
+class TestFindSketchByPartialName(unittest.TestCase):
+    """Test find_sketch_by_partial_name behavior."""
+
+    @patch("fastled.sketch.find_sketch_directories")
+    def test_single_match_returns_path(self, mock_find):
+        """Single unique match should return the matching path."""
+        mock_find.return_value = [
+            Path("examples/sketch1"),
+            Path("examples/sketch2"),
+        ]
+        result = find_sketch_by_partial_name("sketch2")
+        self.assertEqual(Path("examples/sketch2"), result)
+
+    @patch("fastled.sketch.find_sketch_directories")
+    def test_no_match_raises_error(self, mock_find):
+        """No matches should raise ValueError."""
+        mock_find.return_value = [
+            Path("examples/sketch1"),
+            Path("examples/sketch2"),
+        ]
+        with self.assertRaises(ValueError) as context:
+            find_sketch_by_partial_name("nonexistent")
+        self.assertIn("No sketch directory found", str(context.exception))
+
+    @patch("fastled.sketch.find_sketch_directories")
+    def test_multiple_matches_raises_error(self, mock_find):
+        """Multiple matches should raise ValueError with list of matches."""
+        mock_find.return_value = [
+            Path("examples/sketch1"),
+            Path("examples/sketch2"),
+            Path("more/sketch3"),
+        ]
+        with self.assertRaises(ValueError) as context:
+            find_sketch_by_partial_name("sketch")
+        error_msg = str(context.exception)
+        self.assertIn("Multiple sketch directories found", error_msg)
+        # Check using normalized paths (cross-platform)
+        self.assertIn("sketch1", error_msg)
+        self.assertIn("sketch2", error_msg)
+
+    @patch("fastled.sketch.find_sketch_directories")
+    def test_case_insensitive_match(self, mock_find):
+        """Match should be case insensitive."""
+        mock_find.return_value = [
+            Path("examples/MySketch"),
+            Path("examples/OtherSketch"),
+        ]
+        result = find_sketch_by_partial_name("mysketch")
+        self.assertEqual(Path("examples/MySketch"), result)
+
+    @patch("fastled.sketch.find_sketch_directories")
+    def test_partial_path_match(self, mock_find):
+        """Should match partial paths, not just directory names."""
+        mock_find.return_value = [
+            Path("examples/path/sketch1"),
+            Path("examples/other/sketch2"),
+        ]
+        result = find_sketch_by_partial_name("path/sketch1")
+        self.assertEqual(Path("examples/path/sketch1"), result)
+
+    @patch("fastled.sketch.find_sketch_directories")
+    def test_best_match_exact_name(self, mock_find):
+        """When multiple partial matches exist, exact directory name match wins."""
+        mock_find.return_value = [
+            Path("examples/sketch"),
+            Path("examples/sketch1"),
+            Path("examples/sketch2"),
+        ]
+        result = find_sketch_by_partial_name("sketch")
+        self.assertEqual(Path("examples/sketch"), result)
+
+    @patch("fastled.sketch.find_sketch_directories")
+    def test_no_exact_match_with_multiple_partials_errors(self, mock_find):
+        """Multiple partial matches with no exact match should error."""
+        mock_find.return_value = [
+            Path("examples/sketch1"),
+            Path("examples/sketch2"),
+        ]
+        with self.assertRaises(ValueError) as context:
+            find_sketch_by_partial_name("sketch")
+        self.assertIn("Multiple sketch directories found", str(context.exception))
+
+    @patch("fastled.sketch.find_sketch_directories")
+    def test_multiple_exact_matches_errors(self, mock_find):
+        """Multiple exact matches should error."""
+        mock_find.return_value = [
+            Path("examples/sketch"),
+            Path("more/sketch"),
+        ]
+        with self.assertRaises(ValueError) as context:
+            find_sketch_by_partial_name("sketch")
+        self.assertIn("Multiple sketch directories found", str(context.exception))
+
+    @patch("fastled.sketch.find_sketch_directories")
+    def test_low_character_similarity_shows_available_sketches(self, mock_find):
+        """When search term has low character similarity, show available sketches."""
+        mock_find.return_value = [
+            Path("path/to/sketch"),
+            Path("examples/MyProject"),
+        ]
+        with self.assertRaises(ValueError) as context:
+            find_sketch_by_partial_name("blah")
+        error_msg = str(context.exception)
+        self.assertIn("does not look like any of the available sketches", error_msg)
+        self.assertIn("Available sketches:", error_msg)
+        self.assertIn("sketch", error_msg)
+        self.assertIn("MyProject", error_msg)
+
+    @patch("fastled.sketch.find_sketch_directories")
+    def test_substring_match_with_low_similarity_rejected(self, mock_find):
+        """Substring match with low character similarity should be rejected."""
+        mock_find.return_value = [
+            Path("qrs/tuv"),
+        ]
+        # "ab" has chars {a, b}, "qrs/tuv" has chars {q, r, s, /, t, u, v}
+        # No common characters, so similarity = 0/2 = 0% < 50%
+        with self.assertRaises(ValueError) as context:
+            find_sketch_by_partial_name("ab")
+        error_msg = str(context.exception)
+        self.assertIn("does not look like any of the available sketches", error_msg)
+
+    @patch("fastled.sketch.find_sketch_directories")
+    def test_sufficient_similarity_allows_match(self, mock_find):
+        """Match with sufficient character similarity should succeed."""
+        mock_find.return_value = [
+            Path("examples/sketch123"),
+        ]
+        # "sketch" has all chars in "examples/sketch123" (100% similarity)
+        result = find_sketch_by_partial_name("sketch")
+        self.assertEqual(Path("examples/sketch123"), result)
+
+
+if __name__ == "__main__":
+    unittest.main()