fastled 1.3.4__py3-none-any.whl → 1.3.6__py3-none-any.whl

fastled/string_diff.py

@@ -1,82 +1,82 @@
-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.
-    """
-    input_chars = set(input_str)
-    filtered_list = []
-    for s in string_list:
-        # Check if at least half of the input characters are in the string
-        s_chars = set(s)
-        common_chars = input_chars.intersection(s_chars)
-        if len(common_chars) >= len(input_chars) / 2:
-            filtered_list.append(s)
-    return filtered_list
-
-
-# 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
-
-    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}
-
-    if ignore_case:
-        string_list = [s.lower() for s in string_list]
-        input_string = input_string.lower()
-
-    # Apply set membership filtering for queries with 3+ characters
-    if len(input_string) >= 3:
-        string_list = _filter_out_obvious_bad_choices(input_string, string_list)
-
-    is_substring = False
-    for s in string_list:
-        if input_string in s:
-            is_substring = True
-            break
-
-    if is_substring:
-        string_list = [s for s in string_list if input_string in s]
-
-    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))
-    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]]:
-    string_list = [str(p) for p in path_list]
-    tmp = string_diff(str(input_string), string_list, ignore_case)
-    out: list[tuple[float, Path]] = []
-    for i, j in tmp:
-        p = Path(j)
-        out.append((i, p))
-    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.
+    """
+    input_chars = set(input_str)
+    filtered_list = []
+    for s in string_list:
+        # Check if at least half of the input characters are in the string
+        s_chars = set(s)
+        common_chars = input_chars.intersection(s_chars)
+        if len(common_chars) >= len(input_chars) / 2:
+            filtered_list.append(s)
+    return filtered_list
+
+
+# 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
+
+    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}
+
+    if ignore_case:
+        string_list = [s.lower() for s in string_list]
+        input_string = input_string.lower()
+
+    # Apply set membership filtering for queries with 3+ characters
+    if len(input_string) >= 3:
+        string_list = _filter_out_obvious_bad_choices(input_string, string_list)
+
+    is_substring = False
+    for s in string_list:
+        if input_string in s:
+            is_substring = True
+            break
+
+    if is_substring:
+        string_list = [s for s in string_list if input_string in s]
+
+    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))
+    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]]:
+    string_list = [str(p) for p in path_list]
+    tmp = string_diff(str(input_string), string_list, ignore_case)
+    out: list[tuple[float, Path]] = []
+    for i, j in tmp:
+        p = Path(j)
+        out.append((i, p))
+    return out

fastled/types.py

@@ -1,96 +1,11 @@
-import argparse
 from dataclasses import dataclass
 from enum import Enum
-from pathlib import Path
 from typing import Any
 
+from fastled.args import Args
 from fastled.print_filter import PrintFilterFastled
 
 
-@dataclass
-class Args:
-    directory: Path | None
-    init: bool | str
-    just_compile: bool
-    web: str | None
-    interactive: bool
-    profile: bool
-    force_compile: bool
-    auto_update: bool | None
-    update: bool
-    localhost: bool
-    build: bool
-    server: bool
-    purge: bool
-    debug: bool
-    quick: bool
-    release: bool
-
-    @staticmethod
-    def from_namespace(args: argparse.Namespace) -> "Args":
-        assert isinstance(
-            args.directory, str | None
-        ), f"expected str | None, got {type(args.directory)}"
-        assert isinstance(
-            args.init, bool | str | None
-        ), f"expected bool, got {type(args.init)}"
-        assert isinstance(
-            args.just_compile, bool
-        ), f"expected bool, got {type(args.just_compile)}"
-        assert isinstance(
-            args.web, str | None
-        ), f"expected str | None, got {type(args.web)}"
-        assert isinstance(
-            args.interactive, bool
-        ), f"expected bool, got {type(args.interactive)}"
-        assert isinstance(
-            args.profile, bool
-        ), f"expected bool, got {type(args.profile)}"
-        assert isinstance(
-            args.force_compile, bool
-        ), f"expected bool, got {type(args.force_compile)}"
-        assert isinstance(
-            args.no_auto_updates, bool | None
-        ), f"expected bool | None, got {type(args.no_auto_updates)}"
-        assert isinstance(args.update, bool), f"expected bool, got {type(args.update)}"
-        assert isinstance(
-            args.localhost, bool
-        ), f"expected bool, got {type(args.localhost)}"
-        assert isinstance(args.build, bool), f"expected bool, got {type(args.build)}"
-        assert isinstance(args.server, bool), f"expected bool, got {type(args.server)}"
-        assert isinstance(args.purge, bool), f"expected bool, got {type(args.purge)}"
-        assert isinstance(args.debug, bool), f"expected bool, got {type(args.debug)}"
-        assert isinstance(args.quick, bool), f"expected bool, got {type(args.quick)}"
-        assert isinstance(
-            args.release, bool
-        ), f"expected bool, got {type(args.release)}"
-        init: bool | str = False
-        if args.init is None:
-            init = False
-        elif isinstance(args.init, bool):
-            init = args.init
-        elif isinstance(args.init, str):
-            init = args.init
-        return Args(
-            directory=Path(args.directory) if args.directory else None,
-            init=init,
-            just_compile=args.just_compile,
-            web=args.web,
-            interactive=args.interactive,
-            profile=args.profile,
-            force_compile=args.force_compile,
-            auto_update=not args.no_auto_updates,
-            update=args.update,
-            localhost=args.localhost,
-            build=args.build,
-            server=args.server,
-            purge=args.purge,
-            debug=args.debug,
-            quick=args.quick,
-            release=args.release,
-        )
-
-
 @dataclass
 class CompileResult:
     success: bool

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()