PyFunceble-dev 4.3.0a23__py3-none-any.whl → 4.3.0a24__py3-none-any.whl

PyFunceble/query/dns/resolver.py

@@ -11,7 +11,7 @@ The tool to check the availability or syntax of domain, IP or URL.
     ██║        ██║   ██║     ╚██████╔╝██║ ╚████║╚██████╗███████╗██████╔╝███████╗███████╗
     ╚═╝        ╚═╝   ╚═╝      ╚═════╝ ╚═╝  ╚═══╝ ╚═════╝╚══════╝╚═════╝ ╚══════╝╚══════╝
 
-Provides a way to provides the nameserver to use.
+Provides a way to provide the nameserver to use.
 
 Author:
     Nissar Chababy, @funilrys, contactTATAfunilrysTODTODcom
@@ -50,7 +50,6 @@ License:
     limitations under the License.
 """
 
-import functools
 from typing import List, Optional, Union
 
 import dns.resolver
@@ -70,93 +69,123 @@ class Resolver:
 
     STD_TIMEOUT: float = 5.0
 
-    timeout: float = 3.0
+    _timeout: float = 3.0
 
-    nameservers: Nameservers = Nameservers()
-    internal_resolver: Optional[dns.resolver.Resolver] = None
+    _nameservers: Nameservers = None
+    _internal_resolver: Optional[dns.resolver.Resolver] = None
 
     def __init__(
         self, nameservers: Optional[List[str]] = None, timeout: Optional[float] = None
     ) -> None:
+        self._nameservers = Nameservers()
+
         if nameservers is not None:
-            self.set_nameservers(nameservers)
+            self.nameservers = nameservers
         else:
             self.nameservers.guess_and_set_nameservers()
 
         if timeout is not None:
-            self.set_timeout(timeout)
+            self.timeout = timeout
         else:
             self.guess_and_set_timeout()
 
-    def configure_resolver(func):  # pylint: disable=no-self-argument
+    @property
+    def resolver(self) -> dns.resolver.Resolver:
         """
-        Configures the resolvers after calling the decorated method.
+        Provides the resolver to work with.
         """
 
-        @functools.wraps(func)
-        def wrapper(self, *args, **kwargs):
-            result = func(self, *args, **kwargs)  # pylint: disable=not-callable
+        if not self._internal_resolver:
+            if self.get_raw_nameservers():
+                self._internal_resolver = dns.resolver.Resolver(configure=False)
+            else:  # pragma: no cover ## I don't want to play with the default resolver.
+                self._internal_resolver = dns.resolver.Resolver()
+
+            self._internal_resolver.lifetime = self.timeout + 2.0
+            self._internal_resolver.timeout = self.timeout
+            self._internal_resolver.nameservers = self.get_raw_nameservers()
+            self._internal_resolver.nameserver_ports = self.get_raw_nameserver_ports()
 
-            self.internal_resolver.lifetime = self.timeout + 2.0
-            self.internal_resolver.timeout = self.timeout
-            self.internal_resolver.nameservers = self.nameservers.get_nameservers()
-            self.internal_resolver.nameserver_ports = (
-                self.nameservers.get_nameserver_ports()
-            )
+        return self._internal_resolver
 
-            return result
+    @property
+    def nameservers(self) -> Nameservers:
+        """
+        Provides the nameservers to use.
+        """
+
+        return self._nameservers
+
+    @nameservers.setter
+    def nameservers(self, value: List[str]) -> None:
+        """
+        Sets the nameservers to use.
+        """
 
-        return wrapper
+        self.nameservers.set_nameservers(value)
+        self._internal_resolver = None  # Invalidate
 
     def set_nameservers(self, value: List[str]) -> "Resolver":
         """
         Sets the given nameserver.
         """
 
-        self.nameservers.set_nameservers(value)
+        self.nameservers = value
 
-    def set_timeout(self, value: Union[float, int]) -> "Resolver":
+        return self
+
+    @property
+    def timeout(self) -> float:
         """
