chore: Improve typeguard validator naming (#2666)

Co-authored-by: Håkon V. Treider <haakonvt@gmail.com>

Author: erlendvollset

cognite/client/_api/datapoint_tasks.py

@@ -34,7 +34,7 @@
     DatapointsArray,
     DatapointsQuery,
 )
-from cognite.client.utils._auxiliary import exactly_one_is_not_none, is_finite, is_unlimited
+from cognite.client.utils._auxiliary import exactly_one_is_not_none, is_non_negative_int, is_unlimited
 from cognite.client.utils._datapoints import (
     AggregateDatapoints,
     DatapointsRaw,
@@ -300,7 +300,7 @@ def _verify_and_convert_granularity(granularity: str | None) -> tuple[str | None
     def _verify_and_convert_limit(limit: int | None) -> int | None:
         if is_unlimited(limit):
             return None
-        elif is_finite(limit):  # limit=0 is accepted by the API
+        elif is_non_negative_int(limit):  # limit=0 is accepted by the API
             try:
                 # We don't want weird stuff like numpy dtypes etc:
                 return int(limit)

cognite/client/_api/datapoints.py

@@ -52,8 +52,7 @@
 from cognite.client.utils._auxiliary import (
     exactly_one_is_not_none,
     find_duplicates,
-    is_finite,
-    is_positive,
+    is_positive_int,
     split_into_chunks,
     split_into_n_parts,
     unpack_items,
@@ -673,15 +672,15 @@ async def __call__(
         # get 10k/100k datapoints per request. Thus, we round up the given chunk size to the nearest integer multiple of 100k,
         # then subdivide and yield client-side (we use the raw limit also when dealing with aggregates):
         request_limit = self._DPS_LIMIT_RAW * math.ceil(chunk_size_datapoints / self._DPS_LIMIT_RAW)
-        if not is_finite(chunk_size_datapoints) or (
+        if not is_positive_int(chunk_size_datapoints) or (
             chunk_size_datapoints != request_limit and request_limit % chunk_size_datapoints
         ):
             raise ValueError(
                 "The 'chunk_size_datapoints' must be a positive integer that evenly divides 100k OR an integer multiple of 100k "
                 f"(to ensure efficient API usage), not {chunk_size_datapoints}."
             )
 
-        if not (chunk_size_time_series is None or is_positive(chunk_size_time_series)):
+        if not (chunk_size_time_series is None or is_positive_int(chunk_size_time_series)):
             raise ValueError(
                 f"'chunk_size_time_series' must be a positive integer or None, not {chunk_size_time_series}"
             )

cognite/client/_api/raw/rows.py

@@ -12,7 +12,7 @@
 from cognite.client.utils._auxiliary import (
     drop_none_values,
     find_duplicates,
-    is_finite,
+    is_non_negative_int,
     is_unlimited,
     split_into_chunks,
     unpack_items,
@@ -179,7 +179,7 @@ async def _list_generator_concurrent(
 
         concurrency_limit = global_config.concurrency_settings.raw.read
         partitions = min(partitions, concurrency_limit)
-        if is_finite(limit):
+        if is_non_negative_int(limit):
             partitions = min(partitions, concurrency_limit, math.ceil(limit / 20_000))
             if chunk_size is not None and limit < chunk_size:
                 raise ValueError(f"chunk_size ({chunk_size}) should be much smaller than limit ({limit})")
@@ -226,7 +226,7 @@ async def _fetch_and_enqueue(iterator: AsyncIterator[RowList]) -> None:
                     await asyncio.sleep(0.5)
                     continue
 
-                if not is_finite(limit):
+                if not is_non_negative_int(limit):
                     yield chunk
                     continue
 

cognite/client/_sync_api/datapoints.py

@@ -8,7 +8,7 @@
 
 from cognite.client._version import __api_subversion__
 from cognite.client.credentials import CredentialProvider
-from cognite.client.utils._auxiliary import is_finite, is_positive, load_resource_to_dict
+from cognite.client.utils._auxiliary import is_non_negative_int, is_positive_int, load_resource_to_dict
 from cognite.client.utils._concurrency import ConcurrencySettings
 from cognite.client.utils._importing import local_import
 
@@ -78,21 +78,21 @@ def __init__(self) -> None:
         self.file_upload_chunk_size: int | None = None
         self.silence_feature_preview_warnings: bool = False
 
-    def __setattr__(self, name: str, value: Any) -> None:
+    def __setattr__(self, name: str, val: Any) -> None:
         # Why __setattr__ instead of just more use of @property? It is to avoid breaking a bunch of existing
         # inspection code (which would then need special handling). Setting global config options is a rare
         # one-off type event, so overhead is no issue.
         match name:
-            case "max_retries" | "max_retries_connect" | "max_retry_backoff" if not is_finite(value):
-                raise ValueError(f"{name} must be a non-negative integer, got {value!r}")
+            case "max_retries" | "max_retries_connect" | "max_retry_backoff" if not is_non_negative_int(val):
+                raise ValueError(f"{name} must be a non-negative integer, got {val!r}")
 
-            case "max_connection_pool_size" if not is_positive(value):
-                raise ValueError(f"max_connection_pool_size must be a positive integer, got {value!r}")
+            case "max_connection_pool_size" if not is_positive_int(val):
+                raise ValueError(f"max_connection_pool_size must be a positive integer, got {val!r}")
 
-            case "file_download_chunk_size" | "file_upload_chunk_size" if value is not None and not is_positive(value):
-                raise ValueError(f"{name} must be a positive integer or None, got {value!r}")
+            case "file_download_chunk_size" | "file_upload_chunk_size" if val is not None and not is_positive_int(val):
+                raise ValueError(f"{name} must be a positive integer or None, got {val!r}")
 
-        super().__setattr__(name, value)
+        super().__setattr__(name, val)
 
     @property
     def max_workers(self) -> int:
@@ -219,7 +219,9 @@ def __init__(
         self.timeout = timeout or 60
         self.file_transfer_timeout = file_transfer_timeout or 600
         if debug:
-            self.debug = True
+            from cognite.client.utils._logging import _configure_logger_for_debug_mode
+
+            _configure_logger_for_debug_mode()
         self._validate_config()
 
         if not global_config.disable_pypi_version_check:

cognite/client/_sync_api/raw/rows.py

@@ -9,7 +9,7 @@
 
 from cognite.client.data_classes._base import CogniteResource, UnknownCogniteResource
 from cognite.client.data_classes.data_modeling.ids import ContainerId, NodeId
-from cognite.client.utils._auxiliary import is_positive, rename_and_exclude_keys
+from cognite.client.utils._auxiliary import is_positive_int, rename_and_exclude_keys
 from cognite.client.utils._text import convert_all_keys_recursive
 
 logger = logging.getLogger(__name__)
@@ -141,7 +141,7 @@ class ListablePropertyType(PropertyType, ABC):
     max_list_size: int | None = None
 
     def __post_init__(self) -> None:
-        if is_positive(self.max_list_size) and not self.is_list:
+        if is_positive_int(self.max_list_size) and not self.is_list:
             raise ValueError("is_list must be True if max_list_size is set")
 
 

cognite/client/config.py

@@ -48,11 +48,11 @@ def no_op(x: T) -> T:
     return x
 
 
-def is_finite(limit: Any) -> TypeGuard[int]:
+def is_non_negative_int(limit: Any) -> TypeGuard[int]:
     return isinstance(limit, int) and limit >= 0
 
 
-def is_positive(limit: Any) -> TypeGuard[int]:
+def is_positive_int(limit: Any) -> TypeGuard[int]:
     return isinstance(limit, int) and limit > 0