fastled 1.4.31__py3-none-any.whl → 1.4.33__py3-none-any.whl

fastled/string_diff.py

@@ -1,165 +1,165 @@
-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.
-def string_diff(
-    input_string: str, string_list: list[str], ignore_case=True
-) -> list[tuple[float, str]]:
-
-    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:
-        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 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 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:
-            s = string_list[i]
-            s_mapped = map_string.get(s, s)
-            out.append((i, s_mapped))
-
-    return out
-
-
-def string_diff_paths(
-    input_string: str | Path, path_list: list[Path], ignore_case=True
-) -> list[tuple[float, Path]]:
-    # 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:
-        # 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
+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.
+def string_diff(
+    input_string: str, string_list: list[str], ignore_case=True
+) -> list[tuple[float, str]]:
+
+    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:
+        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 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 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:
+            s = string_list[i]
+            s_mapped = map_string.get(s, s)
+            out.append((i, s_mapped))
+
+    return out
+
+
+def string_diff_paths(
+    input_string: str | Path, path_list: list[Path], ignore_case=True
+) -> list[tuple[float, Path]]:
+    # 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:
+        # 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/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/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()

fastled/web_compile.py

@@ -196,16 +196,30 @@ def _process_compile_response(
     response: httpx.Response,
     zip_result: ZipResult,
     start_time: float,
+    zip_time: float,
+    libfastled_time: float,
+    sketch_time: float,
 ) -> CompileResult:
     """Process the compile response and return the final result."""
     if response.status_code != 200:
         json_response = response.json()
         detail = json_response.get("detail", "Could not compile")
         return CompileResult(
-            success=False, stdout=detail, hash_value=None, zip_bytes=b""
+            success=False,
+            stdout=detail,
+            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 error case
         )
 
     print(f"Response status code: {response}")
+
+    # Time the response processing
+    response_processing_start = time.time()
+
     # Create a temporary directory to extract the zip
     with tempfile.TemporaryDirectory() as extract_dir:
         extract_path = Path(extract_dir)
@@ -250,14 +264,32 @@ def _process_compile_response(
                     relative_path = file_path.relative_to(extract_path)
                     out_zip.write(file_path, relative_path)
 
+        response_processing_time = time.time() - response_processing_start
         diff_time = time.time() - start_time
-        msg = f"Compilation success, took {diff_time:.2f} seconds"
+
+        # Create detailed timing breakdown
+        unaccounted_time = diff_time - (
+            zip_time + libfastled_time + sketch_time + response_processing_time
+        )
+        msg = f"Compilation success, took {diff_time:.2f} seconds\n"
+        msg += f"     zip creation: {zip_time:.2f}\n"
+        if libfastled_time > 0:
+            msg += f"     libfastled: {libfastled_time:.2f}\n"
+        msg += f"     sketch compile + link: {sketch_time:.2f}\n"
+        msg += f"     response processing: {response_processing_time:.2f}\n"
+        if unaccounted_time > 0.01:  # Only show if significant
+            msg += f"     other overhead: {unaccounted_time:.2f}"
+
         _print_banner(msg)
         return CompileResult(
             success=True,
             stdout=stdout,
             hash_value=hash_value,
             zip_bytes=out_buffer.getvalue(),
+            zip_time=zip_time,
+            libfastled_time=libfastled_time,
+            sketch_time=sketch_time,
+            response_processing_time=response_processing_time,
         )
 
 
@@ -279,17 +311,35 @@ def web_compile(
     auth_token = auth_token or AUTH_TOKEN
     if not directory.exists():
         raise FileNotFoundError(f"Directory not found: {directory}")
+
+    # Time the zip creation
+    zip_start_time = time.time()
     zip_result: ZipResult | Exception = zip_files(directory, build_mode=build_mode)
+    zip_time = time.time() - zip_start_time
+
     if isinstance(zip_result, Exception):
         return CompileResult(
-            success=False, stdout=str(zip_result), hash_value=None, zip_bytes=b""
+            success=False,
+            stdout=str(zip_result),
+            hash_value=None,
+            zip_bytes=b"",
+            zip_time=zip_time,
+            libfastled_time=0.0,  # No libfastled compilation in zip error case
+            sketch_time=0.0,  # No sketch compilation in zip error case
+            response_processing_time=0.0,  # No response processing in zip error case
         )
     zip_bytes = zip_result.zip_bytes
     print(f"Web compiling on {host}...")
+
+    # Track timing for each step
+    libfastled_time = 0.0
+    sketch_time = 0.0
+
     try:
         # Step 1: Compile libfastled if requested
         if allow_libcompile:
             print("Step 1: Compiling libfastled...")
+            libfastled_start_time = time.time()
             try:
                 libfastled_response = _compile_libfastled(host, auth_token, build_mode)
 
@@ -308,6 +358,10 @@ def web_compile(
                         stdout=stdout,
                         hash_value=None,
                         zip_bytes=b"",
+                        zip_time=zip_time,
+                        libfastled_time=libfastled_time,
+                        sketch_time=0.0,  # No sketch compilation when libfastled fails
+                        response_processing_time=0.0,  # No response processing when libfastled fails
                     )
                 else:
                     # Check for embedded HTTP status in response content
@@ -332,6 +386,10 @@ def web_compile(
                                 stdout=stdout,
                                 hash_value=None,
                                 zip_bytes=b"",
+                                zip_time=zip_time,
+                                libfastled_time=libfastled_time,
+                                sketch_time=0.0,  # No sketch compilation when libfastled fails
+                                response_processing_time=0.0,  # No response processing when libfastled fails
                             )
                             # Continue with sketch compilation even if libfastled fails
                         elif embedded_status is None:
@@ -343,7 +401,9 @@ def web_compile(
                             print("✅ libfastled compilation successful")
                     else:
                         print("✅ libfastled compilation successful")
+                libfastled_time = time.time() - libfastled_start_time
             except Exception as e:
+                libfastled_time = time.time() - libfastled_start_time
                 print(f"Warning: libfastled compilation failed: {e}")
                 # Continue with sketch compilation even if libfastled fails
         else:
@@ -351,6 +411,7 @@ def web_compile(
 
         # Step 2: Compile the sketch
         print("Step 2: Compiling sketch...")
+        sketch_start_time = time.time()
         response = _send_compile_request(
             host,
             zip_bytes,
@@ -360,8 +421,11 @@ def web_compile(
             no_platformio,
             False,  # allow_libcompile is always False since we handle it manually
         )
+        sketch_time = time.time() - sketch_start_time
 
-        return _process_compile_response(response, zip_result, start_time)
+        return _process_compile_response(
+            response, zip_result, start_time, zip_time, libfastled_time, sketch_time
+        )
 
     except ConnectionError as e:
         _print_banner(str(e))
@@ -370,6 +434,10 @@ def web_compile(
             stdout=str(e),
             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
         )
     except KeyboardInterrupt:
         print("Keyboard interrupt")
@@ -377,5 +445,12 @@ def web_compile(
     except httpx.HTTPError as e:
         print(f"Error: {e}")
         return CompileResult(
-            success=False, stdout=str(e), hash_value=None, zip_bytes=b""
+            success=False,
+            stdout=str(e),
+            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 HTTP error case
         )