add __lookup__ rdap/whois

Author: mboot-github

whoisdomain/__init__.py

@@ -208,6 +208,7 @@ def q2(
         if dd.status:
             with_rdap_whois = True
             d: dict[str, Any] = wr.map_data_to_whoisdomain(dd.data, with_rdap_whois=with_rdap_whois)
+            d['__lookup__'] = 'rdap'
 
             rr = Domain(pc=pc, dc=dc)
             rr.from_whodap_dict(d)
@@ -293,20 +294,5 @@ def query(
 # Add get function to support return result in dictionary form
 get = _result2dict(query)
 
-# CLAUDE: logging changes
-# Calling logging.basicConfig(level="DEBUG") inside library code mutates the application's root logger
-# and is widely considered bad library citizenship.
-# If the caller's app uses logging, you've just overridden their config.
-# Use a per-package logger and let the caller configure the level:
-#  logging.getLogger("whoisdomain").setLevel("DEBUG"),
-#  or document a setup_logging(verbose=) helper that callers can opt into.
-
-#  CLAUDE: memoryleak:
-# Three calls — gc.collect(0); gc.collect(1); gc.collect(2) — once on entry and once on exit.
-# gc.collect(2) already does generations 0 and 1, so the other two are redundant.
-# More importantly, manual GC in library code imposes work on callers who don't need it
-# (Python's GC is generational and usually correct without help).
-# The del spam right above isn't doing anything either
-# — locals are about to go out of scope.
+# CLAUDE: memoryleak:
 # If you're chasing a real leak, profile it with tracemalloc;
-# otherwise this is cargo-culted overhead.

whoisdomain/context/parameterContext.py

@@ -95,285 +95,6 @@ def from_json(cls, s: str) -> "ParameterContext":
         return cls(**json.loads(s))
 
 
-ParamsStringJson: str = """
-{
-  "ignore_returncode": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "if the whois command fails with code 1 still process the data returned as normal."
-  },
-  "force": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "Don't use cache."
-  },
-  "verbose": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "print relevant information on steps taken to standard error"
-  },
-  "with_cleanup_results": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "cleanup lines starting with % and REDACTED FOR PRIVACY"
-  },
-  "internationalized": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "if true convert with internationalizedDomainNameToPunyCode()."
-  },
-  "include_raw_whois_text": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "if reqested the full response is also returned."
-  },
-  "return_raw_text_for_unsupported_tld": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": ""
-  },
-  "parse_partial_response": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "try to parse partial response when cmd timed out (stdbuf should be in PATH for best results)"
-  },
-  "simplistic": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "when simplistic is true we return null for most exceptions and dont pass info why we have no data."
-  },
-  "withRedacted": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "show redacted output default no redacted data is shown"
-  },
-  "cmd": {
-    "type": "str",
-    "optional": true,
-    "default": "whois",
-    "help": "specify the path to the cli whois you want to use."
-  },
-  "cache_file": {
-    "type": "str",
-    "optional": true,
-    "default": null,
-    "help": "Use file to store cache not only memory."
-  },
-  "server": {
-    "type": "str",
-    "optional": true,
-    "default": null,
-    "help": "use this whois server for making this query: Linux/Mac: 'whois -h <server> <domain>' Windows: 'whois.exe <domain> <server>'"
-  },
-  "cache_age": {
-    "type": "int",
-    "optional": true,
-    "default": 172800,
-    "help": "Cache expiration time for given domain in seconds 60*60*48 (48 hours)"
-  },
-  "slow_down": {
-    "type": "int",
-    "optional": true,
-    "default": 0,
-    "help": "Time [s] it will wait after you query WHOIS database."
-  },
-  "timeout": {
-    "type": "float",
-    "optional": true,
-    "default": 30.0,
-    "help": "timeout in seconds for the whois command to return a result."
-  },
-  "tryInstallMissingWhoisOnWindows": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "allow auto install of sysinternals whois on windows if no whois found"
-  },
-  "shortResponseLen": {
-    "type": "int",
-    "optional": true,
-    "default": 5,
-    "help": "The number of lines we consider a short response."
-  },
-  "withPublicSuffix": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "if lib 'tld' is installed add tld info based on get_tld(); fake the tld if needed"
-  },
-  "extractServers": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "try to extract the whois servers from the whois output (uses --verbose)"
-  },
-  "stripHttpStatus": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "strip https://icann.org/epp# from status response"
-  },
-  "noIgnoreWww": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "if set to true we skip the strip www action"
-  },
-  "rdapOnly": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "if set to true we only consult rdap"
-  },
-  "whoisOnly": {
-    "type": "bool",
-    "default": false,
-    "optional": true,
-    "help": "if set to true we only consult whois"
-  }
-}
-"""
-
-
-class ParameterContext2:
-    kt: dict[str, Any]
-    value: dict[str, Any]
-    params: dict[str, Any]
-
-    def __init__(
-        self,
-        **kwargs: Any,
-    ) -> None:
-        self.kt: dict[str, Any] = {
-            "int": int,
-            "float": float,
-            "str": str,
-            "bool": bool,
-        }
-        self.value: dict[str, Any] = {}
-        self.params: dict[str, Any] = json.loads(ParamsStringJson)
-
-        mandatory: list[str] = self._load_defaults()
-        self._add_args(mandatory, **kwargs)
-        self._validate_all_mandatory_known(mandatory)
-
-    def _load_defaults(self) -> list[str]:
-        mandatory: list[str] = []
-        for i, k in self.params.items():
-            if "default" in k:
-                self.value[i] = k["default"]
-            else:
-                mandatory.append(i)  # params with no default become mandatory
-                self.value[i] = None
-        return mandatory
-
-    def _add_args(
-        self,
-        mandatory: list[str],
-        **kwargs: Any,
-    ) -> None:
-        for name, value in kwargs.items():
-            if name not in self.params:
-                msg = f"ignore parameter '{name}':you specified a parameter we do not currently know"
-                raise TypeError(msg)
-
-            t = self.params[name].get("type")
-            if t is None:
-                msg = f"unknown type: {t} for {name}"
-                raise TypeError(msg)
-
-            # we have a type and we still exist
-            if value is not None:
-                if not isinstance(value, self.kt[t]):
-                    msg = f"unknown type: {t} for {name}, {value}"
-                    raise TypeError(msg)
-
-                self.value[name] = value
-                if name in mandatory:
-                    del mandatory[mandatory.index(name)]
-
-    @classmethod
-    def _validate_all_mandatory_known(
-        cls,
-        mandatory: list[str],
-    ) -> None:
-        if len(mandatory) != 0:
-            msg = f"missing mandatory parametrs: {sorted(mandatory)}"
-            raise ValueError(msg)
-
-    def __getattr__(
-        self,
-        name: str,
-    ) -> Any:
-        if name in {"params", "value", "kt"}:
-            raise AttributeError(name)  # should never happen as they are resolved before __getattr__
-            # getattr(self, name)
-
-        return self.value.get(name)
-
-    def __setattr__(
-        self,
-        name: str,
-        value: Any,
-    ) -> None:
-        if name in {"params", "value", "kt"}:
-            super().__setattr__(name, value)
-            return
-
-        self.set(name, value)
-
-    # -------------------------------------
-    def get(
-        self,
-        name: str,
-    ) -> Any:
-        return self.value.get(name)
-
-    def set(self, name: str, value: Any) -> None:
-        if name not in self.params:
-            msg = f"ignore parameter '{name}':you specified a parameter we do not currently know"
-            raise TypeError(msg)
-
-        if name in self.params:
-            t = self.params[name].get("type")
-            if t is None:
-                msg = f"unknown type: {t} for {name}"
-                raise TypeError(msg)
-
-            if value is not None:
-                if not isinstance(value, self.kt[t]):
-                    msg = f"unknown type: {t} for {name}, {value}"
-                    raise TypeError(msg)
-                self.value[name] = value
-            # leave the default
-
-    def toJson(
-        self,
-    ) -> str:
-        rr: dict[str, Any] = {}
-        for k in self.params:
-            rr[k] = self.get(k)
-        return json.dumps(rr)
-
-    def fromJson(
-        self,
-        jstring: str,
-    ) -> None:
-        zz = json.loads(jstring)
-        for k, v in zz.items():
-            self.set(k, v)
-
-
 if __name__ == "__main__":
     pc = ParameterContext()
     print(asdict(pc))

whoisdomain/domain.py

@@ -11,7 +11,6 @@
 
 log = logging.getLogger(__name__)
 
-
 class Domain:
     def __init__(
         self,
@@ -37,12 +36,13 @@ def __init__(
 
         self.dnssec: bool = False
 
-        self.last_updated: datetime.datetime | None = None
+        # self.last_updated: datetime.datetime | None = None
         self.updated_date: datetime.datetime | None = None
         self.expiration_date: datetime.datetime | None = None
         self.creation_date: datetime.datetime | None = None
 
         self._rdap_: dict[str, Any] = {}
+        self.__lookup__ = "whois"
 
     @classmethod
     def _cleanupArray(
@@ -170,7 +170,7 @@ def _parseData(
         self.creation_date = str_to_date(dc.data["creation_date"][0], tld=self.tld)
         self.expiration_date = str_to_date(dc.data["expiration_date"][0], tld=self.tld)
         self.updated_date = str_to_date(dc.data["updated_date"][0], tld=self.tld)
-        self.last_updated = self.updated_date  # keep old name for one release
+        # self.last_updated = self.updated_date  # keep old name for one release
 
         self.dnssec = bool(dc.data["DNSSEC"])
         self._doStatus(pc, dc)