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

PyFunceble/helpers/file.py

@@ -183,7 +183,7 @@ class FileHelper:
 
     def read_bytes(self) -> Optional[bytes]:
         """
-        Read the given file ath and returns it's bytes contetn.
+        Read the given file ath and returns it's bytes content.
         """
 
         data = None
@@ -203,7 +203,7 @@ class FileHelper:
 
     def copy(self, destination: str, *, create_parent: bool = False) -> "FileHelper":
         """
-        Copy the globaly given file path to the given destination.
+        Copy the globally given file path to the given destination.
 
         :param str destination: The destination of the copy.
         :param bool create_parent: Tell us if we have to create the parent directory.

PyFunceble/helpers/list.py

@@ -115,18 +115,21 @@ class ListHelper:
 
         return self
 
-    def remove_duplicates(self) -> "ListHelper":
+    def remove_duplicates(self, *, efficient: bool = True) -> "ListHelper":
         """
         Removes the duplicates of the current list.
         """
 
-        result = []
+        if efficient:
+            self.subject = list(set(self.subject))
+        else:
+            result = []
 
-        for element in self.subject:
-            if element not in result:
-                result.append(element)
+            for element in self.subject:
+                if element not in result:
+                    result.append(element)
 
-        self.subject = result
+            self.subject = result
 
         return self
 
@@ -147,7 +150,7 @@ class ListHelper:
 
         :param key_method:
             A function or method to use to format the
-            readed element before sorting.
+            read element before sorting.
         :type key_method: function|method
 
         :param bool reverse: Tell us if we have to reverse the list.

PyFunceble/helpers/merge.py

@@ -1,5 +1,5 @@
 """
-The tool to check the availability or syntax of dosubject, IP or URL.
+The tool to check the availability or syntax of domain, IP or URL.
 
 ::
 
@@ -164,7 +164,7 @@ class Merge:
 
     def into(self, origin: Any, strict: bool = True) -> Any:
         """
-        Process the mergin.
+        Process the merging.
 
         :param origin: The original data.
         :param strict:

PyFunceble/helpers/regex.py

@@ -63,6 +63,7 @@ class RegexHelper:
     """
 
     _regex: Optional[str] = None
+    _compiled: Optional[re.Pattern] = None
     escape_regex: bool = False
 
     def __init__(self, regex: Optional[str] = None, escape_regex: bool = False):
@@ -99,6 +100,8 @@ class RegexHelper:
         else:
             self._regex = re.escape(value)
 
+        self._compiled = re.compile(self._regex)
+
     def set_regex(self, value: str) -> "RegexHelper":
         """
         Sets the regex to work with.
@@ -120,9 +123,7 @@ class RegexHelper:
         in the given data.
         """
 
-        pre_result = re.compile(self.regex)
-
-        return [x for x in data if not pre_result.search(str(x))]
+        return [x for x in data if not self._compiled.search(str(x))]
 
     def get_matching_list(self, data: List[str]) -> List[str]:
         """
@@ -130,9 +131,7 @@ class RegexHelper:
         in the given data.
         """
 