-        Sets the timeout of a query.
+        Provides the timeout to use.
+        """
+
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, value: float) -> None:
+        """
+        Sets the timeout to use.
         """
 
         if not isinstance(value, (float, int)):
             raise TypeError(f"<value> should be {float}, {type(value)} given.")
 
-        self.timeout = float(value)
+        self._timeout = float(value)
+        self._internal_resolver = None  # Invalidate
+
+    def set_timeout(self, value: Union[float, int]) -> "Resolver":
+        """
+        Sets the timeout of a query.
+        """
+
+        self.timeout = value
 
         return self
 
-    def get_nameservers(self) -> Optional[List[str]]:
+    def get_raw_nameservers(self) -> Optional[List[str]]:
         """
         Provides the currently set list of nameserver.
         """
 
         return self.nameservers.get_nameservers()
 
-    def get_nameserver_ports(self) -> Optional[dict]:
+    def get_raw_nameserver_ports(self) -> Optional[dict]:
         """
         Provides the currently set list of nameserver ports.
         """
 
         return self.nameservers.get_nameserver_ports()
 
-    def get_timeout(self) -> Optional[float]:
-        """
-        Provides the currently set query timeout.
-        """
-
-        return self.timeout
-
     def guess_and_set_timeout(self) -> "Resolver":
         """
         Tries to guess the the timeout from the configuration.
         """
 
         if PyFunceble.facility.ConfigLoader.is_already_loaded():
-            self.set_timeout(float(PyFunceble.storage.CONFIGURATION.lookup.timeout))
+            self.timeout = PyFunceble.storage.CONFIGURATION.lookup.timeout
         else:
-            self.set_timeout(self.STD_TIMEOUT)
+            self.timeout = self.STD_TIMEOUT
 
         return self
 
@@ -176,19 +205,3 @@ class Resolver:
             getattr(self, method)()
 
         return self
-
-    @configure_resolver
-    def get_resolver(self) -> dns.resolver.Resolver:
-        """
-        Provides the resolver to work with.
-        """
-
-        if self.internal_resolver:
-            return self.internal_resolver
-
-        if self.nameservers.get_nameservers():
-            self.internal_resolver = dns.resolver.Resolver(configure=False)
-        else:  # pragma: no cover ## I don't want to play with the default resolver.
-            self.internal_resolver = dns.resolver.Resolver()
-
-        return self.internal_resolver

PyFunceble/query/netinfo/address.py

@@ -51,7 +51,7 @@ License:
 """
 
 import socket
-from typing import List, Optional
+from typing import List
 
 from PyFunceble.query.netinfo.base import NetInfoBase
 
@@ -62,12 +62,12 @@ class AddressInfo(NetInfoBase):
     """
 
     @NetInfoBase.ensure_subject_is_given
-    def get_info(self) -> Optional[List[str]]:
+    def get_info(self) -> List[str]:
         """
         Fetch and provides the information of the given hosts.
 
         :return:
-            A list of of IP related to the given host.
+            A list of IP related to the given host.
         """
 
         try:
@@ -76,6 +76,4 @@ class AddressInfo(NetInfoBase):
                 for x in socket.getaddrinfo(self.subject, 80, proto=socket.IPPROTO_TCP)
             ]
         except (socket.gaierror, socket.herror, UnicodeError, OSError):
-            pass
-
-        return []
+            return []

PyFunceble/query/netinfo/base.py

@@ -133,4 +133,4 @@ class NetInfoBase:
         Provides the wanted network information.
         """
 
-        raise NotImplementedError()
+        raise NotImplementedError("Subclasses must implement.")

PyFunceble/query/netinfo/hostbyaddr.py

@@ -51,7 +51,6 @@ License:
 """
 
 import socket
-from typing import Optional
 
 from PyFunceble.query.netinfo.base import NetInfoBase
 
@@ -62,13 +61,13 @@ class HostByAddrInfo(NetInfoBase):
     """
 
     @NetInfoBase.ensure_subject_is_given
-    def get_info(self) -> Optional[dict]:
+    def get_info(self) -> dict:
         """
         Fetch and provides the information of the given hosts.
 
         :return:
-            A dictionnary with the following format or :py:class:`None` if nothing
-            was found.
+            A dictionary with the following format or an empty :py:class:`dict`
+            if nothing was found.
 
             ::
 
@@ -83,7 +82,5 @@ class HostByAddrInfo(NetInfoBase):
             request = socket.gethostbyaddr(self.subject)
 
             return {"hostname": request[0], "aliases": request[1], "ips": request[2]}
-        except (socket.gaierror, socket.herror):
-            pass
-
-        return dict()  # pylint: disable=use-dict-literal
+        except (socket.gaierror, socket.herror, UnicodeError, OSError):
+            return {}

PyFunceble/query/requests/adapter/base.py

@@ -63,7 +63,7 @@ from PyFunceble.query.dns.query_tool import DNSQueryTool
 
 class RequestAdapterBase(requests.adapters.HTTPAdapter):
     """
