fastled 1.4.41__tar.gz → 1.4.45__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.4.41
+Version: 1.4.45
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies

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

{fastled-1.4.41 → fastled-1.4.45}/src/fastled/docker_manager.py

@@ -26,7 +26,6 @@ from docker.models.images import Image
 from filelock import FileLock
 
 from fastled.print_filter import PrintFilter, PrintFilterDefault
-from fastled.spinner import Spinner
 
 CONFIG_DIR = Path(user_data_dir("fastled", "fastled"))
 CONFIG_DIR.mkdir(parents=True, exist_ok=True)
@@ -252,7 +251,34 @@ class DockerManager:
     @property
     def client(self) -> DockerClient:
         if self._client is None:
-            self._client = docker.from_env()
+            # Retry logic for WSL startup on Windows
+            max_retries = 10
+            retry_delay = 2  # seconds
+            last_error = None
+
+            for attempt in range(max_retries):
+                try:
+                    self._client = docker.from_env()
+                    if attempt > 0:
+                        print(
+                            f"Successfully connected to Docker after {attempt + 1} attempts"
+                        )
+                    return self._client
+                except DockerException as e:
+                    last_error = e
+                    if attempt < max_retries - 1:
+                        if attempt == 0:
+                            print("Waiting for Docker/WSL to be ready...")
+                        print(
+                            f"Attempt {attempt + 1}/{max_retries} failed, retrying in {retry_delay}s..."
+                        )
+                        time.sleep(retry_delay)
+                    else:
+                        print(
+                            f"Failed to connect to Docker after {max_retries} attempts"
+                        )
+                        raise last_error
+        assert self._client is not None
         return self._client
 
     @staticmethod
@@ -507,14 +533,9 @@ class DockerManager:
                         return False
 
                     # Quick check for latest version
-                    with Spinner(f"Pulling newer version of {image_name}:{tag}..."):
-                        cmd_list = ["docker", "pull", f"{image_name}:{tag}"]
-                        subprocess.run(
-                            cmd_list,
-                            check=True,
-                            stdout=subprocess.DEVNULL,
-                            stderr=subprocess.DEVNULL,
-                        )
+                    print(f"Pulling newer version of {image_name}:{tag}...")
+                    cmd_list = ["docker", "pull", f"{image_name}:{tag}"]
+                    subprocess.run(cmd_list, check=True)
                     print(f"Updated to newer version of {image_name}:{tag}")
                     local_image_hash = self.client.images.get(f"{image_name}:{tag}").id
                     assert local_image_hash is not None
@@ -524,15 +545,10 @@ class DockerManager:
 
             except ImageNotFound:
                 print(f"Image {image_name}:{tag} not found.")
-                with Spinner("Loading "):
-                    # We use docker cli here because it shows the download.
-                    cmd_list = ["docker", "pull", f"{image_name}:{tag}"]
-                    subprocess.run(
-                        cmd_list,
-                        check=True,
-                        stdout=subprocess.DEVNULL,
-                        stderr=subprocess.DEVNULL,
-                    )
+                print("Loading...")
+                # We use docker cli here because it shows the download.
+                cmd_list = ["docker", "pull", f"{image_name}:{tag}"]
+                subprocess.run(cmd_list, check=True)
                 try:
                     local_image = self.client.images.get(f"{image_name}:{tag}")
                     local_image_hash = local_image.id

{fastled-1.4.41 → fastled-1.4.45}/src/fastled/project_init.py

@@ -22,20 +22,27 @@ def get_examples(host: str | None = None) -> list[str]:
 
 
 def _prompt_for_example() -> str:
+    from fastled.select_sketch_directory import _disambiguate_user_choice
+
     examples = get_examples()
-    while True:
-        print("Available examples:")
-        for i, example in enumerate(examples):
-            print(f"  [{i+1}]: {example}")
-        answer = input("Enter the example number or name: ").strip()
-        if answer.isdigit():
-            example_num = int(answer) - 1
-            if example_num < 0 or example_num >= len(examples):
-                print("Invalid example number")
-                continue
-            return examples[example_num]
-        elif answer in examples:
-            return answer
+
+    # Find default example index (prefer DEFAULT_EXAMPLE if it exists)
+    default_index = 0
+    if DEFAULT_EXAMPLE in examples:
+        default_index = examples.index(DEFAULT_EXAMPLE)
+
+    result = _disambiguate_user_choice(
+        examples,
+        option_to_str=lambda x: x,
+        prompt="Available examples:",
+        default_index=default_index,
+    )
+
+    if result is None:
+        # Fallback to DEFAULT_EXAMPLE if user cancelled
+        return DEFAULT_EXAMPLE
+
+    return result
 
 
 class DownloadThread(threading.Thread):

