Linting and type hint updates for new version

rbell517 · rbell517 · commit 3f3d35216e6d · 2025-11-11T15:58:14.000-06:00
diff --git a/.flake8 b/.flake8
@@ -4,11 +4,21 @@ max-line-length = 119
 # but keep line length to 88 in general
 # - use "black" to auto-format
 
+# D400 and D205 are because we sometimes split the first line of the docstring
+# F821 is temporary, until code is complete and stuff like ObjectDisposedException is gone
 ignore =
-    # D400 and D205 are because we sometimes split the first line of the docstring
-    *.py E203, W503, D100,D101,D102,D105,D106,D107, D400,D205, D415
-    # temporary, until code is complete and stuff like ObjectDisposedException is gone:
-    *.py F821
+    E203,
+    W503,
+    D100,
+    D101,
+    D102,
+    D105,
+    D106,
+    D107,
+    D400,
+    D205,
+    D415,
+    F821
 
 # Config for flake8-docstrings
 docstring-convention = google
diff --git a/nisystemlink/clients/core/_http_configuration.py b/nisystemlink/clients/core/_http_configuration.py
@@ -58,9 +58,9 @@ def __init__(
             )
         self._server_uri = urllib.parse.urlunsplit(uri[:2] + ("", "", ""))
 
-        self._api_keys = None  # type: Optional[Dict[str, str]]
-        self._username = None  # type: Optional[str]
-        self._password = None  # type: Optional[str]
+        self._api_keys: Optional[Dict[str, str]] = None
+        self._username: Optional[str] = None
+        self._password: Optional[str] = None
         if api_key:
             self._api_keys = {self._SYSTEM_LINK_API_KEY_HEADER: api_key}
         elif username or password:
@@ -71,7 +71,7 @@ def __init__(
 
         self._cert_path = cert_path
 
-        self._user_agent = ""  # type: Optional[str]
+        self._user_agent: Optional[str] = ""
 
         self._timeout_ms = self.DEFAULT_TIMEOUT_MILLISECONDS
 
diff --git a/nisystemlink/clients/core/_http_configuration_manager.py b/nisystemlink/clients/core/_http_configuration_manager.py
@@ -110,7 +110,7 @@ def _read_virtual_configurations(cls) -> Dict[str, core.HttpConfiguration]:
             A dictionary mapping each loaded configuration ID to its corresponding
             :class:`HttpConfiguration`.
         """
-        configurations = {}  # type: Dict[str, core.HttpConfiguration]
+        configurations: Dict[str, core.HttpConfiguration] = {}
         try:
             configurations[cls._HTTP_JUPYTER_CONFIGURATION_ID] = (
                 core.JupyterHttpConfiguration()
@@ -135,7 +135,7 @@ def _read_configurations(cls) -> Dict[str, core.HttpConfiguration]:
             ApiException: if an OS or permission error prevents reading the directory
                 that contains HTTP configurations.
         """
-        configurations = {}  # type: Dict[str, core.HttpConfiguration]
+        configurations: Dict[str, core.HttpConfiguration] = {}
         path = cls._http_configurations_directory()
         if not path.exists():
             return configurations
@@ -162,14 +162,12 @@ def _read_configurations(cls) -> Dict[str, core.HttpConfiguration]:
                 if not config_file.uri:
                     continue
 
-                cert_path = None  # type: Optional[pathlib.Path]
+                cert_path: Optional[pathlib.Path] = None
                 if config_file.cert_path:
-                    cert_path = typing.cast(
-                        pathlib.Path,
-                        PathConstants.application_data_directory
-                        / "Certificates"
-                        / config_file.cert_path,
+                    app_data_dir = typing.cast(
+                        pathlib.Path, PathConstants.application_data_directory
                     )
+                    cert_path = app_data_dir / "Certificates" / config_file.cert_path
                     if not cert_path.exists():
                         cert_path = None
                 configurations[config_file.id] = core.HttpConfiguration(
@@ -226,7 +224,10 @@ def _http_configurations_directory(cls) -> pathlib.Path:
         Returns:
             pathlib.Path: The path of the HTTP Configurations directory.
         """
-        return PathConstants.application_data_directory / "HttpConfigurations"
+        app_data_dir = typing.cast(
+            pathlib.Path, PathConstants.application_data_directory
+        )
+        return app_data_dir / "HttpConfigurations"
 
     @classmethod
     def _salt_grains_path(cls) -> pathlib.Path:
@@ -235,7 +236,8 @@ def _salt_grains_path(cls) -> pathlib.Path:
         Returns:
             pathlib.Path: The path of SALT grains config file
         """
-        return PathConstants.salt_data_directory / "conf" / "grains"
+        salt_data_dir = typing.cast(pathlib.Path, PathConstants.salt_data_directory)
+        return salt_data_dir / "conf" / "grains"
 
     @classmethod
     def _read_system_workspace(cls) -> Optional[str]:
diff --git a/nisystemlink/clients/core/_internal/_path_constants.py b/nisystemlink/clients/core/_internal/_path_constants.py
@@ -5,7 +5,6 @@
 import os
 import pathlib
 import typing
-from typing import Optional
 
 from nisystemlink.clients.core._internal._classproperty_support import (
     ClasspropertySupport,
@@ -21,9 +20,9 @@ class PathConstants(metaclass=ClasspropertySupport):
 
     PRODUCT_NAME = "Skyline"
 
-    _application_data_directory = None  # type: Optional[pathlib.Path]
+    _application_data_directory: typing.Optional[pathlib.Path] = None
 
-    _salt_data_directory = None  # type: Optional[pathlib.Path]
+    _salt_data_directory: typing.Optional[pathlib.Path] = None
 
     def __init_subclass__(cls) -> None:
         raise TypeError("type 'PathConstants' is not an acceptable base type")
diff --git a/nisystemlink/clients/tag/_async_tag_query_result_collection.py b/nisystemlink/clients/tag/_async_tag_query_result_collection.py
@@ -22,7 +22,7 @@ def __init__(
             skip: The skip used for the first page of results.
         """
         self._total_count = total_count
-        self._current_page = None  # type: Optional[List[tbase.TagData]]
+        self._current_page: Optional[List[tbase.TagData]] = None
         if first_page:
             if skip >= total_count:
                 raise core.ApiException(
diff --git a/nisystemlink/clients/tag/_buffered_tag_writer.py b/nisystemlink/clients/tag/_buffered_tag_writer.py
@@ -6,8 +6,9 @@
 import datetime
 import sys
 import threading
+import typing  # noqa: F401
 from types import TracebackType
-from typing import Any, Callable, Optional, Type
+from typing import Any, Optional, Type
 
 from nisystemlink.clients import core, tag as tbase
 from nisystemlink.clients.tag._core._itime_stamper import ITimeStamper
@@ -45,9 +46,9 @@ def __init__(
 
         self._closed = False
         self._num_buffered = 0
-        self._send_error = None  # type: Optional[core.ApiException]
+        self._send_error: Optional[core.ApiException] = None
         self._timer_generation = 0
-        self._timer_handler = None  # type: Optional[Callable[[], None]]
+        self._timer_handler: typing.Optional[typing.Callable[[], None]] = None
 
     @abc.abstractmethod
     def _buffer_value(self, path: str, value: Any) -> None:
diff --git a/nisystemlink/clients/tag/_core/_manual_reset_timer.py b/nisystemlink/clients/tag/_core/_manual_reset_timer.py
@@ -38,10 +38,10 @@ def __init_subclass__(cls) -> None:
     # Under certain circumstances, mypy complains about the event not having a type hint
     # unless we specify it explicitly. (But we also need to delete the attribute so that
     # Events.__getattr__ can do its magic.)
-    elapsed = None  # type: events._EventSlot
+    elapsed: events._EventSlot = None  # type: ignore[assignment]
     del elapsed
 
-    __null_timer_impl = None  # type: Optional[ManualResetTimer]
+    __null_timer_impl: Optional["ManualResetTimer"] = None
 
     @ClasspropertySupport.classproperty
     def null_timer(cls) -> "ManualResetTimer":
@@ -77,7 +77,7 @@ def __init__(self, interval: datetime.timedelta) -> None:
         self._running = [None]  # used as mutable boolean; non-empty is True
         self._timer_start = threading.Event()
         self._timer_cancel = threading.Event()
-        self._thread = threading.Thread(
+        self._thread: Optional[threading.Thread] = threading.Thread(
             target=self._run,
             args=[
                 self._running,
@@ -86,7 +86,7 @@ def __init__(self, interval: datetime.timedelta) -> None:
                 self._timer_cancel,
                 self.elapsed,
             ],
-        )  # type: Optional[threading.Thread]
+        )
         self._thread.daemon = True
         self._thread.start()
 
diff --git a/nisystemlink/clients/tag/_http/_http_buffered_tag_writer.py b/nisystemlink/clients/tag/_http/_http_buffered_tag_writer.py
@@ -28,7 +28,7 @@ def __init__(
     ) -> None:
         super().__init__(stamper, buffer_size, flush_timer)
         self._api = client.at_uri("/nitag/v2")
-        self._buffer = OrderedDict()  # type: OrderedDict[str, Dict[str, Any]]
+        self._buffer: OrderedDict[str, Dict[str, Any]] = OrderedDict()
 
     def _buffer_value(self, path: str, value: Dict[str, Any]) -> None:
         if path not in self._buffer:
@@ -50,9 +50,9 @@ def _create_item(
         value: str,
         timestamp: Optional[datetime.datetime] = None,
     ) -> Dict[str, Any]:
-        item = {
+        item: Dict[str, Any] = {
             "value": {"value": value, "type": data_type.api_name}
-        }  # type: Dict[str, Any]
+        }
         if timestamp is not None:
             item["timestamp"] = TimestampUtilities.datetime_to_str(timestamp)
         return item
diff --git a/nisystemlink/clients/tag/_http/_http_tag_selection.py b/nisystemlink/clients/tag/_http/_http_tag_selection.py
@@ -163,7 +163,7 @@ async def _close_internal_async(self) -> None:
     def _create_subscription_internal(
         self, update_interval: Optional[datetime.timedelta] = None
     ) -> tbase.TagSubscription:
-        update_timer = None  # type: Optional[ManualResetTimer]
+        update_timer: Optional[ManualResetTimer] = None
         if update_interval is not None:
             update_timer = ManualResetTimer(update_interval)
         paths = set(self.paths).union(self.metadata.keys())
@@ -174,7 +174,7 @@ def _create_subscription_internal(
     async def _create_subscription_internal_async(
         self, update_interval: Optional[datetime.timedelta] = None
     ) -> tbase.TagSubscription:
-        update_timer = None  # type: Optional[ManualResetTimer]
+        update_timer: Optional[ManualResetTimer] = None
         if update_interval is not None:
             update_timer = ManualResetTimer(update_interval)
         paths = set(self.paths).union(self.metadata.keys())
@@ -241,7 +241,7 @@ def _handle_read_tags_values(
         if response is None or any(t is None for t in response):
             raise tbase.TagManager.invalid_response(http_response)
 
-        result = []  # type: List[Optional[SerializedTagWithAggregates]]
+        result: List[Optional[SerializedTagWithAggregates]] = []
         for i, t in enumerate(response):
             path = paths[i] if paths else t.get("path")
             if path is None:
diff --git a/nisystemlink/clients/tag/_http/_http_tag_subscription.py b/nisystemlink/clients/tag/_http/_http_tag_subscription.py
@@ -124,7 +124,7 @@ def callback() -> None:
 
         self._update_timer_handler = callback
         self._update_timer.elapsed += self._update_timer_handler
-        self._token = None  # type: Optional[str]
+        self._token: Optional[str] = None
 
     # Base class implementation is sufficient:
     #   def __enter__(self):
diff --git a/nisystemlink/clients/tag/_http/_temporary_tag_selection.py b/nisystemlink/clients/tag/_http/_temporary_tag_selection.py
@@ -60,7 +60,7 @@ def __init__(self, magic: object, client: HttpClient) -> None:
             magic == self.__MAGIC
         ), "Do not construct a TemporaryTagSelection directly. Use create() instead."
         self._api = client.at_uri("/nitag/v2/selections")
-        self._id = None  # type: Optional[str]
+        self._id: Optional[str] = None
 
     @property
     def id(self) -> Optional[str]:  # noqa: D401
diff --git a/nisystemlink/clients/tag/_itag_writer.py b/nisystemlink/clients/tag/_itag_writer.py
@@ -5,21 +5,21 @@
 import abc
 import datetime
 import typing
-from typing import Any, Awaitable, Dict, Optional, Tuple, Union
+from typing import Any, Awaitable, Optional, Union
 
 from nisystemlink.clients import tag as tbase
 from nisystemlink.clients.core._internal._timestamp_utilities import TimestampUtilities
 from typing_extensions import Literal
 
 
-_VALID_TYPES = {
+_VALID_TYPES: typing.Dict[tbase.DataType, Union[type, typing.Tuple[type, type]]] = {
     tbase.DataType.BOOLEAN: bool,
     tbase.DataType.DATE_TIME: datetime.datetime,
     tbase.DataType.DOUBLE: (float, int),
     tbase.DataType.INT32: int,
     tbase.DataType.UINT64: int,
     tbase.DataType.STRING: str,
-}  # type: Dict[tbase.DataType, Union[type, Tuple[type, type]]]
+}
 
 
 class _ITagWriterOverloads(abc.ABC):
diff --git a/nisystemlink/clients/tag/_tag_data.py b/nisystemlink/clients/tag/_tag_data.py
@@ -48,11 +48,11 @@ def __init__(
         self._path = path
         self._data_type = tbase.DataType.UNKNOWN if data_type is None else data_type
         self._keywords = list(keywords) if keywords else []
-        self._properties = {}  # type: Dict[str, str]
+        self._properties: Dict[str, str] = {}
         self._collect_aggregates = False
         self._retention_type = tbase.RetentionType.NONE
-        self._retention_count = None  # type: Optional[int]
-        self._retention_days = None  # type: Optional[int]
+        self._retention_count: Optional[int] = None
+        self._retention_days: Optional[int] = None
         if properties:
             self.replace_properties(properties)
 
@@ -70,7 +70,7 @@ def to_json_dict(self) -> Dict[str, Any]:
         if self.data_type == tbase.DataType.UNKNOWN:
             raise ValueError("Invalid tag data type")
 
-        data = {}  # type: Dict[str, Any]
+        data: Dict[str, Any] = {}
         data["path"] = self._path
         data["type"] = self._data_type.api_name
         data["collectAggregates"] = self.collect_aggregates
diff --git a/nisystemlink/clients/tag/_tag_data_update.py b/nisystemlink/clients/tag/_tag_data_update.py
@@ -58,11 +58,11 @@ def __init__(
                 "Must specify at least one of keywords or properties to update"
             )
         self._keywords = list(keywords) if keywords is not None else None
-        self._properties = None  # type: Optional[Dict[str, str]]
+        self._properties: Optional[Dict[str, str]] = None
         if properties is not None:
             self._properties = dict(properties)
 
-        self._collect_aggregates = None  # type: Optional[bool]
+        self._collect_aggregates: Optional[bool] = None
 
     @classmethod
     def from_tagdata(
@@ -113,10 +113,10 @@ def to_json_dict(self) -> Dict[str, Any]:
         if self.data_type == tbase.DataType.UNKNOWN:
             raise ValueError("Invalid tag data type")
 
-        data = {
+        data: Dict[str, Any] = {
             "path": tbase.TagPathUtilities.validate(self._path),
             "type": self._data_type.api_name,
-        }  # type: Dict[str, Any]
+        }
 
         if self._keywords is not None:
             data["keywords"] = self._keywords
diff --git a/nisystemlink/clients/tag/_tag_manager.py b/nisystemlink/clients/tag/_tag_manager.py
@@ -4,6 +4,7 @@
 
 import asyncio
 import datetime
+import typing
 from typing import (
     Any,
     Awaitable,
@@ -161,7 +162,7 @@ def open(
         if data_type == tbase.DataType.UNKNOWN:
             raise ValueError("Must specify a valid data type")
 
-        tag = None  # type: Optional[Dict[str, Any]]
+        tag: Optional[Dict[str, Any]] = None
         try:
             tag, _ = self._api.get(
                 "/tags/{path}", params={"path": tbase.TagPathUtilities.validate(path)}
@@ -224,7 +225,7 @@ async def open_async(
         if data_type == tbase.DataType.UNKNOWN:
             raise ValueError("Must specify a valid data type")
 
-        tag = None  # type: Optional[Dict[str, Any]]
+        tag: Optional[Dict[str, Any]] = None
         try:
             tag, _ = await self._api.as_async.get(
                 "/tags/{path}", params={"path": tbase.TagPathUtilities.validate(path)}
@@ -709,7 +710,7 @@ def create_writer(
                 raise ValueError("max_buffer_time must be at least 1 millisecond")
             timer = ManualResetTimer(max_buffer_time)
         else:
-            timer = ManualResetTimer.null_timer
+            timer = typing.cast(ManualResetTimer, ManualResetTimer.null_timer)
 
         return HttpBufferedTagWriter(
             self._http_client, SystemTimeStamper(), buffer_size, timer
@@ -820,8 +821,8 @@ def _handle_read(
         if response is None:
             return None
 
-        agg = response.get("aggregates") or {}  # type: Dict[str, Any]
-        current = response.get("current", response)  # type: Dict[str, Any]
+        agg: Dict[str, Any] = response.get("aggregates") or {}
+        current: Dict[str, Any] = response.get("current", response)
         if current is None:
             return None
 
@@ -834,7 +835,7 @@ def _handle_read(
 
         assert "value" in val
 
-        timestamp = None  # type: Optional[datetime.datetime]
+        timestamp: Optional[datetime.datetime] = None
         if include_timestamp:
             if current.get("timestamp") is None:
                 raise self.invalid_response(http_response)
diff --git a/nisystemlink/clients/tag/_tag_query_result_collection.py b/nisystemlink/clients/tag/_tag_query_result_collection.py
diff --git a/nisystemlink/clients/tag/_tag_selection.py b/nisystemlink/clients/tag/_tag_selection.py
diff --git a/nisystemlink/clients/tag/_tag_subscription.py b/nisystemlink/clients/tag/_tag_subscription.py
diff --git a/poetry.lock b/poetry.lock
diff --git a/pyproject.toml b/pyproject.toml
