fastled 1.4.39__tar.gz → 1.4.41__tar.gz

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

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

{fastled-1.4.39 → fastled-1.4.41}/build_local_docker.py

@@ -9,8 +9,6 @@
 #   "python-dateutil"
 # ]
 
-import os
-import shutil
 import subprocess
 
 def _exec(cmd: str) -> int:

{fastled-1.4.39 → fastled-1.4.41}/setup.py

@@ -3,8 +3,6 @@ Setup file.
 """
 
 import os
-import re
-from pathlib import Path
 
 from setuptools import setup
 

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

{fastled-1.4.39 → fastled-1.4.41}/src/fastled/string_diff.py

@@ -80,14 +80,100 @@ def string_diff(
     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 an exact match AND other substring matches, return all substring matches
-    # This provides better user experience for partial matching
-    if exact_matches and len(substring_matches) > 1:
-        out: list[tuple[float, str]] = []
-        for i, s in enumerate(substring_matches):
-            s_mapped = map_string.get(s, s)
-            out.append((i, s_mapped))
-        return out
+    # 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:

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

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

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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 """
 Unit test file demonstrating manual API invocation of fastled-wasm-server.
 

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

@@ -511,6 +511,59 @@ class TestStringDiffComprehensive:
                 results1 == results2 == results3
             ), f"Results inconsistent for '{test_case}'"
 
+    def test_wasm_disambiguation_issue(self):
+        """Test the specific Wasm disambiguation issue where exact matches should be prioritized."""
+        # This test exposes the bug where "Wasm" returns both "wasm" and "WasmScreenCoords"
+        # when it should prioritize the exact case-insensitive match "wasm"
+        results = string_diff("Wasm", self.fastled_examples)
+        result_names = [r[1] for r in results]
+
+        # The issue: currently returns both "wasm" and "WasmScreenCoords"
+        # Expected: should only return "wasm" since it's an exact case-insensitive match
+        assert (
+            len(result_names) == 1
+        ), f"Expected exactly 1 result for 'Wasm', got {len(result_names)}: {result_names}"
+        assert (
+            result_names[0] == "wasm"
+        ), f"Expected 'wasm' as the only result, got: {result_names[0]}"
+
+    def test_character_count_based_disambiguation(self):
+        """Test that disambiguation considers the number of extra characters."""
+        # Test cases where the exact match should include variants based on character count
+        test_data = ["Wave2d", "FxWave2d", "SuperLongPrefixWave2d"]
+
+        # Wave2d case: should return Wave2d and FxWave2d (Fx is only 2 chars - short prefix)
+        # but exclude SuperLongPrefixWave2d (SuperLongPrefix is 15 chars - long prefix)
+        results = string_diff("Wave2d", test_data)
+        result_names = [r[1] for r in results]
+
+        assert (
+            "Wave2d" in result_names
+        ), f"Expected 'Wave2d' in results, got: {result_names}"
+        assert (
+            "FxWave2d" in result_names
+        ), f"Expected 'FxWave2d' (short prefix) in results, got: {result_names}"
+
+        # The key test: should exclude long prefixes
+        assert (
+            "SuperLongPrefixWave2d" not in result_names
+        ), f"Did not expect 'SuperLongPrefixWave2d' (long prefix) in results, got: {result_names}"
+
+        # Test with Fire2012 example
+        fire_data = ["Fire2012", "FxFire2012", "VeryLongPrefixFire2012"]
+        results = string_diff("Fire2012", fire_data)
+        result_names = [r[1] for r in results]
+
+        assert (
+            "Fire2012" in result_names
+        ), f"Expected 'Fire2012' in results, got: {result_names}"
+        assert (
+            "FxFire2012" in result_names
+        ), f"Expected 'FxFire2012' (short prefix) in results, got: {result_names}"
+        assert (
+            "VeryLongPrefixFire2012" not in result_names
+        ), f"Did not expect 'VeryLongPrefixFire2012' (long prefix) in results, got: {result_names}"
+
     def test_investigate_multiple_results(self):
         """Investigate cases where multiple results are returned and understand why."""
         # Test cases that might return multiple results
@@ -564,6 +617,8 @@ if __name__ == "__main__":
         test_instance.test_special_characters_in_input,
         test_instance.test_performance_with_large_dataset,
         test_instance.test_consistency_across_runs,
+        test_instance.test_wasm_disambiguation_issue,
+        test_instance.test_character_count_based_disambiguation,
         test_instance.test_investigate_multiple_results,
     ]