Python 3.9 Modernization

CHANGES

@@ -15,6 +15,16 @@ $ pip install --user --upgrade --pre libtmux
 
 <!-- To maintainers and contributors: Please add notes for the forthcoming version above -->
 
+### Development
+
+- Aggressive automated lint fixes via `ruff` (#550)
+
+  via ruff v0.8.4, all automated lint fixes, including unsafe and previews were applied for Python 3.9:
+
+  ```sh
+  ruff check --select ALL . --fix --unsafe-fixes --preview --show-fixes; ruff format .
+  ```
+
 ## libtmux 0.39.0 (2024-11-26)
 
 _Maintenance only, no bug fixes or new features_

conftest.py

@@ -27,7 +27,7 @@
 @pytest.fixture(autouse=True)
 def add_doctest_fixtures(
     request: pytest.FixtureRequest,
-    doctest_namespace: t.Dict[str, t.Any],
+    doctest_namespace: dict[str, t.Any],
 ) -> None:
     """Configure doctest fixtures for pytest-doctest."""
     if isinstance(request._pyfuncitem, DoctestItem) and shutil.which("tmux"):

docs/conf.py

@@ -22,7 +22,7 @@
 sys.path.insert(0, str(cwd / "_ext"))
 
 # package data
-about: t.Dict[str, str] = {}
+about: dict[str, str] = {}
 with (project_src / "libtmux" / "__about__.py").open() as fp:
     exec(fp.read(), about)
 
@@ -71,8 +71,8 @@
 html_css_files = ["css/custom.css"]
 html_extra_path = ["manifest.json"]
 html_theme = "furo"
-html_theme_path: t.List[str] = []
-html_theme_options: t.Dict[str, t.Union[str, t.List[t.Dict[str, str]]]] = {
+html_theme_path: list[str] = []
+html_theme_options: dict[str, t.Union[str, list[dict[str, str]]]] = {
     "light_logo": "img/libtmux.svg",
     "dark_logo": "img/libtmux.svg",
     "footer_icons": [
@@ -138,7 +138,7 @@
 }
 
 
-def linkcode_resolve(domain: str, info: t.Dict[str, str]) -> t.Union[None, str]:
+def linkcode_resolve(domain: str, info: dict[str, str]) -> t.Union[None, str]:
     """
     Determine the URL corresponding to Python object.
 

pyproject.toml

@@ -119,6 +119,7 @@ build-backend = "hatchling.build"
 
 [tool.mypy]
 strict = true
+python_version = "3.9"
 files = [
   "src",
   "tests",
@@ -147,7 +148,7 @@ exclude_lines = [
 ]
 
 [tool.ruff]
-target-version = "py38"
+target-version = "py39"
 
 [tool.ruff.lint]
 select = [

src/libtmux/_internal/query_list.py

@@ -20,8 +20,8 @@ class LookupProtocol(t.Protocol):
 
         def __call__(
             self,
-            data: t.Union[str, t.List[str], "Mapping[str, str]"],
-            rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+            data: t.Union[str, list[str], "Mapping[str, str]"],
+            rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
         ) -> bool:
             """Return callback for :class:`QueryList` filtering operators."""
             ...
@@ -43,7 +43,7 @@ class ObjectDoesNotExist(Exception):
 def keygetter(
     obj: "Mapping[str, t.Any]",
     path: str,
-) -> t.Union[None, t.Any, str, t.List[str], "Mapping[str, str]"]:
+) -> t.Union[None, t.Any, str, list[str], "Mapping[str, str]"]:
     """Fetch values in objects and keys, supported nested data.
 
     **With dictionaries**:
@@ -151,15 +151,15 @@ def parse_lookup(
 
 
 def lookup_exact(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     return rhs == data
 
 
 def lookup_iexact(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     if not isinstance(rhs, str) or not isinstance(data, str):
         return False
@@ -168,8 +168,8 @@ def lookup_iexact(
 
 
 def lookup_contains(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     if not isinstance(rhs, str) or not isinstance(data, (str, Mapping, list)):
         return False
@@ -178,8 +178,8 @@ def lookup_contains(
 
 
 def lookup_icontains(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     if not isinstance(rhs, str) or not isinstance(data, (str, Mapping, list)):
         return False
@@ -193,8 +193,8 @@ def lookup_icontains(
 
 
 def lookup_startswith(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     if not isinstance(rhs, str) or not isinstance(data, str):
         return False
@@ -203,8 +203,8 @@ def lookup_startswith(
 
 
 def lookup_istartswith(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     if not isinstance(rhs, str) or not isinstance(data, str):
         return False
@@ -213,8 +213,8 @@ def lookup_istartswith(
 
 
 def lookup_endswith(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     if not isinstance(rhs, str) or not isinstance(data, str):
         return False
@@ -223,17 +223,17 @@ def lookup_endswith(
 
 
 def lookup_iendswith(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     if not isinstance(rhs, str) or not isinstance(data, str):
         return False
     return data.lower().endswith(rhs.lower())
 
 
 def lookup_in(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     if isinstance(rhs, list):
         return data in rhs
@@ -254,8 +254,8 @@ def lookup_in(
 
 
 def lookup_nin(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     if isinstance(rhs, list):
         return data not in rhs
@@ -276,17 +276,17 @@ def lookup_nin(
 
 
 def lookup_regex(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     if isinstance(data, (str, bytes, re.Pattern)) and isinstance(rhs, (str, bytes)):
         return bool(re.search(rhs, data))
     return False
 
 
 def lookup_iregex(
-    data: t.Union[str, t.List[str], "Mapping[str, str]"],
-    rhs: t.Union[str, t.List[str], "Mapping[str, str]", "re.Pattern[str]"],
+    data: t.Union[str, list[str], "Mapping[str, str]"],
+    rhs: t.Union[str, list[str], "Mapping[str, str]", "re.Pattern[str]"],
 ) -> bool:
     if isinstance(data, (str, bytes, re.Pattern)) and isinstance(rhs, (str, bytes)):
         return bool(re.search(rhs, data, re.IGNORECASE))
@@ -320,7 +320,7 @@ def __init__(self, op: str, *args: object) -> None:
         return super().__init__(f"{op} not in LOOKUP_NAME_MAP")
 
 
-class QueryList(t.List[T], t.Generic[T]):
+class QueryList(list[T], t.Generic[T]):
     """Filter list of object/dictionaries. For small, local datasets.
 
     *Experimental, unstable*.
@@ -475,7 +475,7 @@ class QueryList(t.List[T], t.Generic[T]):
     def __init__(self, items: t.Optional["Iterable[T]"] = None) -> None:
         super().__init__(items if items is not None else [])
 
-    def items(self) -> t.List[t.Tuple[str, T]]:
+    def items(self) -> list[tuple[str, T]]:
         if self.pk_key is None:
             raise PKRequiredException
         return [(getattr(item, self.pk_key), item) for item in self]
@@ -531,19 +531,19 @@ def filter_lookup(obj: t.Any) -> bool:
             return True
 
         if callable(matcher):
-            _filter = matcher
+            filter_ = matcher
         elif matcher is not None:
 
-            def val_match(obj: t.Union[str, t.List[t.Any], T]) -> bool:
+            def val_match(obj: t.Union[str, list[t.Any], T]) -> bool:
                 if isinstance(matcher, list):
                     return obj in matcher
                 return bool(obj == matcher)
 
-            _filter = val_match
+            filter_ = val_match
         else:
-            _filter = filter_lookup
+            filter_ = filter_lookup
 
-        return self.__class__(k for k in self if _filter(k))
+        return self.__class__(k for k in self if filter_(k))
 
     def get(
         self,