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

PyFunceble/converter/subject2complements.py

@@ -64,6 +64,7 @@ class Subject2Complements(ConverterBase):
     """
 
     _include_given: bool = False
+    domain_syntax_checker: Optional[DomainSyntaxChecker] = None
 
     def __init__(
         self,
@@ -74,6 +75,8 @@ class Subject2Complements(ConverterBase):
         if include_given is not None:
             self.include_given = include_given
 
+        self.domain_syntax_checker = DomainSyntaxChecker()
+
         super().__init__(data_to_convert=data_to_convert)
 
     @ConverterBase.data_to_convert.setter
@@ -143,7 +146,7 @@ class Subject2Complements(ConverterBase):
         _ = aggressive
         result = []
 
-        checker = DomainSyntaxChecker(data)
+        checker = self.domain_syntax_checker.set_subject(data)
 
         if self.include_given and data not in result:
             result.append(data)

PyFunceble/converter/url2netloc.py

@@ -58,7 +58,7 @@ from PyFunceble.converter.base import ConverterBase
 
 class Url2Netloc(ConverterBase):
     """
-    Provides the interface for the conversion/extration of the network location
+    Provides the interface for the conversion/extraction of the network location
     of a given URL.
     """
 
@@ -70,7 +70,7 @@ class Url2Netloc(ConverterBase):
     @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`
@@ -116,7 +116,7 @@ class Url2Netloc(ConverterBase):
         Provides the converted data (after conversion)
         """
 
-        # Retrocompatibility.
+        # Retro-compatibility.
         self.parse_url()
 
         return self.convert(self.data_to_convert)

PyFunceble/converter/wildcard2subject.py

@@ -52,7 +52,7 @@ License:
 """
 # pylint: enable=line-too-long
 
-from typing import Any
+from typing import Any, Optional
 
 from PyFunceble.converter.base import ConverterBase
 
@@ -67,7 +67,7 @@ class Wildcard2Subject(ConverterBase):
     @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`
@@ -86,7 +86,7 @@ class Wildcard2Subject(ConverterBase):
 
         return self.convert(self.data_to_convert)
 
-    def convert(self, data: Any, *, aggressive: bool = False) -> str:
+    def convert(self, data: Any, *, aggressive: bool = False) -> Optional[str]:
         """
         Converts the given dataset.
 

PyFunceble/helpers/command.py

@@ -212,7 +212,7 @@ class CommandHelper:
             is that :func:`~PyFunceble.helpers.Command.execute` wait for the
             process to end in order to return its output while this method
             return each line one by one
-            - as they are outputed.
+            - as they are outputted.
 
         :param bool rstrip:
             Deactivates the rstrip of the output.

PyFunceble/helpers/dict.py

@@ -66,7 +66,7 @@ class DictHelper:
     Simplify some :code:`dict` manipulation.
 
     :param dict main: The main :code:`dict` to work with.
-    :raise TypeError: When :code:`main` is not a dict nor a list (tolarated).
+    :raise TypeError: When :code:`main` is not a dict nor a list (tolerated).
     """
 
     _subject: Optional[Union[Any, dict]] = None
@@ -349,7 +349,7 @@ class DictHelper:
         :param bool default_flow_style: Uses the default flow style.
         :param int indent: The indentation to apply.
         :param bool allow_unicode: Allows the decoding of unicode chars.
-        :param bool sort_keys: Sors the keys.
+        :param bool sort_keys: Sorts the keys.
 
         :rtype: dict|list
         """
@@ -371,7 +371,7 @@ class DictHelper:
         data: Optional[Any] = None,
     ) -> dict:
         """
-        Flatten the current dictionnary.
+        Flatten the current dictionary.
 
         :param separator:
             The separator to apply.
@@ -405,7 +405,7 @@ class DictHelper:
 
     def unflatten(self, *, separator: str = ".", data: Optional[Any] = None):
         """
-        Unflatten a previously flatten dictionnary.
+        Unflatten a previously flatten dictionary.
 
         :param separator:
             The separator to split.

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,