PyFunceble-dev 4.0.0b34__py3-none-any.whl → 4.0.0b35__py3-none-any.whl

PyFunceble/checker/syntax/base.py

@@ -122,5 +122,7 @@ class SyntaxCheckerBase(CheckerBase):
         raise NotImplementedError()
 
     # pylint: disable=useless-super-delegation
-    def get_status(self) -> Optional[SyntaxCheckerStatus]:
+    def get_status(
+        self,
+    ) -> Optional[SyntaxCheckerStatus]:  # pragma: no cover ## Safety.
         return super().get_status()

PyFunceble/cli/processes/base.py

@@ -183,6 +183,21 @@ class ProcessesManagerBase:
 
         return wrapper
 
+    def ignore_if_running(func):  # pylint: disable=no-self-argument
+        """
+        Ignore the launching of the decorated method if the workers are
+        running.
+        """
+
+        @functools.wraps(func)
+        def wrapper(self, *args, **kwargs):
+            if not self.is_running():
+                return func(self, *args, **kwargs)  # pylint: disable=not-callable
+
+            return self
+
+        return wrapper
+
     @property
     def max_worker(self) -> Optional[int]:
         """
@@ -434,6 +449,7 @@ class ProcessesManagerBase:
 
     @ensure_worker_obj_is_given
     @create_workers_if_missing
+    # @ignore_if_running
     def start(self) -> "ProcessesManagerBase":
         """
         Starts a defined number of worker.

PyFunceble/converter/adblock_input_line2subject.py

@@ -51,10 +51,8 @@ License:
     limitations under the License.
 """
 
-from typing import Any, List, Optional, Union
+from typing import Any, List, Optional, Set, Union
 
-from PyFunceble.checker.syntax.domain import DomainSyntaxChecker
-from PyFunceble.checker.syntax.ip import IPSyntaxChecker
 from PyFunceble.converter.base import ConverterBase
 from PyFunceble.converter.url2netloc import Url2Netloc
 from PyFunceble.helpers.list import ListHelper
@@ -63,24 +61,23 @@ from PyFunceble.helpers.regex import RegexHelper
 
 class AdblockInputLine2Subject(ConverterBase):
     """
-    Converts/Extract the subjects to test from an inputed AdBlock line.
-
-    In order to decode the given line, this class and its conversion method
-    will go though a brunch of decoding method.
+    Provides an interface for the conversion or extraction of valuable subjects
+    from an inputted AdBlock line.
     """
 
-    OPTION_SEPARATOR: str = ","
-    OPTIONS_SEPARATOR: str = "$"
-
     _aggressive: bool = False
 
+    __regex_helper: Optional[RegexHelper] = None
+
     def __init__(
         self, data_to_convert: Optional[Any] = None, aggressive: bool = False
     ) -> None:
         if aggressive is not None:
             self.aggressive = aggressive
 
-        super().__init__(data_to_convert)
+        self.__regex_helper = RegexHelper()
+
+        super().__init__(data_to_convert=data_to_convert)
 
     @ConverterBase.data_to_convert.setter
     def data_to_convert(self, value: Any) -> None:
@@ -136,219 +133,302 @@ class AdblockInputLine2Subject(ConverterBase):
         Checks if we should ignore the given line.
         """
 
-        to_ignore = r"(^!|^@@|^\/|^\[|^\.|^-|^_|^\?|^&)"
+        starting_chars = ["!", "@@", "/", "[", ".", "-", "_", "?", "&"]
 
-        return RegexHelper(to_ignore).match(line.strip(), return_match=False)
+        return any(line.startswith(x) for x in starting_chars)
 
-    @classmethod
-    def extract_base(cls, subject: Union[str, list]) -> str:
+    @staticmethod
+    def extract_base(subject: Union[str, List[str]]) -> Union[str, List[str]]:
         """
-        Extracts the base of the given element (supposed URL).
+        Extracts the base of the given subject (supposely URL).
+
+        :param subject:
+            The subject to work with.
+
+        Example:
 
-        As example:
             Giving :code:`"hello.world/?is=beautiful"` returns :code:`"hello.world"`
         """
 
         if isinstance(subject, list):
