diocument all exceptions in ruff rules

Author: mboot-github

pyproject.toml

@@ -156,28 +156,19 @@
     ]
 
     ignore = [
-        # ignore for now:
-        #"ARG001",
-        #"ARG002",
-
-        "D100",
-        "D101",
-        "D102",
-        "D104",
-        "D105",
-        "D107",
+        "D100", # Missing docstring in public module
+        "D101", # Missing docstring in public module
+        "D102", # Missing docstring in public method
         "D103", # Missing docstring in public function
+        "D104", # Missing docstring in public package
+        "D105", # Missing docstring in magic method
+        "D107", # Missing docstring in magic method
+        "D203", "D211", # `incorrect-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are incompatible. Ignoring `incorrect-blank-line-before-class`.
 
-        "N802",
-        "N803",
-        "N806",
-        "N812",
-        "N815",
-        "N816",
-        "N818",
-        "N999",
-
-        "PLR2004",
+        "N802", # Function name `getThisTld` should be lowercase
+        "N803", # Argument name `xx` should be lowercase
+        "N806", # Variable `xx` in function should be lowercase
+        "N999", # Invalid module name
 
         "PLR0911", # Too many return statements
         "PLR0912", # Too many branches
@@ -186,9 +177,10 @@
         "PLW0603", # Using the global statement to update `xxx` is discouraged
         "PLW0602", # Using global for `xxx` but no assignment is done
 
-        "RUF001","RUF067", "RUF012",
-        "S101", # Use of `assert` detected
+        "RUF001", # String contains ambiguous  urf8 char
+        "RUF067", # `__init__` module should only contain docstrings and re-exports
 
+        "S101", # Use of `assert` detected
         #
         "COM812", # The following rule may cause conflicts when used with the formatter: `COM812`
         "T201",   # print statements are ok, used in verbose mode

t1.py

@@ -5,6 +5,8 @@
 
 from whoisdomain import ProcFunc
 
+N = 26
+
 
 def remoteFunc(
     conn: Any,
@@ -51,7 +53,7 @@ def main() -> None:
         for item in names:
             v = f(item)
             print(v)
-        if n >= 26:
+        if n >= N:
             break
 
     f = pf.makeHandler(remoteFunc, restart_after_count)
@@ -61,7 +63,7 @@ def main() -> None:
         for item in names:
             v = f(item)
             print(v)
-        if n >= 26:
+        if n >= N:
             break
 
 

whoisdomain/__init__.py

@@ -25,13 +25,13 @@
 from .domain import Domain
 from .doWhoisCommand import setMyCache
 from .exceptions import (
-    FailedParsingWhoisOutput,
-    UnknownDateFormat,
-    UnknownTld,
-    WhoisCommandFailed,
-    WhoisCommandTimeout,
-    WhoisPrivateRegistry,
-    WhoisQuotaExceeded,
+    FailedParsingWhoisOutputError,
+    UnknownDateFormatError,
+    UnknownTldError,
+    WhoisCommandFailedError,
+    WhoisCommandTimeoutError,
+    WhoisPrivateRegistryError,
+    WhoisQuotaExceededError,
 )
 from .helpers import (
     cleanupWhoisResponse,
@@ -83,7 +83,7 @@
 
 TLD_LIB_PRESENT: bool = False
 try:
-    import tld as libTld  # noqa: F401
+    import tld as lib_tld  # noqa: F401
 
     TLD_LIB_PRESENT = True
 except ImportError as e:
@@ -94,7 +94,7 @@
     "ZZ",
     "DBMCache",
     "DummyCache",
-    "FailedParsingWhoisOutput",
+    "FailedParsingWhoisOutputError",
     "NoneStrings",
     "NoneStringsAdd",
     "ParameterContext",
@@ -105,12 +105,12 @@
     "SimpleCacheBase",
     "SimpleCacheWithFile",
     "TldInfo",
-    "UnknownDateFormat",
-    "UnknownTld",
-    "WhoisCommandFailed",
-    "WhoisCommandTimeout",
-    "WhoisPrivateRegistry",
-    "WhoisQuotaExceeded",
+    "UnknownDateFormatError",
+    "UnknownTldError",
+    "WhoisCommandFailedError",
+    "WhoisCommandTimeoutError",
+    "WhoisPrivateRegistryError",
+    "WhoisQuotaExceededError",
     "WhoisRdap",
     "cleanupWhoisResponse",
     "filterTldToSupportedPattern",

whoisdomain/cache/simpleCacheBase.py

@@ -11,11 +11,11 @@ def __init__(
         self,
         *,
         verbose: bool = False,
-        cacheMaxAge: int = (60 * 60 * 48),
+        cache_max_age: int = (60 * 60 * 48),
     ) -> None:
         self.verbose = verbose
         self.memCache: dict[str, tuple[float, str]] = {}
-        self.cacheMaxAge: int = cacheMaxAge
+        self.cache_max_age: int = cache_max_age
 
     def put(
         self,
@@ -38,7 +38,7 @@ def get(
             return None
 
         t = time.time()
-        hasExpired = cData[0] < (t - self.cacheMaxAge)
+        hasExpired = cData[0] < (t - self.cache_max_age)
         if hasExpired is True:
             return None
 

whoisdomain/cache/simpleCacheWithFile.py

@@ -12,28 +12,28 @@
 
 
 class SimpleCacheWithFile(SimpleCacheBase):
-    cacheFilePath: str | None = None
+    cache_file_path: str | None = None
 
     def __init__(
         self,
         *,
         verbose: bool = False,
-        cacheFilePath: str | None = None,
-        cacheMaxAge: int = (60 * 60 * 48),
+        cache_file_path: str | None = None,
+        cache_max_age: int = (60 * 60 * 48),
     ) -> None:
-        super().__init__(verbose=verbose, cacheMaxAge=cacheMaxAge)
-        self.cacheFilePath = cacheFilePath
+        super().__init__(verbose=verbose, cache_max_age=cache_max_age)
+        self.cache_file_path = cache_file_path
 
     def _fileLoad(
         self,
     ) -> None:
-        if self.cacheFilePath is None:
+        if self.cache_file_path is None:
             return
 
-        if not pathlib.Path(self.cacheFilePath).is_file():
+        if not pathlib.Path(self.cache_file_path).is_file():
             return
 
-        with pathlib.Path(self.cacheFilePath).open(encoding="utf-8") as f:
+        with pathlib.Path(self.cache_file_path).open(encoding="utf-8") as f:
             try:
                 self.memCache = json.load(f)
             except ValueError as e:
@@ -43,10 +43,10 @@ def _fileLoad(
     def _fileSave(
         self,
     ) -> None:
-        if self.cacheFilePath is None:
+        if self.cache_file_path is None:
             return
 
-        with pathlib.Path(self.cacheFilePath).open("w", encoding="utf-8") as f:
+        with pathlib.Path(self.cache_file_path).open("w", encoding="utf-8") as f:
             json.dump(self.memCache, f)
 
     def put(

whoisdomain/context/parameterContext.py

@@ -149,13 +149,7 @@
 class ParameterContext:
     params: dict[str, Any]
     value: dict[str, Any]
-
-    KT: dict[str, Any] = {
-        "int": int,
-        "float": float,
-        "str": str,
-        "bool": bool,
-    }
+    KT: dict[str, Any]
 
     def _loadDefaults(self) -> list[str]:
         mandatory: list[str] = []
@@ -205,6 +199,13 @@ def __init__(
         self,
         **kwargs: Any,
     ) -> None:
+        self.KT = {
+            "int": int,
+            "float": float,
+            "str": str,
+            "bool": bool,
+        }
+
         self.params = json.loads(ParamsStringJson)
         self.value = {}
 

whoisdomain/doWhoisCommand.py

@@ -46,8 +46,8 @@ def _initDefaultCache(
     # if no cache defined init the default cache (optional with file storage based on pc)
     CACHE_STUB = SimpleCacheWithFile(
         verbose=pc.verbose,
-        cacheFilePath=pc.cache_file,
-        cacheMaxAge=pc.cache_age,
+        cache_file_path=pc.cache_file,
+        cache_max_age=pc.cache_age,
     )
 
     msg = "initializing default cache"

whoisdomain/exceptions.py

@@ -5,37 +5,37 @@
 logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
 
 
-class WhoisException(Exception):
+class WhoisExceptionError(Exception):
     # make all other exeptions based on a generic exception
     pass
 
 
-class UnknownTld(WhoisException):
+class UnknownTldError(WhoisExceptionError):
     pass
 
 
-class FailedParsingWhoisOutput(WhoisException):
+class FailedParsingWhoisOutputError(WhoisExceptionError):
     pass
 
 
-class WhoisQuotaExceeded(WhoisException):
+class WhoisQuotaExceededError(WhoisExceptionError):
     pass
 
 
-class UnknownDateFormat(WhoisException):
+class UnknownDateFormatError(WhoisExceptionError):
     pass
 
 
-class WhoisCommandFailed(WhoisException):
+class WhoisCommandFailedError(WhoisExceptionError):
     pass
 
 
-class WhoisPrivateRegistry(WhoisException):
+class WhoisPrivateRegistryError(WhoisExceptionError):
     # also known as restricted : see comments at the bottom in tld_regexpr.py
     # almost no info is returned or there is no cli whois server at all:
     # see: https://www.iana.org/domains/root/db/<tld>.html
     pass
 
 
-class WhoisCommandTimeout(WhoisException):
+class WhoisCommandTimeoutError(WhoisExceptionError):
     pass

whoisdomain/handleDateStrings.py

@@ -9,7 +9,7 @@
 import os
 import re
 
-from .exceptions import UnknownDateFormat
+from .exceptions import UnknownDateFormatError
 
 log = logging.getLogger(__name__)
 logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
@@ -139,4 +139,4 @@ def str_to_date(
             return z.astimezone().replace(tzinfo=None)
 
     msg = f"Unknown date format: '{text}'"
-    raise UnknownDateFormat(msg)
+    raise UnknownDateFormatError(msg)

whoisdomain/helpers.py

@@ -5,7 +5,7 @@
 )
 
 from .context.parameterContext import ParameterContext
-from .exceptions import WhoisQuotaExceeded
+from .exceptions import WhoisQuotaExceededError
 from .tldDb.tld_regexpr import ZZ
 from .tldInfo import TldInfo
 from .version import VERSION
@@ -17,30 +17,30 @@
 def filterTldToSupportedPattern(
     dList: list[str],
 ) -> str | None:
-    global tldInfo
-    return tldInfo.filterTldToSupportedPattern(dList)
+    global MY_TLD_INFO
+    return MY_TLD_INFO.filterTldToSupportedPattern(dList)
 
 
 def mergeExternalDictWithRegex(
     aDict: dict[str, Any] | None = None,
 ) -> None:
-    global tldInfo
+    global MY_TLD_INFO
     if aDict is None:
         return
     if len(aDict) == 0:
         return
 
-    tldInfo.mergeExternalDictWithRegex(aDict)
+    MY_TLD_INFO.mergeExternalDictWithRegex(aDict)
 
 
 def validTlds() -> list[str]:
-    global tldInfo
-    return tldInfo.validTlds()
+    global MY_TLD_INFO
+    return MY_TLD_INFO.validTlds()
 
 
 def get_TLD_RE() -> dict[str, dict[str, Any]]:
-    global tldInfo
-    return tldInfo.TLD_RE()
+    global MY_TLD_INFO
+    return MY_TLD_INFO.TLD_RE()
 
 
 def getVersion() -> str:
@@ -76,7 +76,7 @@ def cleanupWhoisResponse(
     for line in tmp:
         # some servers respond with: % Quota exceeded in the comment section (lines starting with %)
         if "quota exceeded" in line.lower():
-            raise WhoisQuotaExceeded(whoisStr)
+            raise WhoisQuotaExceededError(whoisStr)
 
         if pc.with_cleanup_results is True and line.startswith("%"):  # only remove if requested
             continue
@@ -97,6 +97,6 @@ def cleanupWhoisResponse(
 
 VERBOSE: bool = False
 
-# Here we focre load on import the processing of the ZZ database
-tldInfo = TldInfo(ZZ, verbose=VERBOSE)
-tldInfo.init()  # must run on import
+# Here we force-load on import the processing of the ZZ database
+MY_TLD_INFO = TldInfo(ZZ, verbose=VERBOSE)
+MY_TLD_INFO.init()  # must run on import