fastled-1.4.45/src/fastled/select_sketch_directory.py

@@ -0,0 +1,122 @@
+from pathlib import Path
+from typing import Callable, TypeVar, Union
+
+T = TypeVar("T")
+
+
+def _disambiguate_user_choice(
+    options: list[T],
+    option_to_str: Callable[[T], str] = str,
+    prompt: str = "Multiple matches found. Please choose:",
+    default_index: int = 0,
+) -> Union[T, None]:
+    """
+    Present multiple options to the user with a default selection.
+
+    Args:
+        options: List of options to choose from
+        option_to_str: Function to convert option to display string
+        prompt: Prompt message to show user
+        default_index: Index of the default option (0-based)
+
+    Returns:
+        Selected option or None if cancelled
+    """
+    if not options:
+        return None
+
+    if len(options) == 1:
+        return options[0]
+
+    # Ensure default_index is valid
+    if default_index < 0 or default_index >= len(options):
+        default_index = 0
+
+    print(f"\n{prompt}")
+    for i, option in enumerate(options):
+        option_str = option_to_str(option)
+        if i == default_index:
+            print(f"  [{i+1}]: [{option_str}]")  # Default option shown in brackets
+        else:
+            print(f"  [{i+1}]: {option_str}")
+
+    default_option_str = option_to_str(options[default_index])
+    user_input = input(
+        f"\nEnter number or name (default: [{default_option_str}]): "
+    ).strip()
+
+    # Handle empty input - select default
+    if not user_input:
+        return options[default_index]
+
+    # Try to parse as number
+    try:
+        index = int(user_input) - 1
+        if 0 <= index < len(options):
+            return options[index]
+    except ValueError:
+        pass
+
+    # Try to match by name (case insensitive)
+    user_input_lower = user_input.lower()
+    for option in options:
+        option_str = option_to_str(option).lower()
+        if option_str == user_input_lower:
+            return option
+
+    # Try partial match
+    matches = []
+    for option in options:
+        option_str = option_to_str(option)
+        if user_input_lower in option_str.lower():
+            matches.append(option)
+
+    if len(matches) == 1:
+        return matches[0]
+    elif len(matches) > 1:
+        # Recursive disambiguation with the filtered matches
+        return _disambiguate_user_choice(
+            matches,
+            option_to_str,
+            f"Multiple partial matches for '{user_input}':",
+            0,  # Reset default to first match
+        )
+
+    # 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)
+
+
+def select_sketch_directory(
+    sketch_directories: list[Path], cwd_is_fastled: bool, is_followup: bool = False
+) -> str | None:
+    if cwd_is_fastled:
+        exclude = ["src", "dev", "tests"]
+        for ex in exclude:
+            p = Path(ex)
+            if p in sketch_directories:
+                sketch_directories.remove(p)
+
+    if len(sketch_directories) == 1:
+        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
+        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
+        result = _disambiguate_user_choice(
+            sketch_directories,
+            option_to_str=lambda x: str(x),
+            prompt="Multiple Directories found, choose one:",
+            default_index=0,
+        )
+
+        if result is None:
+            return None
+
+        return str(result)
+    return None

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.4.41
+Version: 1.4.45
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies

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

@@ -130,6 +130,7 @@ tests/unit/test_http_server.py
 tests/unit/test_manual_api_invocation.py
 tests/unit/test_no_platformio_compile.py
 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_string_diff.py

{fastled-1.4.41 → fastled-1.4.45}/tests/unit/test_manual_api_invocation.py