-            return [cls.extract_base(x) for x in subject]
+            return [AdblockInputLine2Subject.extract_base(x) for x in subject]
+
+        subject = subject.replace("*", "").replace("~", "")
 
         try:
             return Url2Netloc(subject).get_converted()
         except ValueError:
             return subject
 
-    @classmethod
-    def __format_decoded(
-        cls, decoded: str, *, result: Optional[List[str]] = None
-    ) -> List[str]:
+    def _decode_multiple_subject(self, decoded: str) -> Set[str]:
         """
-        A recursive method which infinitly filter and format the decoded data
-        in order to delete uneeded parts.
+        Implementation of the decoding of the case that multiple
+        subjects are possible in the given :py:class:`str`.
 
         :param decoded:
-            The decoded part.
+            The decoded part to split.
         """
 
-        if result is None:
-            result = []
+        result = set()
 
-        chars_to_split = ["^", "#", ",", "!", "|"]
+        rematch = self.__regex_helper.set_regex(r"((?:[^~\*,]+))").match(
+            decoded, rematch=True, return_match=True
+        )
 
-        for data in decoded:
-            if not data:
-                continue
+        if rematch:
+            result.update({self.extract_base(x) for x in rematch})
 
-            for char_to_split in chars_to_split:
-                if char_to_split in data:
-                    return cls.__format_decoded(
-                        data.split(char_to_split), result=result
-                    )
+        return result
+
+    def _decode_options(self, decoded_options: List[str]) -> Set[str]:
+        """
+        Handle the decoding of the options.
+
+        What it does:
+
+            - It extracts all :code:`domain=` component - when found.
+            - It extracts all :code:`href` URL base - when found.
 
-            data = cls.extract_base(data)
 
-            if data and (
-                DomainSyntaxChecker(data).is_valid() or IPSyntaxChecker(data).is_valid()
-            ):
-                result.append(data)
+        :param decoded_options:
+            The splitted list of options.
+        """
+
+        result = set()
+
+        for rule in decoded_options:
+            if "domain=" in rule:
+                rule = rule.replace("domain=", "").replace("|", ",")
+
+                result.update(self._decode_multiple_subject(rule))
+                continue
+
+            if "href" in rule:
+                matched = self.__regex_helper.set_regex(
+                    r"((?:\"|\')(.*)(?:\"|\'))"
+                ).match(rule, return_match=True, rematch=True, group=1)
+
+                result.add(self.extract_base(matched))
+                continue
 
         return result
 
-    def __filter_options(self, options: List[str]) -> Union[bool, List[str]]:
+    def _decode_v1(self, line: str) -> Set[str]:
         """
-        Filters the interessting parts of the given list of options.
+        Implementation of our first decoding mode.
+
+        In this mode we try to decode the simple:
+
+            ||ads.example.com^
 
-        :param options:
-            The extracted options to filter.
+        rule.
 
-        .. warning::
-            Thís method only works if the aggressive method is given.
+        :param line:
+            The line to decode.
         """
 
-        result = []
+        result = set()
 
-        regex_domain_in_option = r"domain=(.*)"
+        local_line = line.strip()
 
-        for option in options:
-            try:
-                domains = RegexHelper(regex_domain_in_option).match(
-                    option, return_match=True, rematch=True, group=0
-                )[-1]
-            except TypeError:
-                continue
+        if local_line.startswith("||") and (
+            local_line.endswith("^") or local_line.endswith("$")
+        ):
+            local_line = local_line.replace("||", "", 1)
 
-            result.extend(
-                [x for x in domains.split("|") if x and not x.startswith("~")]
-            )
+            if local_line.endswith("^"):
+                local_line = "".join(local_line.rsplit("^", 1))
+            elif local_line.endswith("$"):
+                local_line = "".join(local_line.rsplit("$", 1))
 
-        if self.aggressive:
-            return result
+            result.update(self._decode_multiple_subject(local_line))
 
-        return bool(result)
+        return {x for x in result if "." in x}
 