-        pre_result = re.compile(self.regex)
-
-        return [x for x in data if pre_result.search(str(x))]
+        return [x for x in data if self._compiled.search(str(x))]
 
     def match(
         self,
@@ -157,12 +156,11 @@ class RegexHelper:
         """
 
         result = []
-        to_match = re.compile(self.regex)
 
         if rematch:
-            pre_result = to_match.findall(data)
+            pre_result = self._compiled.findall(data)
         else:
-            pre_result = to_match.search(data)
+            pre_result = self._compiled.search(data)
 
         if return_match and pre_result:
             if rematch:
@@ -209,7 +207,7 @@ class RegexHelper:
                 self.regex,
                 replacement,
                 data,
-                occurences,
+                count=occurences,
                 flags=re.MULTILINE if multiline else 0,
             )
         return data
@@ -222,4 +220,4 @@ class RegexHelper:
         :rtype: list
         """
 
-        return re.split(self.regex, data)
+        return self._compiled.split(data)

PyFunceble/query/dns/nameserver.py

@@ -150,25 +150,15 @@ class Nameservers:
             _ = ipaddress.ip_address(nameserver)
             result.append(nameserver)
         except ValueError:
-            try:
-                result.extend(
-                    [
-                        x.address
-                        for x in dns.resolver.Resolver().resolve(nameserver, "A")
-                    ]
-                )
-            except dns.exception.DNSException:
-                pass
+            resolver = dns.resolver.get_default_resolver()
 
-            try:
-                result.extend(
-                    [
-                        x.address
-                        for x in dns.resolver.Resolver().resolve(nameserver, "AAAA")
-                    ]
-                )
-            except dns.exception.DNSException:
-                pass
+            for record_type in ["A", "AAAA"]:
+                try:
+                    result.extend(
+                        [x.address for x in resolver.resolve(nameserver, record_type)]
+                    )
+                except dns.exception.DNSException:
+                    pass
 
         PyFunceble.facility.Logger.debug(
             "IP from nameserver (%r):\n%r", nameserver, result
@@ -203,7 +193,7 @@ class Nameservers:
         self.nameservers = []
 
         for nameserver in value:
-            if self.protocol.lower() == "https":
+            if isinstance(self.protocol, str) and self.protocol.lower() == "https":
                 if not nameserver.startswith("https://"):
                     netloc = self.url2netloc.set_data_to_convert(
                         nameserver

PyFunceble/query/dns/query_tool.py

@@ -69,7 +69,6 @@ import dns.rdatatype
 
 import PyFunceble.facility
 import PyFunceble.storage
-from PyFunceble.helpers.list import ListHelper
 from PyFunceble.query.dns.nameserver import Nameservers
 from PyFunceble.query.record.dns import DNSQueryToolRecord
 
@@ -122,16 +121,16 @@ class DNSQueryTool:
     ) -> None:
         self.nameservers = Nameservers()
 
-        if nameservers is not None:
-            self.nameservers.set_nameservers(nameservers)
-        else:  # pragma: no cover ## I'm not playing with system resolver.
-            self.nameservers.guess_and_set_nameservers()
-
         if preferred_protocol is not None:
             self.preferred_protocol = preferred_protocol
         else:
             self.guess_and_set_preferred_protocol()
 
+        if nameservers is not None:
+            self.nameservers.set_nameservers(nameservers)
+        else:  # pragma: no cover ## I'm not playing with system resolver.
+            self.nameservers.guess_and_set_nameservers()
+
         if follow_nameserver_order is not None:
             self.follow_nameserver_order = follow_nameserver_order
         else:
@@ -345,6 +344,8 @@ class DNSQueryTool:
 
         self.nameservers.set_nameservers(value)
 
+        return self
+
     @property
     def follow_nameserver_order(self) -> bool:
         """
@@ -758,29 +759,54 @@ class DNSQueryTool:
         PyFunceble.facility.Logger.debug("Mixed data:\n%r", dataset)
         return dataset
 
-    @ensure_subject_is_given
-    @ignore_if_query_message_is_missing
-    @update_lookup_record_response
-    def tcp(
-        self,
-    ) -> Optional[List[str]]:
+    def _query_protocol(self, protocol: str) -> Optional[List[str]]:
         """
-        Request the chosen record through the TCP protocol.
+        Given a protocol, we query the nameservers with or through it.
+
+        :param str protocol:
+            The protocol to use for the query.
+
+            It can be one of the following:
+                - "TCP"
+                - "UDP"
+                - "HTTPS"
+                - "TLS"
+        :return:
+            The result of the query, or an empty list if the query failed.
         """
 
-        self.lookup_record.used_protocol = "TCP"
+        self.lookup_record.used_protocol = protocol.upper()
 
-        result = []
+        if self.lookup_record.used_protocol not in self.SUPPORTED_PROTOCOL:
+            raise ValueError(
+                f"<protocol> ({self.lookup_record.used_protocol!r}) is unknown or "
+                f"unsupported (supported: {self.SUPPORTED_PROTOCOL!r})."
+            )
+
+        result = set()
 
         for nameserver, port in self._mix_order(
             self.nameservers.get_nameserver_ports()
         ).items():
             PyFunceble.facility.Logger.debug(
-                "Started to query information of %r from %r", self.subject, nameserver
+                "Started to query information of %r from %r (%s)",
+                self.subject,
+                nameserver,
+                self.lookup_record.used_protocol,
             )
 
+            if self.lookup_record.used_protocol == "HTTPS" and port == 53:
+                # Default port for nameserver class is 53. So we ensure we
+                # overwrite with our own default.
+                port = 443
+
+            if self.lookup_record.used_protocol == "TLS" and port == 53:
+                # Default port for nameserver class is 53. So we ensure we
+                # overwrite with our own default.
+                port = 853
+
             try:
-                response = dns.query.tcp(
+                response = getattr(dns.query, protocol.lower())(
                     self.query_message,
                     nameserver,
                     port=port,
@@ -790,19 +816,18 @@ class DNSQueryTool:
                 local_result = self._get_result_from_response(response)
 
                 if local_result:
-                    result.extend(local_result)
+                    result.update(local_result)
 
                     self.lookup_record.nameserver = nameserver
                     self.lookup_record.port = port
 
                     PyFunceble.facility.Logger.debug(
-                        "Successfully queried information of %r from %r.",
+                        "Successfully queried information of %r from %r. (%s)",
                         self.subject,
                         nameserver,
+                        self.lookup_record.used_protocol,
                     )
 
-                    if not self.trust_server:  # pragma: no cover: Per case.
-                        break
                 if self.trust_server:  # pragma: no cover: Per case.
                     break
             except (dns.exception.Timeout, socket.error):
@@ -820,87 +845,40 @@ class DNSQueryTool:
                 break
 
             PyFunceble.facility.Logger.debug(
-                "Unsuccessfully queried information of %r from %r. Sleeping %fs.",
+                "Unsuccessfully queried information of %r from %r (%s). Sleeping %fs.",
                 self.subject,
                 nameserver,
+                self.lookup_record.used_protocol,
                 self.delay,
             )
 
             time.sleep(self.delay)
 
-        return ListHelper(result).remove_duplicates().subject
+        return list(result)
 
     @ensure_subject_is_given
     @ignore_if_query_message_is_missing
     @update_lookup_record_response
-    def udp(
+    def tcp(
         self,
     ) -> Optional[List[str]]:
         """
-        Request the chosen record through the UTP protocol.
+        Request the chosen record through the TCP protocol.
         """
 
-        self.lookup_record.used_protocol = "UDP"
+        return self._query_protocol("TCP")
 
-        result = []
-
-        for nameserver, port in self._mix_order(
-            self.nameservers.get_nameserver_ports()
-        ).items():
-            PyFunceble.facility.Logger.debug(
-                "Started to query information of %r from %r", self.subject, nameserver
-            )
-
-            try:
-                response = dns.query.udp(
-                    self.query_message,
-                    nameserver,
-                    port=port,
-                    timeout=self.query_timeout,
-                )
-
-                local_result = self._get_result_from_response(response)
-
-                if local_result:
-                    result.extend(local_result)
-
-                    self.lookup_record.nameserver = nameserver
-                    self.lookup_record.port = port
-
-                    PyFunceble.facility.Logger.debug(
-                        "Successfully queried information of %r from %r.",
-                        self.subject,
-                        nameserver,
-                    )
-
-                    if not self.trust_server:  # pragma: no cover: Per case.
-                        break
-                if self.trust_server:  # pragma: no cover: Per case.
-                    break
-            except (dns.exception.Timeout, socket.error):
-                # Example: Resource temporarily unavailable.
-                pass
-            except dns.query.UnexpectedSource:
-                # Example: got a response from XXX instead of XXX.
-                pass
-            except dns.query.BadResponse:
-                # Example: A DNS query response does not respond to the question
-                # asked.
-                pass
-            except ValueError:
-                # Example: Input is malformed.
-                break
-
-            PyFunceble.facility.Logger.debug(
-                "Unsuccessfully queried information of %r from %r. Sleeping %fs.",
-                self.subject,
-                nameserver,
-                self.delay,
-            )
-
-            time.sleep(self.delay)
+    @ensure_subject_is_given
+    @ignore_if_query_message_is_missing
+    @update_lookup_record_response
+    def udp(
+        self,
+    ) -> Optional[List[str]]:
+        """
+        Request the chosen record through the UTP protocol.
+        """
 
-        return ListHelper(result).remove_duplicates().subject
+        return self._query_protocol("UDP")
 
     @ensure_subject_is_given
     @ignore_if_query_message_is_missing
@@ -912,61 +890,7 @@ class DNSQueryTool:
         Request the chosen record through the https protocol.
         """
 
-        self.lookup_record.used_protocol = "HTTPS"
-
-        result = []
-
-        for nameserver in self._mix_order(self.nameservers.get_nameservers()):
-            PyFunceble.facility.Logger.debug(
-                "Started to query information of %r from %r", self.subject, nameserver
-            )
-
-            try:
-                response = dns.query.https(
-                    self.query_message, nameserver, timeout=self.query_timeout
-                )
-
-                local_result = self._get_result_from_response(response)
-
-                if local_result:
-                    result.extend(local_result)
-
-                    self.lookup_record.nameserver = nameserver
-
-                    PyFunceble.facility.Logger.debug(
-                        "Successfully queried information of %r from %r.",
-                        self.subject,
-                        nameserver,
-                    )
-
-                    if not self.trust_server:  # pragma: no cover: Per case.
-                        break
-                if self.trust_server:  # pragma: no cover: Per case.
-                    break
-            except (dns.exception.Timeout, socket.error):
-                # Example: Resource temporarily unavailable.
-                pass
-            except dns.query.UnexpectedSource:
-                # Example: got a response from XXX instead of XXX.
-                pass
-            except dns.query.BadResponse:
-                # Example: A DNS query response does not respond to the question
-                # asked.
-                pass
-            except ValueError:
-                # Example: Input is malformed.
-                break
-
-            PyFunceble.facility.Logger.debug(
-                "Unsuccessfully queried information of %r from %r. Sleeping %fs.",
-                self.subject,
-                nameserver,
-                self.delay,
-            )
-
-            time.sleep(self.delay)
-
-        return ListHelper(result).remove_duplicates().subject
+        return self._query_protocol("HTTPS")
 
     @ensure_subject_is_given
     @ignore_if_query_message_is_missing
@@ -978,72 +902,7 @@ class DNSQueryTool:
         Request the chosen record through the TLS protocol.
         """
 
-        self.lookup_record.used_protocol = "TLS"
-
-        result = []
-
-        for nameserver, port in self._mix_order(
-            self.nameservers.get_nameserver_ports()
-        ).items():
-            PyFunceble.facility.Logger.debug(
-                "Started to query information of %r from %r", self.subject, nameserver
-            )
-
-            if port == 53:
-                # Default port for nameserver class is 53. So we ensure we
-                # overwrite with our own default.
-                port = 853
-
-            try:
-                response = dns.query.tls(
-                    self.query_message,
-                    nameserver,
-                    port=port,
-                    timeout=self.query_timeout,
-                )
-
-                local_result = self._get_result_from_response(response)
-
-                if local_result:
-                    result.extend(local_result)
-
-                    self.lookup_record.nameserver = nameserver
-                    self.lookup_record.port = port
-
-                    PyFunceble.facility.Logger.debug(
-                        "Successfully queried information of %r from %r.",
-                        self.subject,
-                        nameserver,
-                    )
-
-                    if not self.trust_server:  # pragma: no cover: Per case.
-                        break
-                if self.trust_server:  # pragma: no cover: Per case.
-                    break
-            except (dns.exception.Timeout, socket.error):
-                # Example: Resource temporarily unavailable.
-                pass
-            except dns.query.UnexpectedSource:
-                # Example: got a response from XXX instead of XXX.
-                pass
-            except dns.query.BadResponse:
-                # Example: A DNS query response does not respond to the question
-                # asked.
-                pass
-            except ValueError:
-                # Example: Input is malformed.
-                break
-
-            PyFunceble.facility.Logger.debug(
-                "Unsuccessfully queried information of %r from %r. Sleeping %fs.",
-                self.subject,
-                nameserver,
-                self.delay,
-            )
-
-            time.sleep(self.delay)
-
-        return ListHelper(result).remove_duplicates().subject
+        return self._query_protocol("TLS")
 
     def query(
         self,