remove unnecessary # type: ignore[...]'s and add missing type checking

Author: xulbux

CHANGELOG.md

@@ -25,9 +25,10 @@
 
 **BREAKING CHANGES:**
 * Made the value input into the params `bar_format` and `limited_bar_format` of `ProgressBar` be a list/tuple of strings instead of a single string, so the user can define multiple formats for different console widths.
-* Added a new param <code>sep: str = " "</code> to the `ProgressBar` class, which is used to join multiple bar-format strings.
+* Added a new param <code>sep: *str* = " "</code> to the `ProgressBar` class, which is used to join multiple bar-format strings.
 * Renamed the class property `Console.wh` to `Console.size`, since it describes the property better.
 * Renamed the class property `Console.usr` to `Console.user`, since it describes the property better.
+* Added missing type checking to methods in the `path` module.
 
 <span id="v1-9-0" />
 

src/xulbux/console.py

@@ -184,13 +184,13 @@ def items(self) -> Generator[tuple[str, ArgResultRegular | ArgResultPositional],
 class Console:
     """This class provides methods for logging and other actions within the console."""
 
-    w: int = _ConsoleWidth()  # type: ignore[assignment]
+    w: int = cast(int, _ConsoleWidth())
     """The width of the console in characters."""
-    h: int = _ConsoleHeight()  # type: ignore[assignment]
+    h: int = cast(int, _ConsoleHeight())
     """The height of the console in lines."""
-    size: tuple[int, int] = _ConsoleSize()  # type: ignore[assignment]
+    size: tuple[int, int] = cast(tuple[int, int], _ConsoleSize())
     """A tuple with the width and height of the console in characters and lines."""
-    user: str = _ConsoleUser()  # type: ignore[assignment]
+    user: str = cast(str, _ConsoleUser())
     """The name of the current user."""
 
     @staticmethod
@@ -1054,7 +1054,7 @@ def input(
         allow_paste: bool = True,
         validator: Optional[Callable[[str], Optional[str]]] = None,
         default_val: Optional[T] = None,
-        output_type: type[T] = str,  # type: ignore[assignment]
+        output_type: type[T] = str,
     ) -> T:
         """Acts like a standard Python `input()` a bunch of cool extra features.\n
         ------------------------------------------------------------------------------------

src/xulbux/path.py

@@ -4,7 +4,7 @@
 
 from .base.exceptions import PathNotFoundError
 
-from typing import Optional
+from typing import Optional, cast
 import tempfile as _tempfile
 import difflib as _difflib
 import shutil as _shutil
@@ -37,9 +37,9 @@ def __get__(self, obj, owner=None):
 class Path:
     """This class provides methods to work with file and directory paths."""
 
-    cwd: str = _Cwd()  # type: ignore[assignment]
+    cwd: str = cast(str, _Cwd())
     """The path to the current working directory."""
-    script_dir: str = _ScriptDir()  # type: ignore[assignment]
+    script_dir: str = cast(str, _ScriptDir())
     """The path to the directory of the current script."""
 
     @staticmethod
@@ -63,68 +63,82 @@ def extend(
         it will be searched in the `search_in` directory/s.<br>
         If the `rel_path` is still not found, it returns `None` or
         raises a `PathNotFoundError` if `raise_error` is true."""
-        if rel_path in {"", None}:
+        search_dirs: list[str] = []
+
+        if not isinstance(rel_path, str):
+            raise TypeError(f"The 'rel_path' parameter must be a string, got {type(rel_path)}")
+        if search_in is not None:
+            if isinstance(search_in, str):
+                search_dirs.extend([search_in])
+            elif isinstance(search_in, list):
+                if not all(isinstance(item, str) for item in search_in):
+                    raise TypeError("All items in the 'search_in' list must be strings.")
+                search_dirs.extend(search_in)
+            else:
+                raise TypeError(f"The 'search_in' parameter must be a string or a list of strings, got {type(search_in)}")
+        if not isinstance(raise_error, bool):
+            raise TypeError(f"The 'raise_error' parameter must be a boolean, got {type(raise_error)}")
+        if not isinstance(use_closest_match, bool):
+            raise TypeError(f"The 'use_closest_match' parameter must be a boolean, got {type(use_closest_match)}")
+
+        if rel_path == "":
             if raise_error:
                 raise PathNotFoundError("Path is empty.")
-            return None
+            else:
+                return None
         elif _os.path.isabs(rel_path):
             return rel_path
 
         def get_closest_match(dir: str, part: str) -> Optional[str]:
             try:
-                files_and_dirs = _os.listdir(dir)
-                matches = _difflib.get_close_matches(part, files_and_dirs, n=1, cutoff=0.6)
+                matches = _difflib.get_close_matches(part, _os.listdir(dir), n=1, cutoff=0.6)
                 return matches[0] if matches else None
             except Exception:
                 return None
 
         def find_path(start: str, parts: list[str]) -> Optional[str]:
             current = start
+
             for part in parts:
                 if _os.path.isfile(current):
                     return current
                 closest_match = get_closest_match(current, part) if use_closest_match else part
                 current = _os.path.join(current, closest_match) if closest_match else None
                 if current is None:
                     return None
+
             return current if _os.path.exists(current) and current != start else None
 
         def expand_env_path(p: str) -> str:
             if "%" not in p:
                 return p
-            parts = p.split("%")
-            for i in range(1, len(parts), 2):
+
+            for i in range(1, len(parts := p.split("%")), 2):
                 if parts[i].upper() in _os.environ:
                     parts[i] = _os.environ[parts[i].upper()]
+
             return "".join(parts)
 
         rel_path = _os.path.normpath(expand_env_path(rel_path))
+
         if _os.path.isabs(rel_path):
             drive, rel_path = _os.path.splitdrive(rel_path)
             rel_path = rel_path.lstrip(_os.sep)
-            search_dirs = [(drive + _os.sep) if drive else _os.sep]
+            search_dirs.extend([(drive + _os.sep) if drive else _os.sep])
         else:
             rel_path = rel_path.lstrip(_os.sep)
-            base_dir = Path.script_dir
-            search_dirs = [
-                _os.getcwd(),
-                base_dir,
-                _os.path.expanduser("~"),
-                _tempfile.gettempdir(),
-            ]
-        if search_in:
-            search_dirs.extend([search_in] if isinstance(search_in, str) else search_in)
-        path_parts = rel_path.split(_os.sep)
+            search_dirs.extend([_os.getcwd(), Path.script_dir, _os.path.expanduser("~"), _tempfile.gettempdir()])
+
         for search_dir in search_dirs:
-            full_path = _os.path.join(search_dir, rel_path)
-            if _os.path.exists(full_path):
+            if _os.path.exists(full_path := _os.path.join(search_dir, rel_path)):
                 return full_path
-            match = find_path(search_dir, path_parts) if use_closest_match else None
-            if match:
+            if (match := find_path(search_dir, rel_path.split(_os.sep)) if use_closest_match else None):
                 return match
+
         if raise_error:
             raise PathNotFoundError(f"Path '{rel_path}' not found in specified directories.")
-        return None
+        else:
+            return None
 
     @staticmethod
     def extend_or_make(
@@ -151,12 +165,24 @@ def extend_or_make(
         even though the `rel_path` doesn't exist there.<br>
         If `prefer_script_dir` is false, it will instead make a path
         that points to where the `rel_path` would be in the CWD."""
+        # THE 'rel_path' PARAM IS CHECKED IN 'Path.extend()'
+        # THE 'search_in' PARAM IS CHECKED IN 'Path.extend()'
+        if not isinstance(prefer_script_dir, bool):
+            raise TypeError(f"The 'prefer_script_dir' parameter must be a boolean, got {type(prefer_script_dir)}")
+        # THE 'use_closest_match' PARAM IS CHECKED IN 'Path.extend()'
+
         try:
-            return str(Path.extend(rel_path, search_in, raise_error=True, use_closest_match=use_closest_match))
+            return str(Path.extend( \
+                rel_path=rel_path,
+                search_in=search_in,
+                raise_error=True,
+                use_closest_match=use_closest_match,
+            ))
         except PathNotFoundError:
-            normalized_rel_path = _os.path.normpath(rel_path)
-            base = Path.script_dir if prefer_script_dir else _os.getcwd()
-            return _os.path.join(base, normalized_rel_path)
+            return _os.path.join(
+                Path.script_dir if prefer_script_dir else _os.getcwd(),
+                _os.path.normpath(rel_path),
+            )
 
     @staticmethod
     def remove(path: str, only_content: bool = False) -> None:
@@ -165,13 +191,20 @@ def remove(path: str, only_content: bool = False) -> None:
         - `path` -⠀the path to the directory or file to remove
         - `only_content` -⠀if true, only the content of the directory is removed
           and the directory itself is kept"""
+        if not isinstance(path, str):
+            raise TypeError(f"The 'path' parameter must be a string, got {type(path)}")
+        if not isinstance(only_content, bool):
+            raise TypeError(f"The 'only_content' parameter must be a boolean, got {type(only_content)}")
+
         if not _os.path.exists(path):
             return None
+
         if not only_content:
             if _os.path.isfile(path) or _os.path.islink(path):
                 _os.unlink(path)
             elif _os.path.isdir(path):
                 _shutil.rmtree(path)
+
         elif _os.path.isdir(path):
             for filename in _os.listdir(path):
                 file_path = _os.path.join(path, filename)

src/xulbux/system.py

@@ -8,7 +8,7 @@
 from .format_codes import FormatCodes
 from .console import Console
 
-from typing import Optional
+from typing import Optional, cast
 import subprocess as _subprocess
 import platform as _platform
 import ctypes as _ctypes
@@ -33,7 +33,7 @@ def __get__(self, obj, owner=None):
 class System:
     """This class provides methods to interact with the underlying operating system."""
 
-    is_elevated: bool = _IsElevated()  # type: ignore[assignment]
+    is_elevated: bool = cast(bool, _IsElevated())
     """Is `True` if the current process has elevated privileges and `False` otherwise."""
 
     @staticmethod

tests/test_color.py

@@ -27,7 +27,7 @@ def test_is_valid_rgba():
     assert Color.is_valid_rgba({"r": 255, "g": 0, "b": 0, "a": 0.5}) is True
     assert Color.is_valid_rgba(rgba(255, 0, 0)) is True
     assert Color.is_valid_rgba((300, 0, 0)) is False
-    assert Color.is_valid_rgba((255, 0)) is False  # type: ignore[assignment]
+    assert Color.is_valid_rgba((255, 0)) is False
     assert Color.is_valid_rgba((255, 0, 0, 2)) is False
     assert Color.is_valid_rgba("not a color") is False
     assert Color.is_valid_rgba((255, 0, 0), allow_alpha=False) is True
@@ -45,7 +45,7 @@ def test_is_valid_hsla():
     assert Color.is_valid_hsla((370, 100, 50)) is False
     assert Color.is_valid_hsla((0, 101, 50)) is False
     assert Color.is_valid_hsla((0, 100, 101)) is False
-    assert Color.is_valid_hsla((0, 100)) is False  # type: ignore[assignment]
+    assert Color.is_valid_hsla((0, 100)) is False
     assert Color.is_valid_hsla("not a color") is False
     assert Color.is_valid_hsla((0, 100, 50), allow_alpha=False) is True
     assert Color.is_valid_hsla((0, 100, 50, 0.5), allow_alpha=False) is False
@@ -117,8 +117,8 @@ def test_str_to_rgba():
     assert color.values() == (255, 0, 0, 0.5)
     colors = Color.str_to_rgba("first color: rgb(255, 0, 0) | second color: rgba(0,255,0,.5)")
     assert len(colors) == 2  # type: ignore[assignment]
-    assert colors[0].values() == (255, 0, 0, None)  # type: ignore
-    assert colors[1].values() == (0, 255, 0, 0.5)  # type: ignore
+    assert colors[0].values() == (255, 0, 0, None)  # type: ignore[not-subscriptable]
+    assert colors[1].values() == (0, 255, 0, 0.5)  # type: ignore[not-subscriptable]
     assert Color.str_to_rgba("No colors here") is None
 
 
@@ -159,7 +159,7 @@ def test_adjust_lightness():
 
 def test_adjust_saturation():
     color = rgba(128, 80, 80)
-    saturated = Color.adjust_saturation(color, 0.25)  # type: ignore[assignment]
+    saturated = Color.adjust_saturation(color, 0.25)
     assert isinstance(saturated, rgba)
     assert saturated.to_hsla().s > color.to_hsla().s
     assert saturated == rgba(155, 54, 54)

tests/test_console.py

@@ -220,12 +220,12 @@ def test_get_args_no_spaces(monkeypatch, argv, find_args, expected_args_dict):
     for key, expected in expected_args_dict.items():
         assert (key in args_result) is True
         assert isinstance(args_result[key], ArgResult)
-        assert args_result[key].exists == expected["exists"]  # type: ignore[access]
+        assert args_result[key].exists == expected["exists"]  # type: ignore[cannot-access-attr]
         # CHECK IF THIS IS A POSITIONAL ARG (HAS 'values') OR REGULAR ARG (HAS 'value')
         if "values" in expected:
-            assert args_result[key].values == expected["values"]  # type: ignore[access]
+            assert args_result[key].values == expected["values"]  # type: ignore[cannot-access-attr]
         else:
-            assert args_result[key].value == expected["value"]  # type: ignore[access]
+            assert args_result[key].value == expected["value"]  # type: ignore[cannot-access-attr]
         assert bool(args_result[key]) == expected["exists"]
     assert list(args_result.keys()) == list(expected_args_dict.keys())
     assert [v.exists for v in args_result.values()] == [d["exists"] for d in expected_args_dict.values()]
@@ -388,7 +388,7 @@ def test_get_args_invalid_config():
         Console.get_args({"bad_flags": {"flags": ["--flag"]}})  # type: ignore[assignment]
 
     with pytest.raises(ValueError, match="Invalid 'flags' for alias 'bad_flags'. Must be a set of strings."):
-        Console.get_args({"bad_flags": {"flags": "not-a-list", "default": "value"}})  # type: ignore[assignment]
+        Console.get_args({"bad_flags": {"flags": "not-a-set", "default": "value"}})  # type: ignore[assignment]
 
 
 def test_get_args_duplicate_flag():

tests/test_path.py

@@ -60,9 +60,10 @@ def test_extend(setup_test_environment):
 
     # EMPTY PATH
     assert Path.extend("") is None
-    assert Path.extend(None) is None  # type: ignore[assignment]
     with pytest.raises(PathNotFoundError, match="Path is empty."):
         Path.extend("", raise_error=True)
+    with pytest.raises(TypeError, match="parameter must be a string"):
+        Path.extend(None, raise_error=True)  # type: ignore[assignment]
 
     # FOUND IN STANDARD LOCATIONS
     assert Path.extend("file_in_cwd.txt") == str(env["cwd"] / "file_in_cwd.txt")