-    Extends the built-in HTTP adapater and acts as a base for all our own
+    Extends the built-in HTTP adapter and acts as a base for all our own
     adapter.
     """
 
@@ -286,7 +286,7 @@ class RequestAdapterBase(requests.adapters.HTTPAdapter):
 
     def resolve(self, hostname: str) -> Optional[str]:
         """
-        Resolves with the prefered method.
+        Resolves with the preferred method.
         """
 
         if hostname:
@@ -301,7 +301,7 @@ class RequestAdapterBase(requests.adapters.HTTPAdapter):
         use our own ssl context - when given.
         """
 
-        _ = pool_kwargs.pop("ssl_context", None)
+        pool_kwargs.pop("ssl_context", None)
 
         return super().init_poolmanager(
             connections, maxsize, block, ssl_context=self.ssl_context, **pool_kwargs

PyFunceble/query/requests/adapter/http.py

@@ -124,7 +124,6 @@ class RequestHTTPAdapter(RequestAdapterBase):
 
             return self.fake_response()
 
-        # raise Exception(hostname_ip, parsed_url, parsed_url.hostname, kwargs)
         response = super().send(request, **kwargs)
 
         if hostname_ip:

PyFunceble/query/requests/requester.py

@@ -377,7 +377,7 @@ class Requester:
         """
 
         if not isinstance(value, bool):
-            raise TypeError(f"<value> shoule be {bool}, {type(value)} given.")
+            raise TypeError(f"<value> should be {bool}, {type(value)} given.")
 
         self._verify_certificate = value
 
@@ -429,11 +429,11 @@ class Requester:
             When the given :code:`value` is not a :py:class`int` nor
             :py:class:`float`.
         :raise ValueError:
-            Whent the given :code:`value` is less than `1`.
+            Went the given :code:`value` is less than `1`.
         """
 
         if not isinstance(value, (int, float)):
-            raise TypeError(f"<value> shoule be {int} or {float}, {type(value)} given.")
+            raise TypeError(f"<value> should be {int} or {float}, {type(value)} given.")
 
         if value < 0:
             raise ValueError("<value> should not be less than 0.")
@@ -489,7 +489,7 @@ class Requester:
         """
 
         if not isinstance(value, dict):
-            raise TypeError(f"<value> shoule be {dict}, {type(value)} given.")
+            raise TypeError(f"<value> should be {dict}, {type(value)} given.")
 
         self._proxy_pattern = value
 
@@ -544,7 +544,7 @@ class Requester:
 
     def get_timeout(self) -> float:
         """
-        Provides the currently set timetout.
+        Provides the currently set timeout.
         """
 
         return self.timeout
@@ -595,7 +595,7 @@ class Requester:
     @request_factory("OPTIONS")
     def options(self, *args, **kwargs) -> requests.Response:
         """
-        Sends am OPTIONS request and get its response.
+        Sends an OPTIONS request and get its response.
         """
 
     @request_factory("HEAD")

PyFunceble/query/whois/converter/expiration_date.py

@@ -50,7 +50,7 @@ License:
     limitations under the License.
 """
 
-from typing import List, Optional, Tuple
+from typing import List, Optional
 
 from PyFunceble.helpers.regex import RegexHelper
 from PyFunceble.query.whois.converter.base import ConverterBase
@@ -226,7 +226,7 @@ class ExpirationDateExtractor(ConverterBase):
         },
     ]
     """
-    Our parsing map. Indeed, we hava a list of regex, but no way to know
+    Our parsing map. Indeed, we have a list of regex, but no way to know
     how to parse them. Especially when the order (month, day, year) are
     different from a format to another.
 
@@ -234,6 +234,19 @@ class ExpirationDateExtractor(ConverterBase):
     created.
     """
 
+    _regex_helper: Optional[RegexHelper] = None
+
+    @property
+    def regex_helper(self) -> "RegexHelper":
+        """
+        Provides the regex helper to use.
+        """
+
+        if self._regex_helper is None:
+            self._regex_helper = RegexHelper()
+
+        return self._regex_helper
+
     @ConverterBase.data_to_convert.setter
     def data_to_convert(self, value: str) -> None:
         """
@@ -263,7 +276,7 @@ class ExpirationDateExtractor(ConverterBase):
         """
 
         for regex in self.PATTERNS:
-            expiration_date_line = RegexHelper(r"(?i)" + regex).match(
+            expiration_date_line = self.regex_helper.set_regex(r"(?i)" + regex).match(
                 self.data_to_convert, return_match=True, rematch=True, group=0
             )
 
@@ -273,15 +286,13 @@ class ExpirationDateExtractor(ConverterBase):
             return expiration_date_line
         return None
 
-    def __get_actual_expiration_date(
-        self, extracted: str
-    ) -> Optional[Tuple[str, str, str]]:
+    def __get_actual_expiration_date(self, extracted: str) -> Optional[str]:
         """
         Tries to extract the actual expiration date.
         """
 
         for index, date_regex in self.MARKER2DATE_REGEX.items():
-            matched = RegexHelper(date_regex).match(
+            matched = self.regex_helper.set_regex(date_regex).match(
                 extracted, return_match=True, rematch=True
             )
             date_parts = tuple()
@@ -318,7 +329,7 @@ class ExpirationDateExtractor(ConverterBase):
         if expiration_date_line:
             expiration_date = expiration_date_line[0].strip()
 
-            if RegexHelper(self.REGEX_DIGITS).match(
+            if self.regex_helper.set_regex(self.REGEX_DIGITS).match(
                 expiration_date, return_match=False
             ):
                 return self.__get_actual_expiration_date(expiration_date)

PyFunceble/query/whois/converter/month2unified.py

@@ -75,10 +75,12 @@ class Month2Unified(ConverterBase):
         "dec": [str(12), "dec", "december", "dec."],
     }
 
+    REVERSE_MAP: Dict[str, str] = {z: x for x, y in MAP.items() for z in y}
+
     @ConverterBase.data_to_convert.setter
     def data_to_convert(self, value: Any) -> None:
         """
-        Overrites the default behavior.
+        Overrides the default behavior.
 
         :raise TypeError:
             When the given data to convert is not :py:class:`str`
@@ -99,8 +101,4 @@ class Month2Unified(ConverterBase):
             If no month is found, the given data is given as response.
         """
 
-        for to_return, possibilities in self.MAP.items():
-            if self.data_to_convert.lower() in possibilities:
-                return to_return
-
-        return self.data_to_convert
+        return self.REVERSE_MAP.get(self.data_to_convert.lower(), self.data_to_convert)

PyFunceble/query/whois/converter/registrar.py

@@ -11,7 +11,7 @@ The tool to check the availability or syntax of domain, IP or URL.
     ██║        ██║   ██║     ╚██████╔╝██║ ╚████║╚██████╗███████╗██████╔╝███████╗███████╗
     ╚═╝        ╚═╝   ╚═╝      ╚═════╝ ╚═╝  ╚═══╝ ╚═════╝╚══════╝╚═════╝ ╚══════╝╚══════╝
 
-Provides our registrar extrator.
+Provides our registrar extractor.
 
 Author:
     Nissar Chababy, @funilrys, contactTATAfunilrysTODTODcom
@@ -56,9 +56,9 @@ from PyFunceble.helpers.regex import RegexHelper
 from PyFunceble.query.whois.converter.base import ConverterBase
 
 
-class RegistarExtractor(ConverterBase):
+class RegistrarExtractor(ConverterBase):
     """
-    Provides an interface for the extration of the registrar.
+    Provides an interface for the extraction of the registrar.
     """
 
     PATTERNS: List[str] = [
@@ -73,6 +73,19 @@ class RegistarExtractor(ConverterBase):
         r"sponsoring\s+registrar\s+organization(\s+|):(.*)",
     ]
 
+    _regex_helper: Optional[RegexHelper] = None
+
+    @property
+    def regex_helper(self) -> "RegexHelper":
+        """
+        Provides the regex helper to use.
+        """
+
+        if self._regex_helper is None:
+            self._regex_helper = RegexHelper()
+
+        return self._regex_helper
+
     @ConverterBase.data_to_convert.setter
     def data_to_convert(self, value: Any) -> None:
         """
@@ -94,7 +107,7 @@ class RegistarExtractor(ConverterBase):
             raise ValueError("<value> should not be empty.")
 
         # pylint: disable=no-member
-        super(RegistarExtractor, self.__class__).data_to_convert.fset(self, value)
+        super(RegistrarExtractor, self.__class__).data_to_convert.fset(self, value)
 
     def __get_line(self) -> Optional[str]:
         """
@@ -102,7 +115,7 @@ class RegistarExtractor(ConverterBase):
         """
 
         for regex in self.PATTERNS:
-            registrar_line = RegexHelper(r"(?i)" + regex).match(
+            registrar_line = self.regex_helper.set_regex(r"(?i)" + regex).match(
                 self.data_to_convert, return_match=True, rematch=True, group=0
             )
 

PyFunceble/query/whois/query_tool.py

@@ -11,7 +11,7 @@ The tool to check the availability or syntax of domain, IP or URL.
     ██║        ██║   ██║     ╚██████╔╝██║ ╚████║╚██████╗███████╗██████╔╝███████╗███████╗
     ╚═╝        ╚═╝   ╚═╝      ╚═════╝ ╚═╝  ╚═══╝ ╚═════╝╚══════╝╚═════╝ ╚══════╝╚══════╝
 
-Provides our interface for quering the WHOIS Record of a given subject.
+Provides our interface for querying the WHOIS Record of a given subject.
 
 Author:
     Nissar Chababy, @funilrys, contactTATAfunilrysTODTODcom
@@ -57,7 +57,7 @@ from typing import Optional, Union
 from PyFunceble.dataset.iana import IanaDataset
 from PyFunceble.query.record.whois import WhoisQueryToolRecord
 from PyFunceble.query.whois.converter.expiration_date import ExpirationDateExtractor
-from PyFunceble.query.whois.converter.registrar import RegistarExtractor
+from PyFunceble.query.whois.converter.registrar import RegistrarExtractor
 
 # pylint: disable=protected-access
 
@@ -71,7 +71,7 @@ class WhoisQueryTool:
     STD_PORT: int = 43
 
     expiration_date_extractor: Optional[ExpirationDateExtractor] = None
-    registrar_extractor: Optional[RegistarExtractor] = None
+    registrar_extractor: Optional[RegistrarExtractor] = None
     iana_dataset: Optional[IanaDataset] = None
 
     _subject: Optional[str] = None
@@ -90,7 +90,7 @@ class WhoisQueryTool:
         server: Optional[str] = None,
         query_timeout: Optional[float] = None,
     ) -> None:
-        self.registrar_extractor = RegistarExtractor()
+        self.registrar_extractor = RegistrarExtractor()
         self.expiration_date_extractor = ExpirationDateExtractor()
         self.iana_dataset = IanaDataset()
 
@@ -297,7 +297,7 @@ class WhoisQueryTool:
             raise TypeError(f"<value> should be {int} or {float}, {type(value)} given.")
 
         if value < 0:
-            raise ValueError(f"<value> ({value!r}) should be less than 0.")
+            raise ValueError(f"<value> ({value!r}) should not be less than 0.")
 
         self._query_timeout = float(value)
 
@@ -365,7 +365,7 @@ class WhoisQueryTool:
         else:
             extension = self.subject
 
-        extension = extension[extension.rfind(".") + 1 :]
+        extension = extension.rsplit(".", 1)[-1]
 
         return self.iana_dataset.get_whois_server(extension)
 
@@ -419,24 +419,21 @@ class WhoisQueryTool:
                         if not data:
                             break
 
-                    req.close()
-
-                    try:
-                        self.lookup_record.record = self._record = response.decode()
-                    except UnicodeDecodeError:
-                        # Note: Because we don't want to deal with other issue, we
-                        # decided to use `replace` in order to automatically replace
-                        # all non utf-8 encoded characters.
-                        self.lookup_record.record = self._record = response.decode(
-                            "utf-8", "replace"
-                        )
+                    # Note: Because we don't want to deal with other issue, we
+                    # decided to use `replace` in order to automatically replace
+                    # all non utf-8 encoded characters.
+                    self.lookup_record.record = self._record = response.decode(
+                        "utf-8", "replace"
+                    )
                 except socket.error:
                     pass
+                finally:
+                    req.close()
 
             if self.lookup_record.record is None or not self.lookup_record.record:
                 self.lookup_record.record = self._record = ""
                 self.lookup_record.expiration_date = self._expiration_date = ""
-                self.lookup_record.registrar = self._record = ""
+                self.lookup_record.registrar = self._registrar = ""
             else:
                 self.lookup_record.expiration_date = self.expiration_date
                 self.lookup_record.registrar = self.registrar

PyFunceble/storage.py

@@ -60,7 +60,7 @@ from dotenv import load_dotenv
 from PyFunceble.storage_facility import get_config_directory
 
 PROJECT_NAME: str = "PyFunceble"
-PROJECT_VERSION: str = "4.3.0a23.dev (Blue Duckling: Tulip)"
+PROJECT_VERSION: str = "4.3.0a24.dev (Blue Duckling: Tulip)"
 
 DISTRIBUTED_CONFIGURATION_FILENAME: str = ".PyFunceble_production.yaml"