-    def __decode_v1(self, line: str) -> List[str]:
+    def _decode_v2(self, line: str) -> Set[str]:
         """
-        Our first decoding version.
+        Implementation of our second decoding mode.
+
+        In this mode, we try to decode the simple:
 
-        The main idea is to filter based on option and a pattern common to all
-        AdBlock / Ublock format.
+            |https://ads.example.com|
+
+        rule.
 
         :param line:
             The line to decode.
         """
 
-        result = []
+        result = set()
 
-        # Get all groups :-)
-        rematch = RegexHelper(r"^(?:.*\|\|)([^\/\$\^]{1,}).*$").match(
-            line, return_match=True, group=0, rematch=True
-        )
+        local_line = line.strip()
 
-        if rematch:
-            if self.OPTIONS_SEPARATOR in line:
-                # We get the list of options for filtering.
-                options = line.split(self.OPTIONS_SEPARATOR)[-1].split(
-                    self.OPTION_SEPARATOR
-                )
-
-                # pylint: disable=too-many-boolean-expressions
-                if (
-                    not options[-1]
-                    or "third-party" in options
-                    or "script" in options
-                    or "popup" in options
-                    or "xmlhttprequest" in options
-                    or "all" in options
-                    or "document" in options
-                ):
-                    result.extend(self.extract_base(rematch))
-
-                extra = self.__filter_options(options)
-
-                if extra:
-                    if isinstance(extra, list):
-                        extra.extend(self.extract_base(rematch))
-                        result.extend(self.extract_base(extra))
-                    else:
-                        result.extend(self.extract_base(rematch))
-            else:
-                result.extend(self.extract_base(rematch))
+        if local_line.startswith("|") and local_line.endswith("|"):
+            local_line = local_line.replace("|", "", 1)
+            local_line = "".join(local_line.rsplit("|", 1))
 
-        return result
+            result.add(self.extract_base(local_line))
+
+        return {x for x in result if "." in x}
 
-    def __decode_v2(self, line: str) -> List[str]:
+    def _decode_v3(self, line: str) -> Set[str]:
         """
-        Our second decoding version.
+        Implementation of our third decoding mode.
 
-        The main idea here is that we will match simple records.
+        In this mode, we try to decode the simple:
+
+            ||ads.example.com^$script,image,domain=example.com|~foo.example.info
+            ||ads.example.com$script,image,domain=example.com|~foo.example.info
+
+        rule.
 
         :param line:
             The line to decode.
         """
 
-        result = []
+        result = set()
+
+        local_line = line.strip()
+
+        if not local_line.startswith("||"):
+            return result
 