@@ -187,11 +187,14 @@ void loop() {
             self.assertGreater(len(wasm_files), 0, "Expected to find .wasm files")
 
             # Verify file sizes are reasonable
+            # Note: graphics_manager_base.js is intentionally empty/minimal
+            skip_size_check = {"graphics_manager_base.js"}
             for js_file in js_files:
                 size = js_file.stat().st_size
-                self.assertGreater(
-                    size, 1000, f"JS file {js_file.name} too small: {size} bytes"
-                )
+                if js_file.name not in skip_size_check:
+                    self.assertGreater(
+                        size, 1000, f"JS file {js_file.name} too small: {size} bytes"
+                    )
                 print(f"📄 {js_file.name}: {size:,} bytes")
 
             for wasm_file in wasm_files:

fastled-1.4.45/tests/unit/test_select_sketch_directory.py

@@ -0,0 +1,103 @@
+"""
+Unit tests for select_sketch_directory to prevent regressions.
+"""
+
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from fastled.select_sketch_directory import select_sketch_directory
+
+
+class TestSelectSketchDirectory(unittest.TestCase):
+    """Test select_sketch_directory behavior."""
+
+    def test_single_directory_auto_selects(self):
+        """Single directory should auto-select without prompting."""
+        sketch_dirs = [Path("sketch1")]
+        result = select_sketch_directory(sketch_dirs, cwd_is_fastled=False)
+        self.assertEqual(str(sketch_dirs[0]), result)
+
+    def test_first_scan_with_more_than_4_returns_none(self):
+        """First scan with >4 directories should return None (no auto-select)."""
+        sketch_dirs = [Path(f"sketch{i}") for i in range(5)]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=False, is_followup=False
+        )
+        self.assertIsNone(result)
+
+    @patch("builtins.input", return_value="")
+    def test_first_scan_with_4_or_less_prompts_with_default(self, mock_input):
+        """First scan with ≤4 directories should prompt with default selection."""
+        sketch_dirs = [Path(f"sketch{i}") for i in range(4)]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=False, is_followup=False
+        )
+        # User pressed return (empty input), should get default (first option)
+        self.assertEqual(str(sketch_dirs[0]), result)
+        mock_input.assert_called_once()
+
+    @patch("builtins.input", return_value="2")
+    def test_first_scan_user_selects_by_number(self, mock_input):
+        """User can select by number on first scan with ≤4 directories."""
+        sketch_dirs = [Path(f"sketch{i}") for i in range(4)]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=False, is_followup=False
+        )
+        self.assertEqual(str(sketch_dirs[1]), result)
+        mock_input.assert_called_once()
+
+    @patch("builtins.input", return_value="")
+    def test_followup_always_prompts_even_with_many_dirs(self, mock_input):
+        """Follow-up calls should always prompt, even with >4 directories."""
+        sketch_dirs = [Path(f"sketch{i}") for i in range(10)]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=False, is_followup=True
+        )
+        # Should prompt and return default (first option)
+        self.assertEqual(str(sketch_dirs[0]), result)
+        mock_input.assert_called_once()
+
+    @patch("builtins.input", return_value="5")
+    def test_followup_user_can_select_from_many(self, mock_input):
+        """Follow-up calls allow user to select from many directories."""
+        sketch_dirs = [Path(f"sketch{i}") for i in range(10)]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=False, is_followup=True
+        )
+        self.assertEqual(str(sketch_dirs[4]), result)
+        mock_input.assert_called_once()
+
+    def test_fastled_repo_excludes_src_dev_tests(self):
+        """When in FastLED repo, should exclude src, dev, tests directories."""
+        sketch_dirs = [Path("src"), Path("dev"), Path("tests"), Path("examples")]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=True, is_followup=False
+        )
+        # Only "examples" remains, should auto-select
+        self.assertEqual("examples", result)
+
+    @patch("builtins.input", return_value="sketch3")
+    def test_user_can_select_by_name(self, mock_input):
+        """User can select by name instead of number."""
+        sketch_dirs = [Path("sketch1"), Path("sketch2"), Path("sketch3")]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=False, is_followup=False
+        )
+        self.assertEqual("sketch3", result)
+        mock_input.assert_called_once()
+
+    @patch("builtins.input", side_effect=["invalid", "1"])
+    def test_invalid_input_retry(self, mock_input):
+        """Invalid input should retry prompt."""
+        sketch_dirs = [Path("sketch1"), Path("sketch2")]
+        result = select_sketch_directory(
+            sketch_dirs, cwd_is_fastled=False, is_followup=False
+        )
+        self.assertEqual(str(sketch_dirs[0]), result)
+        # Should be called twice: once for invalid, once for valid
+        self.assertEqual(mock_input.call_count, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

{fastled-1.4.41 → fastled-1.4.45}/tests/unit/test_string_diff_comprehensive.py

@@ -210,6 +210,41 @@ class TestStringDiffComprehensive:
                 expected in result_names
             ), f"Expected '{expected}' in results for spaced input '{input_str}', got: {result_names}"
 