-        rematch = RegexHelper(r"^\|(.*\..*)\|$").match(
-            line, return_match=True, rematch=True, group=0
+        if "$" in local_line:
+            v1_mode, options = local_line.split("$", 1)
+
+            if not v1_mode.endswith("^"):
+                v1_mode += "^"
+
+            result.update(self._decode_v1(v1_mode))
+
+            if self.aggressive:
+                result.update(self._decode_options(options.split(",")))
+        elif "^" not in local_line:
+            result.update(self._decode_v1(f"{local_line}^"))
+        else:
+            result.update(self._decode_v1(local_line[: local_line.find("^") + 1]))
+
+        return {x for x in result if "." in x}
+
+    def _decode_v4(self, line: str) -> Set[str]:
+        """
+        Implementation of our fourth decoding mode.
+
+        In this mode, we try to decode the simple:
+
+            @@||ads.example.com/notbanner^$~script
+
+        rule.
+
+        :param line:
+            The line to decode.
+        """
+
+        result = set()
+        local_line = line.strip()
+
+        if (
+            not self.aggressive
+            or not local_line.startswith("@@||")
+            or "^$" not in local_line
+        ):
+            return result
+
+        print(not local_line.startswith("@@||"), "^$" not in local_line)
+
+        v1_mode, options = local_line.split("$", 1)
+
+        result.update(
+            {self.extract_base(x) for x in self._decode_v1(v1_mode.replace("@@", ""))}
         )
 
-        if rematch:
-            result.extend(self.__format_decoded(rematch))
+        result.update(self._decode_options(options.split(",")))
 
-        return result
+        return {x for x in result if "." in x}
 
-    def __decode_v3(self, line: str) -> List[str]:
+    def _decode_v5(self, line: str) -> Set[str]:
         """
-        Our third decoding version.
+        Implementation of our fifth decoding mode.
+
+        In this mode, we try to decode the simple:
+
+            example.com,example.net##.advert
+            exception.example.com#@#.advert
+            example.com,example.net#?#div:-abp-has(> div > img.advert)
+            exception.example.com#@#div:-abp-has(> div > img.advert)
 
-        This one is for more complex formats (and Ublock).
+        rule.
 
         :param line:
             The line to decode.
         """
 
-        result = []
+        local_line = line.strip()
+        result = set()
 
-        rematch = RegexHelper(
-            r"(?:#+(?:[a-z]+?)?\[[a-z]+(?:\^|\*)\=(?:\'|\"))(.*\..*)(?:(?:\'|\")\])"
-        ).match(line, return_match=True, rematch=True, group=0)
+        if not self.aggressive:
+            return result
 
-        if rematch:
-            result.extend(self.__format_decoded(rematch))
+        separators = ["##", "#@#", "#?#"]
 
-        return result
+        obj_of_interest, options = "", ""
+
+        for separator in separators:
+            if separator in local_line:
+                obj_of_interest, options = local_line.split(separator, 1)
+                break
+
+        result.update(self._decode_multiple_subject(obj_of_interest))
+        result.update(self._decode_options(options.split(",")))
 
-    def __decode_v4(self, line: str) -> List[str]:
+        return {x for x in result if "." in x}
+
+    def _decode_v6(self, line: str) -> Set[str]:
         """
-        Our fourth decoding version.
+        Implementation of our sixth decoding mode.
+
+        In this mode we try to decode the simple:
 
-        This is is for the one who are surrounded by #.
+            $domain=exam.pl|elpmaxe.pl|example.pl
+
+        rule.
 
         :param line:
             The line to decode.
         """
 
-        result = []
+        local_line = line.strip()
+        result = set()
 
-        rematch = RegexHelper(r"^(.*?)(?:#{2}|#@#)").match(
-            line, return_match=True, rematch=True, group=0
-        )
+        if not self.aggressive:
+            return result
 
-        if rematch:
-            result.extend(self.__format_decoded(rematch))
+        separators = ["$"]
 
-        return result
+        for separator in separators:
+            if not local_line.startswith(separator):
+                continue
+
+            options = local_line[len(separator) :]
+
+            result.update(self._decode_options(options.split(",")))
+
+        return {x for x in result if "." in x}
 
     def get_converted(self) -> List[str]:
         """
-        Provides the subjects to test.
+        Provides the converted data.
         """
 
-        result = []
+        result = set()
 
         if not self.should_be_ignored(self.data_to_convert.strip()):
-            result.extend(self.__decode_v1(self.data_to_convert))
-            result.extend(self.__decode_v2(self.data_to_convert))
-            result.extend(self.__decode_v3(self.data_to_convert))
-            result.extend(self.__decode_v4(self.data_to_convert))
+            result.update(self._decode_v1(self.data_to_convert))
+            result.update(self._decode_v2(self.data_to_convert))
+            result.update(self._decode_v3(self.data_to_convert))
+            result.update(self._decode_v5(self.data_to_convert))
+            result.update(self._decode_v6(self.data_to_convert))
+
+        result.update(self._decode_v4(self.data_to_convert))
 
-        return ListHelper(result).remove_duplicates().sort().subject
+        return ListHelper(list(result)).sort().subject

PyFunceble/helpers/download.py

@@ -221,7 +221,7 @@ class DownloadHelper:
 
         :param destination: The download destination.
 
-        :raise UnableToDownload: When could not unable to donwload the URL.
+        :raise UnableToDownload: When could not unable to download the URL.
         """
 
         session = requests.Session()
@@ -240,8 +240,10 @@ class DownloadHelper:
             if destination and isinstance(destination, str):
                 FileHelper(destination).write(req.text, overwrite=True)
 
+            req.close()
             return response
 
+        session.close()
         raise PyFunceble.helpers.exceptions.UnableToDownload(
             f"{req.url} (retries: {self.retries} | status code: {req.status_code})"
         )

PyFunceble/helpers/environment_variable.py

@@ -144,13 +144,13 @@ class EnvironmentVariableHelper:
             The name to set.
         """
 
-        self.name = value
+        self.env_file_path = value
 
         return self
 
     def exists(self) -> bool:
         """
-        Checks if the given environement variable name exists.
+        Checks if the given environment variable name exists.
         """
 
         return self.name in os.environ
@@ -204,6 +204,10 @@ class EnvironmentVariableHelper:
         """
         Sets the given value and save it into the given dotenv file.
 
+        .. warning::
+            This method also set the environment variable from the current
+            environment.
+
         :param value:
             The value to set.
         """
@@ -227,8 +231,14 @@ class EnvironmentVariableHelper:
     def delete_from_env_file(self) -> "EnvironmentVariableHelper":
         """
         Deletes the given environment file from the given dotenv file.
+
+        .. warning::
+            This method also delete the environment variable from the current
+            environment.
         """
 
+        self.delete()
+
         dotenv.unset_key(self.env_file_path, self.name)
 
         return self

PyFunceble/storage.py

@@ -61,7 +61,7 @@ from dotenv import load_dotenv
 from PyFunceble.storage_facility import get_config_directory
 
 PROJECT_NAME: str = "PyFunceble"
-PROJECT_VERSION: str = "4.0.0b34.dev (Blue Duckling)"
+PROJECT_VERSION: str = "4.0.0b35.dev (Blue Duckling)"
 
 DISTRIBUTED_CONFIGURATION_FILENAME: str = ".PyFunceble_production.yaml"
 DISTRIBUTED_DIR_STRUCTURE_FILENAME: str = "dir_structure_production.json"

{PyFunceble_dev-4.0.0b34.dist-info → PyFunceble_dev-4.0.0b35.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyFunceble-dev
-Version: 4.0.0b34
+Version: 4.0.0b35
 Summary: The tool to check the availability or syntax of domain, IP or URL.
 Home-page: https://github.com/funilrys/PyFunceble
 Author: funilrys

{PyFunceble_dev-4.0.0b34.dist-info → PyFunceble_dev-4.0.0b35.dist-info}/RECORD

@@ -4,7 +4,7 @@ PyFunceble/facility.py,sha256=HCwrdsuPDvkoIoWC5MgXkpHJeLjySY8vY6ZYEael3t4,2627
 PyFunceble/factory.py,sha256=-CwpjMvOdrREMM7e4pC4y4mGUAORtJPeQ33ggXqFg94,2577
 PyFunceble/logger.py,sha256=-vOChPJV-qlBFyzbChaO_UopcUMcr55TNkGqIUqy43Q,16757
 PyFunceble/sessions.py,sha256=AJZon_02K__w8cjF7zH4n5TPDWSndE2T_dV-kqLfMjY,2569
-PyFunceble/storage.py,sha256=MA0ftsAtKDr7pfo0_P5fAPEwGarQ7ZWXJTDaKd2x12A,6098
+PyFunceble/storage.py,sha256=WufkdZIt5n-wAXSXFLmw5jiTlJMNShPiLr1Ry_UG3Uw,6098
 PyFunceble/storage_facility.py,sha256=5ajP3o4WpXp1Bt-SvyRZJWx8vc0Cvih19POFGMDW-Eg,4820
 PyFunceble/.vscode/settings.json,sha256=CNwEGC910aIFzMRFJ32nSq86EbSaoSmtmMWjdCXMrpM,49
 PyFunceble/checker/__init__.py,sha256=VujZifUlm9gvVrMBgQ6SVPseVJwbX1-NTSVywdglkb4,2431
@@ -30,7 +30,7 @@ PyFunceble/checker/reputation/params.py,sha256=p9BiVPUFnTCCR0P2VMbB5Wa4WBvjAIY_m
 PyFunceble/checker/reputation/status.py,sha256=cTLUbIefHZEdyWMupLrKItvrS5YV3YFCyhgndWhfc4Y,4056
 PyFunceble/checker/reputation/url.py,sha256=xtcvf2gmXcwdNFSHcji2jidGgY08cNuXIxzI2ydgArc,3394
 PyFunceble/checker/syntax/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-PyFunceble/checker/syntax/base.py,sha256=v6AOYVfRD7BkPpOdtGFVBunjNBcorms9u0-WzcDFNB8,4435
+PyFunceble/checker/syntax/base.py,sha256=Ka1HQUORCt8Y6KIZi-kVOox453SXg0mJ2pXFdYlt3z4,4481
 PyFunceble/checker/syntax/domain.py,sha256=xW85OY5ciDTR0qDlFZODwV917mNyIqdFqmGx71k7XDY,4816
 PyFunceble/checker/syntax/domain_base.py,sha256=1i8VXAMrjrx5ePnzJqEmqW2eAcWgn5x3WOHnos8E0yE,6894
 PyFunceble/checker/syntax/ip.py,sha256=IdO2n-Q86IyWBF8UZ0RqMyui67YraICx6ldjlbPelOI,5634
@@ -101,7 +101,7 @@ PyFunceble/cli/migrators/mariadb/base.py,sha256=JiDxtkVnW-UOI5AUOwXD8KNake-AA-k7
 PyFunceble/cli/migrators/mariadb/file_and_status.py,sha256=hyYMcK1HnBg325XD68F5Ip3GtPIu7Zwe22AjHcJS75U,7048
 PyFunceble/cli/migrators/mariadb/whois_record_idna_subject.py,sha256=9YcQnZo7MZUE1BBj_nVua04OMkvdQCciXBZnLGBljho,4437
 PyFunceble/cli/processes/__init__.py,sha256=idorOeJrcr9mBf9gxKUcaRZ1PmledpVOodrhcOYnphA,2641
-PyFunceble/cli/processes/base.py,sha256=QW_3PSdHXxuaI4M3K_FZ5N5b9vm2cq-9Grws9lPY6eg,14281
+PyFunceble/cli/processes/base.py,sha256=XeZz-BpjnHRJJjR8cz5wfhT0UeYDMRfrNEdb0e_HE0w,14735
 PyFunceble/cli/processes/file_sorter.py,sha256=FlcIohQiCdkfbRbe7fuA7V21ZW7LWaK-0K3D7CcrsLo,2745
 PyFunceble/cli/processes/migrator.py,sha256=6XXS5iXaHxlQHMPtdzbXbYEKt3osnzCRUCu9ky1Bnvs,15182
 PyFunceble/cli/processes/miner.py,sha256=Bz-O4adtBdeGiCQCr5XboIDsjFYi327iZfCSIrSGGGA,2707
@@ -132,7 +132,7 @@ PyFunceble/config/__init__.py,sha256=2GgOQWwdClM28JicoTwZEM77aLz0iZwDpwwtSXGepZs
 PyFunceble/config/compare.py,sha256=l7V-nu5_AohW7O8sL3EIpsM_aknLrfuCRTOHZO3crUA,12483
 PyFunceble/config/loader.py,sha256=U4rn_w1zZzCcRdQr0y93Kvjn4IaHYUu-b6fOE5eiKhE,12868
 PyFunceble/converter/__init__.py,sha256=HDk64s6MDLEPlGOQA1vLyT04Wd7Zaq2r51PtmP_QbRg,2437
-PyFunceble/converter/adblock_input_line2subject.py,sha256=FOX74K4cJOkxjl6jo3xO0NaZs56IdJrxayIgUsKlYes,11088
+PyFunceble/converter/adblock_input_line2subject.py,sha256=5QjavRM2jTNvEUHh-jfdFzGS1OYgKGRsKT-ZGhKYwtU,12947
 PyFunceble/converter/base.py,sha256=vLs77XK5PCMcAKqFiQO4Zy7GB5bnSlh42CA9whU6878,3625
 PyFunceble/converter/input_line2subject.py,sha256=EpUxicwp3Gxi24MyrKMQc8XeqDIC0Qx6nZyixOBLQGM,4596
 PyFunceble/converter/internal_url.py,sha256=RxgdADi_bWAgQQUPxiN7x_cVKl5rrXrpvR_80dNKDbY,3692
@@ -211,8 +211,8 @@ PyFunceble/helpers/__init__.py,sha256=aLAVgls7bcEDLufVmZceihffrf71SvuMyOyzfKI8Vd
 PyFunceble/helpers/command.py,sha256=S1WgFRFUmogXHHZ8TkR9Niw_T7ajHTuAJU3jVWSCzA0,7632
 PyFunceble/helpers/dict.py,sha256=58SbFjGCEKZdhswpgl0yaNS19OVyy2Loy9Nzf0T77Zo,13782
 PyFunceble/helpers/directory.py,sha256=zGl8eKwruntTwxoEzmCbJXz3AvLx4aHkJzKpc4mG_eY,5977
-PyFunceble/helpers/download.py,sha256=Yc-R1pDfEZdsI5UCdExj-9iW_qS3XgZc8YBfzF0Ar5E,7378
-PyFunceble/helpers/environment_variable.py,sha256=L6QKp5d2TLE-jC3d1CXMf1ocSHCIHzMkiLEkzuydTvM,6957
+PyFunceble/helpers/download.py,sha256=b7spkPXppz47dzJUaqwewo7q7KJm45YHP1vZSV1gJ6s,7426
+PyFunceble/helpers/environment_variable.py,sha256=1nRxAVTopWIA3W-3PavWlaAcfGFitOHl8fPk67h9qO8,7235
 PyFunceble/helpers/exceptions.py,sha256=dKiqWn7XYYup5nI2WzW_Clh1jUiIMNyQTkJUO2phulo,2761
 PyFunceble/helpers/file.py,sha256=ru-7_Ay1_Xc8N_XwD1j2nRRRKb1i9xhmd36I9n32UbY,6536
 PyFunceble/helpers/hash.py,sha256=iDDnz7fHDiaKUlktVwhEwp_TAGNtZy41IZoWLwpChTI,5261
@@ -250,9 +250,9 @@ PyFunceble/utils/__init__.py,sha256=zMW-yHa0L363-x09n9ECqaeNWMqXwhjM1nf9DKlm0W0,
 PyFunceble/utils/platform.py,sha256=H_xWL4xXu_eTTtGsxNg7ETrffAeQlS9Ik5OcJXZdfKY,3907
 PyFunceble/utils/profile.py,sha256=o8reJzVWHOz89IblQxmLafNYdIxnLyF4uRyyEyuApYA,3255
 PyFunceble/utils/version.py,sha256=f3_QrarCmOaguHfs8Z7a4PG7QCPjc5uExjjpbQVbyJo,11309
-PyFunceble_dev-4.0.0b34.dist-info/LICENSE,sha256=aenEcfHNnA3RjzJYjI__qB9TxU2NBKGvhgPlCo014Z0,10783
-PyFunceble_dev-4.0.0b34.dist-info/METADATA,sha256=qSd4zL_Z-1OKegzSJKUNQ3492ynS8PKf3yRL6fNUSjQ,15943
-PyFunceble_dev-4.0.0b34.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
-PyFunceble_dev-4.0.0b34.dist-info/entry_points.txt,sha256=CjpbvIUzYzeHRLep_c-gfngDihweQzDfOGSdZ6xvhfw,414
-PyFunceble_dev-4.0.0b34.dist-info/top_level.txt,sha256=J7GBKIiNYv93m1AxLy8_gr6ExXyZbMmCVXHMQBTUq2Y,11
-PyFunceble_dev-4.0.0b34.dist-info/RECORD,,
+PyFunceble_dev-4.0.0b35.dist-info/LICENSE,sha256=aenEcfHNnA3RjzJYjI__qB9TxU2NBKGvhgPlCo014Z0,10783
+PyFunceble_dev-4.0.0b35.dist-info/METADATA,sha256=2FyjP0BQqW9otexoqHcXXwrNtjwxVDeonFbNnOxJqCU,15943
+PyFunceble_dev-4.0.0b35.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+PyFunceble_dev-4.0.0b35.dist-info/entry_points.txt,sha256=CjpbvIUzYzeHRLep_c-gfngDihweQzDfOGSdZ6xvhfw,414
+PyFunceble_dev-4.0.0b35.dist-info/top_level.txt,sha256=J7GBKIiNYv93m1AxLy8_gr6ExXyZbMmCVXHMQBTUq2Y,11
+PyFunceble_dev-4.0.0b35.dist-info/RECORD,,