+    def test_whitespace_in_camelcase_names(self):
+        """Test that whitespace between words matches CamelCase names without disambiguation.
+
+        This tests the specific case where 'Noise Ring' should directly match 'FxNoiseRing'
+        without requiring a disambiguation step, since the whitespace is just separating
+        the CamelCase components.
+        """
+        test_cases = [
+            ("Noise Ring", "FxNoiseRing", 1),  # Should be unique match
+            ("Noise Playground", "NoisePlayground", 1),  # Should be unique match
+            ("Noise Plus Palette", "NoisePlusPalette", 1),  # Should be unique match
+            ("Fire Cylinder", "FireCylinder", 1),  # Should be unique match
+            ("Fire Matrix", "FireMatrix", 1),  # Should be unique match
+            ("Blink Parallel", "BlinkParallel", 1),  # Should be unique match
+            ("Color Palette", "ColorPalette", 1),  # Should be unique match
+            ("Color Temperature", "ColorTemperature", 1),  # Should be unique match
+            ("Demo Reel 100", "DemoReel100", 1),  # Should be unique match
+            ("XY Matrix", "XYMatrix", 1),  # Should be unique match
+            ("XY Path", "XYPath", 1),  # Should be unique match
+        ]
+
+        for input_str, expected, expected_count in test_cases:
+            results = string_diff(input_str, self.fastled_examples)
+            result_names = [r[1] for r in results]
+
+            # Check that the expected match is in the results
+            assert (
+                expected in result_names
+            ), f"Expected '{expected}' in results for whitespace input '{input_str}', got: {result_names}"
+
+            # Check that it's a direct match without disambiguation (should return exactly expected_count results)
+            assert (
+                len(results) == expected_count
+            ), f"Expected exactly {expected_count} result(s) for '{input_str}' (no disambiguation), got {len(results)}: {result_names}"
+
     def test_typos_and_minor_edits(self):
         """Test handling of typos and minor edits."""
         test_cases = [
@@ -605,6 +640,7 @@ if __name__ == "__main__":
         test_instance.test_case_insensitive_matches,
         test_instance.test_partial_matches,
         test_instance.test_spaces_in_input,
+        test_instance.test_whitespace_in_camelcase_names,
         test_instance.test_typos_and_minor_edits,
         test_instance.test_prefix_matching,
         test_instance.test_suffix_matching,

fastled-1.4.41/src/fastled/select_sketch_directory.py

@@ -1,67 +0,0 @@
-from pathlib import Path
-
-from rapidfuzz import fuzz
-
-from fastled.string_diff import string_diff_paths
-
-
-def select_sketch_directory(
-    sketch_directories: list[Path], cwd_is_fastled: bool, is_followup: bool = False
-) -> str | None:
-    if cwd_is_fastled:
-        exclude = ["src", "dev", "tests"]
-        for ex in exclude:
-            p = Path(ex)
-            if p in sketch_directories:
-                sketch_directories.remove(p)
-
-    if len(sketch_directories) == 1:
-        print(f"\nUsing sketch directory: {sketch_directories[0]}")
-        return str(sketch_directories[0])
-    elif len(sketch_directories) > 1:
-        print("\nMultiple Directories found, choose one:")
-        for i, sketch_dir in enumerate(sketch_directories):
-            print(f"  [{i+1}]: {sketch_dir}")
-        which = input(
-            "\nPlease specify a sketch directory\nYou can enter a number or type a fuzzy search: "
-        ).strip()
-        try:
-            index = int(which) - 1
-            return str(sketch_directories[index])
-        except (ValueError, IndexError):
-            inputs = [p for p in sketch_directories]
-
-            if is_followup:
-                # On follow-up, find the closest match by fuzzy distance
-                distances = []
-                for path in inputs:
-                    path_str = str(path).replace("\\", "/")
-                    dist = fuzz.token_sort_ratio(which.lower(), path_str.lower())
-                    distances.append((dist, path))
-
-                # Get the best distance and return the closest match(es)
-                best_distance = max(distances, key=lambda x: x[0])[0]
-                best_matches = [
-                    path for dist, path in distances if dist == best_distance
-                ]
-
-                if len(best_matches) == 1:
-                    example = best_matches[0]
-                    return str(example)
-                else:
-                    # If still multiple matches with same distance, recurse again
-                    return select_sketch_directory(
-                        best_matches, cwd_is_fastled, is_followup=True
-                    )
-            else:
-                # First call - use original fuzzy matching (allows ambiguity)
-                top_hits: list[tuple[float, Path]] = string_diff_paths(which, inputs)
-                if len(top_hits) == 1:
-                    example = top_hits[0][1]
-                    return str(example)
-                else:
-                    # Recursive call with is_followup=True for more precise matching
-                    return select_sketch_directory(
-                        [p for _, p in top_hits], cwd_is_fastled, is_followup=True
-                    )
-    return None