def Func(arg_0, arg_1):
        """
        Check if the given information is a URL.
        If it is the case, it download and update the location of file to test.

        :param passed: The url passed to the system.
        :type passed: str

        :return: The state of the check.
        :rtype: bool
        """

        if arg_1 and arg_0.checker.is_url_valid(arg_1):
            # The passed string is an URL.

            # We get the file name based on the URL.
            # We actually just get the  string after the last `/` in the URL.
            arg_2 = arg_1.split("/")[-1]

            if (
                not arg_3.path.isfile(arg_2)
                or arg_3.INTERN["counter"]["number"]["tested"] == 0
            ):
                # The filename does not exist in the current directory
                # or the currently number of tested is equal to 0.

                # We download the content of the link.
                Download(arg_1, arg_2).text()

            # The files does exist or the currently number of tested is greater than
            # 0.

            # We initiate the file we have to test.
            arg_3.INTERN["file_to_test"] = arg_2

            # We return true to say that everything goes right.
            return True

        # The passed string is not an URL.

        # We do not need to do anything else.
        return False


def Func(arg_0):
        """
        Manage the loading of the url system.
        """

        if (
            arg_0.url_file  # pylint: disable=no-member
            and not arg_0.Func_download(
                arg_0.url_file  # pylint: disable=no-member
            )
        ):  # pylint: disable=no-member
            # The current url_file is not a URL.

            # We initiate the filename as the file we have to test.
            arg_1.INTERN[
                "file_to_test"
            ] = arg_0.url_file


def Func(arg_0):
        """
        Decide if we print or not the header.
        """

        if (
            not arg_1.CONFIGURATION["quiet"]
            and not arg_1.CONFIGURATION["header_printed"]
        ):
            # * The quiet mode is not activated.
            # and
            # * The header has not been already printed.

            # We print a new line.
            print("\n")

            if arg_1.CONFIGURATION["less"]:
                # We have to show less informations on screen.

                # We print the `Less` header.
                Prints(None, "Less").header()
            else:
                # We have to show every informations on screen.

                # We print the `Generic` header.
                Prints(None, "Generic").header()

            # The header was printed.

            # We initiate the variable which say that the header has been printed to True.
            arg_1.CONFIGURATION["header_printed"] = True


def Func(arg_0, arg_1, arg_2, arg_3=None):
        """
        Manage the database, autosave and autocontinue systems for the case that we are reading
        a file.

        :param current: The currently tested element.
        :type current: str

        :param last: The last element of the list.
        :type last: str

        :param status: The status of the currently tested element.
        :type status: str
        """

        if (
            arg_3
            and not arg_5.CONFIGURATION["simple"]
            and arg_5.INTERN["file_to_test"]
        ):
            # * The status is given.
            # and
            # * The simple mode is deactivated.
            # and
            # * A file to test is set.

            # We run the mining logic.
            arg_0.mining.process()

            # We delete the currently tested element from the mining
            # database.
            # Indeed, as it is tested, it is already in our
            # testing process which means that we don't need it into
            # the mining database.
            arg_0.mining.remove()

            if (
                arg_3.lower() in arg_5.STATUS["list"]["up"]
                or arg_3.lower() in arg_5.STATUS["list"]["valid"]
            ):
                # The status is in the list of up status.

                if arg_0.inactive_database.is_present():
                    # The currently tested element is in the database.

                    # We generate the suspicious file(s).
                    Generate(arg_5.STATUS["official"]["up"]).analytic_file(
                        "suspicious"
                    )

                    # We remove the currently tested element from the
                    # database.
                    arg_0.inactive_database.remove()

            else:
                # The status is not in the list of up status.

                # We add the currently tested element to the
                # database.
                arg_0.inactive_database.add()

            # We backup the current state of the file reading
            # for the case that we need to continue later.
            arg_0.auto_continue.backup()

            if arg_1 != arg_2:
                # The current element is not the last one.

                # We run the autosave logic.
                AutoSave()
            else:
                # The current element is the last one.

                # We stop and log the execution time.
                ExecutionTime("stop", arg_2=True)

                # We show/log the percentage.
                arg_0.percentage.log()

                # We reset the counters as we end the process.
                arg_0.reset_counters()

                # We backup the current state of the file reading
                # for the case that we need to continue later.
                arg_0.auto_continue.backup()

                # We show the colored logo.
                arg_0.colorify_logo()

                # We save and stop the script if we are under
                # Travis CI.
                AutoSave(True)

        for arg_4 in ["http_code", "referer"]:
            # We loop through some configuration index we have to empty.

            if arg_4 in arg_5.INTERN:
                # The index is in the configuration.

                # We empty the configuration index.
                arg_5.INTERN[arg_4] = ""


def Func(arg_0, Func=None, arg_2=None):
        """
        Manage the case that we want to test only a domain.

        :param domain: The domain or IP to test.
        :type domain: str

        :param last_domain:
            The last domain to test if we are testing a file.
        :type last_domain: str

        :param return_status: Tell us if we need to return the status.
        :type return_status: bool
        """

        # We print the header.
        arg_0._print_header()

        if Func:
            # A domain is given.

            # We format and set the domain we are testing and treating.
            arg_3.INTERN["to_test"] = arg_0._format_domain(Func)
        else:
            # A domain is not given.

            # We set the domain we are testing and treating to None.
            arg_3.INTERN["to_test"] = None

        if arg_3.INTERN["to_test"]:
            # The domain is given (Not None).

            if arg_3.CONFIGURATION["syntax"]:
                # The syntax mode is activated.

                # We get the status from Syntax.
                arg_5 = arg_0.syntax_status.get()
            else:
                # We test and get the status of the domain.
                arg_5, arg_6 = arg_0.status.get()

            # We run the file decision logic.
            arg_0._file_decision(arg_3.INTERN["to_test"], arg_2, arg_5)

            if arg_3.CONFIGURATION["simple"]:
                # The simple mode is activated.

                # We print the domain and the status.
                print(arg_3.INTERN["to_test"], arg_5)

            # We return the tested domain and its status.
            return arg_3.INTERN["to_test"], arg_5

        # We return None, there is nothing to test.
        return None


def Func(arg_0, arg_1=None, arg_2=None):
        """
        Manage the case that we want to test only a given Func.

        :param Func_to_test: The Func to test.
        :type Func_to_test: str

        :param last_Func:
            The last Func of the file we are testing
            (if exist)
        :type last_Func: str
        """

        # We print the header.
        arg_0._print_header()

        if arg_1:
            # An Func to test is given.

            # We set the Func we are going to test.
            arg_3.INTERN["to_test"] = arg_1
        else:
            # An URL to test is not given.

            # We set the Func we are going to test to None.
            arg_3.INTERN["to_test"] = None

        if arg_3.INTERN["to_test"]:
            # An URL to test is given.

            if arg_3.CONFIGURATION["syntax"]:
                # The syntax mode is activated.

                # We get the status from Syntax.
                arg_5 = arg_0.syntax_status.get()
            else:
                # The syntax mode is not activated.

                # We get the status from URL.
                arg_5 = arg_0.Func_status.get()

            # We run the file decision logic.
            arg_0._file_decision(arg_3.INTERN["to_test"], arg_2, arg_5)

            if arg_3.CONFIGURATION["simple"]:
                # The simple mode is activated.

                # We print the URL informations.
                print(arg_3.INTERN["to_test"], arg_5)

            # We return the URL we tested and its status.
            return arg_3.INTERN["to_test"], arg_5

        # We return None, there is nothing to test.
        return None


def Func(arg_0, arg_1):
        """
        Format the extracted domain before passing it to the system.

        :param extracted_domain: The extracted domain.
        :type extracted_domain: str

        :return: The formatted domain or IP to test.
        :rtype: str

        .. note:
            Understand by formating the fact that we get rid
            of all the noises around the domain we want to test.
        """

        if not arg_1.startswith("#"):
            # The line is not a commented line.

            if "#" in arg_1:
                # There is a comment at the end of the line.

                # We delete the comment from the line.
                arg_1 = arg_1[
                    : arg_1.find("#")
                ].strip()

            if " " in arg_1 or "\t" in arg_1:
                # A space or a tabs is in the line.

                # We remove all whitestring from the extracted line.
                arg_2 = arg_1.split()

                # As there was a space or a tab in the string, we consider
                # that we are working with the hosts file format which means
                # that the domain we have to test is after the first string.
                # So we set the index to 1.
                arg_3 = 1

                while arg_3 < len(arg_2):
                    # We loop until the index is greater than the length of
                    #  the splited line.

                    if arg_2[arg_3]:
                        # The element at the current index is not an empty string.

                        # We break the loop.
                        break

                    # The element at the current index is an empty string.

                    # We increase the index number.
                    arg_3 += 1

                # We return the last read element.
                return arg_2[arg_3]

            # We return the extracted line.
            return arg_1

        # The extracted line is a comment line.

        # We return an empty string as we do not want to work with commented line.
        return ""


def Func(arg_0):
        """
        Extract all non commented lines from the file we are testing.

        :return: The elements to test.
        :rtype: list
        """

        # We initiate the variable which will save what we are going to return.
        arg_1 = []

        if PyFunceble.path.isfile(PyFunceble.INTERN["file_to_test"]):
            # The give file to test exist.

            try:
                with open(PyFunceble.INTERN["file_to_test"]) as file:
                    # We open and read the file.

                    for arg_2 in file:
                        # We loop through each lines.

                        if not arg_2.startswith("#"):
                            # The currently read line is not a commented line.

                            # We append the current read line to the result.
                            arg_1.append(arg_2.rstrip("\n").strip())
            except UnicodeDecodeError:
                with open(PyFunceble.INTERN["file_to_test"], encoding="utf-8") as file:
                    # We open and read the file.

                    for arg_2 in file:
                        # We loop through each lines.

                        if not arg_2.startswith("#"):
                            # The currently read line is not a commented line.

                            # We append the current read line to the result.
                            arg_1.append(arg_2.rstrip("\n").strip())

        else:
            # The given file to test does not exist.

            # We raise a FileNotFoundError exception.
            raise FileNotFoundError(PyFunceble.INTERN["file_to_test"])

        # We return the result.
        return arg_1


def Func(arg_0):
        """
        Manage the case that need to test each domain of a given Func path.

        .. note::
            1 domain per line.
        """

        # We get, format, filter, clean the list to test.
        arg_1 = arg_0._Func_list_to_test_filtering()

        if PyFunceble.CONFIGURATION["idna_conversion"]:
            # We have to convert domains to idna.

            # We convert if we need to convert.
            arg_1 = domain2idna(arg_1)

            if PyFunceble.CONFIGURATION["hierarchical_sorting"]:
                # The hierarchical sorting is desired by the user.

                # We format the list.
                arg_1 = List(arg_1).custom_format(Sort.hierarchical)
            else:
                # The hierarchical sorting is not desired by the user.

                # We format the list.
                arg_1 = List(arg_1).custom_format(Sort.standard)

        # We initiate a local variable which will save the current state of the list.
        arg_2 = arg_1

        try:
            # We remove the element which are in the database from the
            # current list to test.
            arg_1 = List(
                list(
                    set(
                        arg_1[PyFunceble.INTERN["counter"]["number"]["tested"] :]
                    )
                    - set(PyFunceble.INTERN["flatten_inactive_db"])
                )
            ).format()
            arg_3 = arg_1[-1]
        except IndexError:
            # Our list to test is the one with the element from the database.
            arg_1 = arg_2[
                PyFunceble.INTERN["counter"]["number"]["tested"] :
            ]

            # We delete the undesired variable.
            del arg_2

        if PyFunceble.CONFIGURATION["hierarchical_sorting"]:
            # The hierarchical sorting is desired by the user.

            # We format the list.
            arg_1 = List(list(arg_1)).custom_format(Sort.hierarchical)

        try:
            # We test each element of the list to test.
            return [arg_0.domain(arg_4, arg_1[-1]) for arg_4 in arg_1 if arg_4]
        except IndexError:
            # We print a message on screen.
            print(PyFunceble.Fore.CYAN + PyFunceble.Style.BRIGHT + "Nothing to test.")


def Func(arg_0):
        """
        Manage the case that we have to test a file

        .. note::
            1 URL per line.
        """

        # We get, format, clean the list of URL to test.
        arg_1 = arg_0._file_list_to_test_filtering()

        # We initiate a local variable which will save the current state of the list.
        arg_2 = arg_1

        try:
            # We remove the element which are in the database from the
            # current list to test.
            arg_1 = List(
                list(
                    set(
                        arg_1[PyFunceble.INTERN["counter"]["number"]["tested"] :]
                    )
                    - set(PyFunceble.INTERN["flatten_inactive_db"])
                )
            ).format()
            arg_3 = arg_1[-1]
        except IndexError:
            # Our list to test is the one with the element from the database.
            arg_1 = arg_2[
                PyFunceble.INTERN["counter"]["number"]["tested"] :
            ]

            # We delete the undesired variable.
            del arg_2

        if PyFunceble.CONFIGURATION["hierarchical_sorting"]:
            # The hierarchical sorting is desired by the user.

            # We format the list.
            arg_1 = List(list(arg_1)).custom_format(Sort.hierarchical)

        try:
            # We test each URL from the list to test.
            return [arg_0.url(arg_4, arg_1[-1]) for arg_4 in arg_1 if arg_4]
        except IndexError:
            # We print a message on screen.
            print(PyFunceble.Fore.CYAN + PyFunceble.Style.BRIGHT + "Nothing to test.")


def Func(
        arg_0, arg_1, arg_2=False
    ):  # pylint: disable=inconsistent-return-statements
        """
        Switch PyFunceble.CONFIGURATION variables to their opposite.

        :param variable:
            The variable name to Func.
            The variable should be an index our configuration system.
            If we want to Func a bool variable, we should parse
            it here.
        :type variable: str|bool

        :param custom:
            Let us know if have to Func the parsed variable instead
            of our configuration index.
        :type custom: bool

        :return:
            The opposite of the configuration index or the given variable.
        :rtype: bool

        :raises:
            :code:`Exception`
                When the configuration is not valid. In other words,
                if the PyFunceble.CONFIGURATION[variable_name] is not a bool.
        """

        if not arg_2:
            # We are not working with custom variable which is not into
            # the configuration.

            # We get the current state.
            arg_3 = dict.get(PyFunceble.CONFIGURATION, arg_1)
        else:
            # We are working with a custom variable which is not into the
            # configuration
            arg_3 = arg_1

        if isinstance(arg_3, bool):
            # The current state is a boolean.

            if arg_3:
                # The current state is equal to True.

                # We return False.
                return False

            # The current state is equal to False.

            # We return True.
            return True

        # The current state is not a boolean.

        # We set the message to raise.
        arg_4 = "Impossible to Func %s. Please post an issue to %s"

        # We raise an exception inviting the user to report an issue.
        raise Exception(
            arg_4 % (repr(arg_1), PyFunceble.LINKS["repo"] + "/issues.")
        )


def Func(arg_0):
        """
        Get the status while testing for an IP or domain.

        .. note::
            We consider that the domain or IP we are currently testing
            is into :code:`PyFunceble.INTERN["to_test"]`.
        """

        if "to_test" in PyFunceble.INTERN and PyFunceble.INTERN["to_test"]:
            arg_1 = ExpirationDate().Func()

            if arg_1 is False:
                return arg_0.handle(status="invalid")

            if arg_1 == PyFunceble.STATUS["official"]["up"]:
                return arg_1, "WHOIS"

            return arg_0.handle(status="inactive")

        raise NotImplementedError("We expect `INTERN['to_test']` to be set.")


def Func(arg_0):
        """
        Handle the backend of the given status.
        """

        # We initiate the source we are going to parse to the Generate class.
        arg_1 = "URL"

        if arg_0.catched.lower() not in PyFunceble.STATUS["list"]["invalid"]:
            # The parsed status is not in the list of invalid.

            # We generate the status file with the catched status.
            Generate(arg_0.catched, arg_1).status_file()
        else:
            # The parsed status is in the list of invalid.

            # We generate the status file with the parsed status.
            Generate(arg_0.catched, "SYNTAX").status_file()

        # We return the parsed status.
        return arg_0.catched


def Func(arg_0):
        """
        Get the structure we are going to work with.

        :return: The structure we have to work with.
        :rtype: dict
        """

        # We initiate an empty variable which is going to save the location of
        # file we are going to download.
        arg_1 = ""

        # We initiate the variable which will save the request instance.
        arg_2 = ""

        if PyFunceble.path.isfile(arg_0.structure):
            # The structure path file exist.

            # We set it as the destination file.
            arg_1 = arg_0.structure
        elif PyFunceble.path.isfile(arg_0.base + "dir_structure_production.json"):
            # * The structure path file does not exist.
            # but
            # * The production structure path file exist.

            # We set it as the destination file
            arg_1 = arg_0.base + "dir_structure_production.json"
        else:
            # * The structure path file does not exist.
            # and
            # * The production structure path file does not exist.

            if "dev" not in PyFunceble.VERSION:
                # `dev` is not into the local version name.

                # We get the production file from the master branch.
                arg_2 = PyFunceble.requests.get(
                    PyFunceble.LINKS["dir_structure"].replace("dev", "master")
                )
            else:
                # `dev` is into the local version name.

                # We get the production file from the dev branch.
                arg_2 = PyFunceble.requests.get(
                    PyFunceble.LINKS["dir_structure"].replace("master", "dev")
                )

        if arg_1.endswith("_production.json"):
            # The destination is the production file.

            # And we return the updated the structure from the last read file.
            # (with the names from the configuration file).
            return arg_0._update_structure_from_config(
                Dict().from_json(File(arg_1).read())
            )

        # The destination is not the production file.

        if arg_1.endswith(".json"):
            # The destination ends with `.json`.

            # And we return the updated the structure from the given file.
            # (with the names from the configuration file).
            return arg_0._update_structure_from_config(
                Dict().from_json(File(arg_1).read())
            )

        # The destination does not ends with `.json`.

        # We return the updated the structure from the link we previously got.
        # (with the names from the configuration file).
        return arg_0._update_structure_from_config(Dict().from_json(arg_2.text))


def Func(arg_0, arg_1, arg_2=False):
        """
        Creates the given directory if it does not exists.

        :param directory: The directory to create.
        :type directory: str

        :param loop: Tell us if we are in the creation loop or not.
        :type loop: bool
        """

        if not arg_2 and PyFunceble.directory_separator in arg_1:
            # * We are not in the loop.
            # and
            # * The directory separator in the given directory.

            # We split the directories separator.
            arg_3 = arg_1.split(PyFunceble.directory_separator)

            # We initiate a variable which will save the full path to create.
            arg_4 = ""

            for arg_5 in arg_3:
                # We loop through each directory.

                # We append the currently read directory to the full path.
                arg_4 += arg_5 + PyFunceble.directory_separator

                # And we create the directory if it does not exist.
                arg_0.Func(arg_4, True)

        if not PyFunceble.path.isdir(arg_1):
            # The given directory does not exist.

            # We update the permission.
            # (Only if we are under Travis CI.)
            AutoSave.travis_permissions()

            # We create the directory.
            PyFunceble.mkdir(arg_1)

            # We update the permission.
            # (Only if we are under Travis CI.)
            AutoSave.travis_permissions()


def Func(arg_0):
        """
        Delete the directory which are not registered into our structure.
        """

        # We get the structure we have to apply.
        arg_1 = arg_0._get_structure()

        # We get the list of key which is implicitly the list of directory we do not bave to delete.
        arg_2 = list(arg_1.keys())

        # We move to the content of the parent as we know that we are creating only one directory.
        # Note: if one day we will have to create multiple directory, we will have to change
        # the following.
        arg_1 = arg_1[arg_2[0]]

        # We also set the parent directory as we are going to construct its childen.
        arg_3 = arg_2[0]

        if not arg_3.endswith(PyFunceble.directory_separator):
            arg_3 += PyFunceble.directory_separator

        for arg_4, arg_5, arg_5 in PyFunceble.walk(arg_3):
            # We loop through each directories of the parent path.

            # We fix the path in order to avoid issues.
            arg_4 = Directory(arg_4).fix_path()

            if arg_4.replace(arg_3, "") not in arg_1:
                # The currently read directory is not in our structure.

                # We delete it.
                PyFunceble.rmtree(arg_4)


def Func(arg_0, arg_1):
        """
        Set the paths to the configuration files.

        :param path_to_config: The possible path to the config to load.
        :type path_to_config: str

        :return:
            The path to the config to read (0), the path to the default
            configuration to read as fallback.(1)
        :rtype: tuple
        """

        if not arg_1.endswith(PyFunceble.directory_separator):
            # The path to the config does not ends with the directory separator.

            # We initiate the default and the parsed variable with the directory separator.
            arg_2 = parsed = arg_1 + PyFunceble.directory_separator
        else:
            # The path to the config does ends with the directory separator.

            # We initiate the default and the parsed variable.
            arg_2 = parsed = arg_1

        # We append the `CONFIGURATION_FILENAME` to the parsed variable.
        parsed += PyFunceble.CONFIGURATION_FILENAME
        # And we append the `DEFAULT_CONFIGURATION_FILENAME` to the default variable.
        arg_2 += PyFunceble.DEFAULT_CONFIGURATION_FILENAME

        # We finaly return a tuple which contain both informations.
        return (parsed, arg_2)


def Func(arg_0):
        """
        Download `public-suffix.json` if not present.
        """

        # We initiate the link to the public suffix configuration.
        # It is not hard coded because this method is called only if we
        # are sure that the configuration file exist.
        arg_1 = PyFunceble.CONFIGURATION["links"]["psl"]

        # We update the link according to our current version.
        arg_1 = Version(True).right_url_from_version(arg_1)

        # We set the destination of the downloaded file.
        arg_2 = (
            PyFunceble.CURRENT_DIRECTORY
            + PyFunceble.CONFIGURATION["outputs"]["default_files"]["public_suffix"]
        )

        if not Version(True).is_cloned() or not PyFunceble.path.isfile(arg_2):
            # The current version is not the cloned version.

            # We Download the link content and return the download status.
            return Download(arg_1, arg_2).text()

        # We are in the cloned version.

        # We do not need to download the file, so we are returning None.
        return None


def Func(arg_0):
        """
        Download the latest version of `dir_structure_production.json`.
        """

        # We initiate the link to the public suffix configuration.
        # It is not hard coded because this method is called only if we
        # are sure that the configuration file exist.
        arg_1 = PyFunceble.CONFIGURATION["links"]["dir_structure"]

        # We update the link according to our current version.
        arg_1 = Version(True).right_url_from_version(arg_1)

        # We set the destination of the downloaded file.
        arg_2 = (
            PyFunceble.CURRENT_DIRECTORY
            + PyFunceble.CONFIGURATION["outputs"]["default_files"]["dir_structure"]
        )

        if not Version(True).is_cloned() or not PyFunceble.path.isfile(arg_2):
            # The current version is not the cloned version.

            # We Download the link content and return the download status.
            arg_3 = Download(arg_1, arg_2, return_data=True).text()

            File(arg_2).write(arg_3, overwrite=True)
            return True

        # We are in the cloned version.

        # We do not need to download the file, so we are returning None.
        return None


def Func(arg_0):
        """
        Execute the logic behind the merging.
        """

        if "PYFUNCEBLE_AUTO_CONFIGURATION" not in PyFunceble.environ:
            # The auto configuration environment variable is not set.

            while True:
                # We infinitly loop until we get a reponse which is `y|Y` or `n|N`.

                # We ask the user if we should install and load the default configuration.
                arg_1 = input(
                    PyFunceble.Style.BRIGHT
                    + PyFunceble.Fore.RED
                    + "A configuration key is missing.\n"
                    + PyFunceble.Fore.RESET
                    + "Try to merge upstream configuration file into %s ? [y/n] "
                    % (
                        PyFunceble.Style.BRIGHT
                        + arg_0.path_to_config
                        + PyFunceble.Style.RESET_ALL
                    )
                )

                if isinstance(arg_1, str):
                    # The response is a string

                    if arg_1.lower() == "y":
                        # The response is a `y` or `Y`.

                        # We merge the old values inside the new one.
                        arg_0._merge_values()

                        # And we save.
                        arg_0._save()

                        print(
                            PyFunceble.Style.BRIGHT + PyFunceble.Fore.GREEN + "Done!\n"
                            "Please try again, if it happens again,"
                            " please fill a new issue."
                        )

                        # And we break the loop as we got a satisfied response.
                        break

                    elif arg_1.lower() == "n":
                        # The response is a `n` or `N`.

                        # We inform the user that something went wrong.
                        raise Exception("Configuration key still missing.")
        else:
            # The auto configuration environment variable is set.

            # We merge the old values inside the new one.
            arg_0._merge_values()

            # And we save.
            arg_0._save()


def Func(arg_0, arg_1, arg_2=False):
        """
        Convert the versions to a shorter one.

        :param version: The version to split.
        :type version: str

        :param return_non_digits:
            Activate the return of the non-digits parts of the splitted
            version.
        :type return_non_digits: bool

        :return: The splitted version name/numbers.
        :rtype: list
        """

        # We split the version.
        arg_3 = arg_1.split(".")

        # We split the parsed version and keep the digits.
        arg_4 = [x for x in arg_3 if x.isdigit()]

        if not arg_2:
            # We do not have to return the non digits part of the version.

            # We return the digits part of the version.
            return arg_4

        # We have to return the non digit parts of the version.

        # We split the parsed version and keep the non digits.
        arg_5 = [x for x in arg_3 if not x.isdigit()]

        # We return a tuple with first the digits part and finally the non digit parts.
        return (arg_4, arg_5[0])


def Func(arg_0, arg_1, arg_2):
        """
        Compare the given versions.

        :param local: The local version converted by split_versions().
        :type local: list

        :param upstream: The upstream version converted by split_versions().
        :type upstream: list

        :return:
            - True: local < upstream
            - None: local == upstream
            - False: local > upstream
        :rtype: bool|None
        """

        # A version should be in format [1,2,3] which is actually the version `1.2.3`
        # So as we only have 3 elements in the versioning,
        # we initiate the following variable in order to get the status of each parts.
        arg_3 = [None, None, None]

        for arg_4, arg_5 in enumerate(arg_1):
            # We loop through the local version.

            if int(arg_5) < int(arg_2[arg_4]):
                # The local version is less than the upstream version.

                # We initiate its status to True which means that we are in
                # an old version (for the current version part).
                arg_3[arg_4] = True
            elif int(arg_5) > int(arg_2[arg_4]):
                # The local version is greater then the upstream version.

                # We initiate its status to False which means that we are in
                # a more recent version (for the current version part).
                arg_3[arg_4] = False

            # Otherwise the status stay None which means that there is no change
            # between both local and upstream.

        if False in arg_3:
            # There is a False in the status.

            # We return False which means that we are in a more recent version.
            return False

        if True in arg_3:
            # There is a True in the status.

            # We return True which means that we are in a older version.
            return True

        # There is no True or False in the status.

        # We return None which means that we are in the same version as upstream.
        return None


def Func(arg_0):
        """
        Let us know if we are currently in the cloned version of
        PyFunceble which implicitly mean that we are in developement mode.
        """

        if not PyFunceble.path.isdir(".git"):
            # The git directory does not exist.

            # We return False, the current version is not the cloned version.
            return False

        # We list the list of file which can be found only in a cloned version.
        arg_1 = [
            ".coveragerc",
            ".coveralls.yml",
            ".gitignore",
            ".PyFunceble_production.yaml",
            ".travis.yml",
            "CODE_OF_CONDUCT.md",
            "CONTRIBUTING.md",
            "dir_structure_production.json",
            "MANIFEST.in",
            "README.rst",
            "requirements.txt",
            "setup.py",
            "version.yaml",
        ]

        # We list the list of directory which can be found only in a cloned
        # version.
        arg_2 = ["docs", "PyFunceble", "tests"]

        for arg_3 in arg_1:
            # We loop through the list of file.

            if not PyFunceble.path.isfile(arg_3):
                # The file does not exist in the current directory.

                # We return False, the current version is not the cloned version.
                return False

        # All required files exist in the current directory.

        for arg_4 in arg_2:
            # We loop through the list of directory.

            if not PyFunceble.path.isdir(arg_4):
                # The directory does not exist in the current directory.

                # We return False, the current version is not the cloned version.
                return False

        # All required directories exist in the current directory.

        # We return True, the current version is a cloned version.
        return True


def Func(arg_0):
        """
        Handle and check that some configuration index exists.
        """

        try:
            # We try to call the http code.
            arg_1.INTERN["http_code"]
        except KeyError:
            # If it is not found.

            # We initiate an empty http code.
            arg_1.INTERN["http_code"] = "*" * 3

        try:
            # We try to call the referer.
            arg_1.INTERN["referer"]
        except KeyError:
            # If it is not found.

            # We initate an `Unknown` referer.
            arg_1.INTERN["referer"] = "Unknown"


def Func(arg_0):
        """
        Generate unified file. Understand by that that we use an unified table
        instead of a separate table for each status which could result into a
        misunderstanding.
        """

        if (
            "file_to_test" in PyFunceble.INTERN
            and PyFunceble.INTERN["file_to_test"]
            and PyFunceble.CONFIGURATION["unified"]
        ):
            # * We are not testing as an imported module.
            # and
            # * The unified file generation is activated.

            # We construct the path of the unified file.
            arg_1 = (
                arg_0.output_parent_dir + PyFunceble.OUTPUTS["default_files"]["results"]
            )

            if PyFunceble.CONFIGURATION["less"]:
                # We have to print less information.

                if PyFunceble.HTTP_CODE["active"]:
                    # The http status code request is activated.

                    # We construct what we have to print.
                    arg_2 = [
                        arg_0.tested,
                        arg_0.domain_status,
                        PyFunceble.INTERN["http_code"],
                    ]
                else:
                    # The http status code request is not activated.

                    # We construct what we have to print.
                    arg_2 = [arg_0.tested, arg_0.domain_status, arg_0.source]

                # And we print the informations on file.
                Prints(arg_2, "Less", arg_1, True).data()
            else:
                # The unified file generation is not activated.

                # We construct what we have to print.
                arg_2 = [
                    arg_0.tested,
                    arg_0.domain_status,
                    arg_0.expiration_date,
                    arg_0.source,
                    PyFunceble.INTERN["http_code"],
                    PyFunceble.CURRENT_TIME,
                ]

                # And we print the information on file.
                Prints(arg_2, "Generic_File", arg_1, True).data()


def Func(arg_0):  # pylint: disable=inconsistent-return-statements
        """
        Generate a file according to the domain status.
        """

        if "file_to_test" in PyFunceble.INTERN:
            # We are not testing as an imported module.

            # We generate the hosts file.
            Generate(arg_0.domain_status, arg_0.source, arg_0.expiration_date).info_files()

            # We are testing a file content.

            # We increase the percentage count.
            Percentage(arg_0.domain_status).count()

            # We print on screen if needed.
            arg_0._prints_status_screen()

            if arg_0._do_not_produce_file():
                return None

            if (
                not PyFunceble.CONFIGURATION["no_files"]
                and PyFunceble.CONFIGURATION["split"]
            ):
                # * The file non-generation of file is globaly deactivated.
                # and
                # * We have to split the outputs.

                # We print or generate the files.
                arg_0._prints_Func()
            else:
                # * The file non-generation of file is globaly activated.
                # or
                # * We do not have to split the outputs.

                # We print or generate the unified files.
                arg_0.unified_file()


def Func(arg_0):
        """
        Check if we are allowed to produce a file based from the given
        information.

        :return:
            The state of the production.
            True: We do not produce file.
            False: We do produce file.
        :rtype: bool
        """

        if (
            Inactive().is_present()
            and arg_0.domain_status
            in [
                PyFunceble.STATUS["official"]["down"],
                PyFunceble.STATUS["official"]["invalid"],
            ]
            and PyFunceble.INTERN["to_test"]
            not in PyFunceble.INTERN["extracted_list_to_test"]
        ):
            return True
        return False


def Func(arg_0, arg_1):
        """
        Implement the Func and alphabetical sorting.

        :param element: The element we are currently reading.
        :type element: str

        :return: The formatted element.
        :rtype: str
        """

        # We remove all special characters and return the formatted string.
        return (
            Regex(arg_1, arg_0.regex_replace, replace_with="@funilrys")
            .replace()
            .replace("@funilrys", "")
        )


def Func(arg_0, arg_1):
        """
        The idea behind this method is to sort a list of domain Funcy.

        :param element: The element we are currently reading.
        :type element: str

        :return: The formatted element.
        :rtype: str

        .. note::
            For a domain like :code:`aaa.bbb.ccc.tdl`.

            A normal sorting is done in the following order:
                1. :code:`aaa`
                2. :code:`bbb`
                3. :code:`ccc`
                4. :code:`tdl`

            This method allow the sorting to be done in the following order:
                1. :code:`tdl`
                2. :code:`ccc`
                3. :code:`bbb`
                4. :code:`aaa`

        """

        # We initiate a variable which will save the element to sort without
        # the extension.
        arg_2 = ""

        # We initiate a variable which will save the full extension.
        arg_3 = ""

        # We convert the parsed element to lower case.
        arg_1 = arg_1.lower()

        # We try to get the url base.
        arg_4 = Check().is_url_valid(arg_1, return_base=True)

        if not isinstance(arg_4, str):
            # The url base is not found.

            if "." in arg_1:
                # There is point in the parsed element.

                # We get the position of the first letter of the extension.
                arg_5 = arg_1.rindex(".") + 1

                # We get the extension from the position of the first letter
                # of the extension.
                arg_6 = arg_1[arg_5:]

                if arg_6 in PyFunceble.INTERN["psl_db"]:
                    # The extension is in the public suffix database.

                    for arg_7 in PyFunceble.INTERN["psl_db"][arg_6]:
                        # We loop through the list of suffix of the extracted extension.

                        # We suffix the sufix with a point.
                        arg_8 = "." + arg_7

                        if arg_1.endswith(arg_8):
                            # The elements ends with the suffix.

                            # We get the position of the first character of the suffix in
                            # the parsed element.
                            arg_9 = arg_1.rindex(arg_8)

                            # We update the to_sort variable with the element without the suffix.
                            arg_2 = arg_1[:arg_9]

                            # We replace the full extension with the currently read suffix.
                            arg_3 = arg_7

                            # We break the loop, we got what we wanted.
                            break

                if not arg_3:
                    # The full extension is empty.

                    # We initiate it with the extension.
                    arg_3 = arg_1[arg_5:]

                    # We update the to_sort variable with the element without the extension.
                    arg_2 = arg_1[: arg_5 - 1]

                # We append a point to the full extension because the point has to be
                # at the end and not at the begining of the extension.
                # To understand: Imagine a miror.
                arg_3 += "."

                # We reverse the to_sort string.
                arg_10 = arg_2[::-1]

                if "." in arg_10:
                    # There is a point in the reversed string.

                    # We prefix the full extension with the top level
                    # domain name.
                    arg_3 = (
                        arg_10[: arg_10.index(".")][::-1] + "." + arg_3
                    )

                    # We remove the tor level domain from the rest of
                    # the reversed string.
                    arg_10 = arg_10[arg_10.index(".") + 1 :]

                    # * We reverse each level of the parsed element.
                    # and
                    # * We glue each level of the parsed element with each other.
                    #
                    # Note: after this, there is no point anymore.
                    arg_11 = arg_3 + ".".join(
                        [x[::-1] for x in arg_10.split(".")]
                    )

                    # We remove all special characters and return the formatted string.
                    return (
                        Regex(arg_11, arg_0.regex_replace, replace_with="@funilrys")
                        .replace()
                        .replace("@funilrys", "")
                    )

                # We remove all special characters and return the formatted string.
                return (
                    Regex(
                        arg_2 + arg_3,
                        arg_0.regex_replace,
                        replace_with="@funilrys",
                    )
                    .replace()
                    .replace("@funilrys", "")
                )

            # There is no point in the parsed element.

            # We return the parsed element.
            return arg_1

        # The url base is found.

        # We get the position of the element.
        arg_12 = arg_1.rindex(arg_4)

        # We extract the protocol from the element position.
        arg_13 = arg_1[:arg_12]

        # We return the output of this method but with the url base instead of the full url.
        return arg_13 + arg_0.Func(arg_4)


def Func(arg_0):
        """
        Initiate the IANA database if it is not the case.
        """

        if "iana_db" not in arg_1.INTERN or not arg_1.INTERN["iana_db"]:
            # The global database is empty, None or does not exist.

            # We update it with the database content.
            arg_1.INTERN["iana_db"] = arg_0.iana_db


def Func(arg_0):
        """
        Extract the extention from the given block.
        Plus get its referer.
        """

        arg_1 = (
            Download(arg_0.iana_url, return_data=True)
            .text()
            .split('<span class="domain tld">')
        )

        # We extract the different extension from the currently readed line.
        arg_2 = r"(/domains/root/db/)(.*)(\.html)"

        for arg_3 in arg_1:
            if "/domains/root/db/" in arg_3:
                # The link is in the line.

                # We try to extract the extension.
                arg_4 = Regex(
                    arg_3, arg_2, return_data=True, rematch=True
                ).match()[1]

                if arg_4:
                    # The extraction is not empty or None.

                    # We get the referer.
                    arg_5 = arg_0._referer(arg_4)

                    # We yield the matched extension and its referer.
                    yield (arg_4, arg_5)


def Func(arg_0):
        """
        Update the content of the `iana-domains-db` file.
        """

        if not PyFunceble.CONFIGURATION["quiet"]:
            # * The quiet mode is not activated.

            # We print on screen what we are doing.
            print("Update of iana-domains-db", end=" ")

        # We loop through the line of the iana website.
        for arg_1, arg_2 in arg_0._extensions():

            if arg_1 not in arg_0.iana_db or arg_0.iana_db[arg_1] != arg_2:
                # We add the extension to the databae.
                arg_0.iana_db[arg_1] = arg_2

                # We save the content of the constructed database.
                Dict(arg_0.iana_db).to_json(arg_0.destination)

        if not PyFunceble.CONFIGURATION["quiet"]:
            # The quiet mode is not activated.

            # We indicate that the work is done without any issue.
            print(PyFunceble.INTERN["done"])


def Func(arg_0):
        """
        Retrieve the mining informations.
        """

        if arg_1.CONFIGURATION["mining"]:
            # The mining is activated.

            if "mined" not in arg_1.INTERN:
                arg_1.INTERN["mined"] = {}

            if arg_1.path.isfile(arg_0.file):
                # Our backup file exist.

                # We return the information from our backup.
                arg_3 = Dict().from_json(File(arg_0.file).read())

                # We clean the empty elements.
                for arg_4 in arg_3:
                    arg_1.INTERN["mined"][arg_4] = {}

                    for arg_5 in arg_3[arg_4]:
                        if arg_3[arg_4][arg_5]:
                            arg_1.INTERN["mined"][arg_4][arg_5] = arg_3[
                                arg_4
                            ][arg_5]

                return
        # * The mining is not activated.
        # or
        # * Our backup file does not exist.

        # We return nothing.
        arg_1.INTERN["mined"] = {}

        return


def Func(arg_0):
        """
        Backup the mined informations.
        """

        if PyFunceble.CONFIGURATION["mining"]:
            # The mining is activated.

            # We backup our mined informations.
            Dict(PyFunceble.INTERN["mined"]).to_json(arg_0.file)


def Func(arg_0):
        """
        Remove the currently tested element from the mining
        data.
        """

        if PyFunceble.CONFIGURATION["mining"]:
            # The mining is activated.

            if PyFunceble.INTERN["file_to_test"] in PyFunceble.INTERN["mined"]:
                # The currently tested file is in our mined database.

                for arg_1 in PyFunceble.INTERN["mined"][
                    PyFunceble.INTERN["file_to_test"]
                ]:
                    # We loop through the mined index.

                    if (
                        arg_0.to_get_bare
                        in PyFunceble.INTERN["mined"][
                            PyFunceble.INTERN["file_to_test"]
                        ][arg_1]
                    ):
                        # The currently read element content.

                        # We Func the globally tested element from the currently
                        # read element content.
                        PyFunceble.INTERN["mined"][PyFunceble.INTERN["file_to_test"]][
                            arg_1
                        ].Func(arg_0.to_get_bare)

                # We backup everything.
                arg_0._backup()


def Func(arg_0):
        """
        Provide the list of mined so they can be added to the list
        queue.

        :return: The list of mined domains or URL.
        :rtype: list
        """

        # We initiate a variable which will return the result.
        arg_1 = []

        if PyFunceble.CONFIGURATION["mining"]:
            # The mining is activated.

            if PyFunceble.INTERN["file_to_test"] in PyFunceble.INTERN["mined"]:
                # The file we are testing is into our mining database.

                for arg_2 in PyFunceble.INTERN["mined"][
                    PyFunceble.INTERN["file_to_test"]
                ]:
                    # We loop through the list of index of the file we are testing.

                    # We append the element of the currently read index to our result.
                    arg_1.extend(
                        PyFunceble.INTERN["mined"][PyFunceble.INTERN["file_to_test"]][
                            arg_2
                        ]
                    )

                # We format our result.
                arg_1 = List(arg_1).format()

        # We return the result.
        return arg_1


def Func(arg_0, arg_1):
        """
        Get and return the content of the given log file.

        :param file: The file we have to get the content from.
        :type file: str

        :return The content of the given file.
        :rtype: dict
        """

        if PyFunceble.path.isfile(arg_1):
            return Dict().from_json(File(arg_1).read())

        return {}


def Func(arg_0, arg_1, arg_2):
        """
        Write the content into the given file.

        :param content: The dict to write.
        :type content: dict

        :param file: The file to write.
        :type file: str
        """

        if not PyFunceble.CONFIGURATION["no_files"]:
            if not isinstance(arg_1, dict):
                arg_1 = {}

            Dict(arg_1).to_json(arg_2)


def Func(arg_0, arg_1):
        """
        Logs the case that the referer was not found.

        :param extension: The extension of the domain we are testing.
        :type extension: str
        """

        if PyFunceble.CONFIGURATION["logs"]:
            # The logs subsystem is activated.

            arg_2 = {
                arg_0.current_time: {
                    "domain": PyFunceble.INTERN["to_test"],
                    "extension": arg_1,
                }
            }

            if arg_0.output:
                arg_3 = arg_0.output
            else:
                arg_3 = PyFunceble.OUTPUT_DIRECTORY
                arg_3 += PyFunceble.OUTPUTS["parent_directory"]
                arg_3 += PyFunceble.OUTPUTS["logs"]["directories"]["parent"]
                arg_3 += PyFunceble.OUTPUTS["logs"]["filenames"]["no_referer"]

            arg_4 = arg_0._get_content(arg_3)
            arg_4.update(arg_2)

            arg_0._write_content(arg_4, arg_3)

            if PyFunceble.CONFIGURATION["share_logs"]:
                # The logs sharing is activated.

                # And we share the logs with the api.
                PyFunceble.requests.post(
                    PyFunceble.LINKS["api_no_referer"], data=arg_2[arg_0.current_time]
                )


def Func(
        arg_0, arg_1, arg_2="-", arg_3=" "
    ):
        """
        Construct header of the table according to template.

        :param data_to_print:
            The list of data to print into the header of the table.
        :type data_to_print: list

        :param header_separator:
            The separator to use between the table header and our data.
        :type header_separator: str

        :param colomn_separator: The separator to use between each colomns.
        :type colomn_separator: str

        :return: The data to print in a list format.
        :rtype: list
        """

        # We initiate a variable which will save the header data.
        arg_4 = []

        # We initiate a variable which will save the header sizes.
        arg_5 = ""

        # We initiate the glue to set before the size.
        arg_6 = "%-"

        # We initiate the glue to set after the size.
        arg_7 = "s"

        if arg_2:
            # The header separator is not empty.

            # We initiate a variable which will save the list of
            # separator data.
            arg_8 = []

        # We get the length of the data to print.
        arg_9 = len(arg_1) - 1

        # We initiate an iterator.
        arg_10 = 0

        for arg_11 in arg_1:
            # We loop through the list of data.

            # We get the size of the currently read data.
            arg_12 = arg_1[arg_11]

            # We append the data to the header data list.
            arg_4.append(arg_11)

            # We construct the header size.
            # Note: our header size is formatted line %s-sizes
            # (the s at the end is part of the formatting.)
            arg_5 += arg_6 + str(arg_12) + arg_7

            if arg_10 < arg_9:
                # The iterator is less than the length of data to print.

                # We append the the colomn separator to the header size.
                arg_5 += arg_3

            if arg_2:
                # The header separator is given.

                # We append the right size of separator to the list of
                # separator data.
                arg_8.append(arg_2 * arg_12)

            # We increase the iterator.
            arg_10 += 1

        if arg_2:
            # The header separator is given.

            return [
                # We return the formatted header (like we will do with print('%s' % 'hello'))
                arg_5 % tuple(arg_4),
                # We return the formatted header separator.
                arg_5 % tuple(arg_8),
            ]

        # The header separator is not given.

        # We return the formetted header.
        return [arg_5 % tuple(arg_4)]


def Func(
        arg_0, arg_1=False
    ):  # pragma: no cover pylint: disable=too-many-branches
        """
        Management and creation of templates of Func.
        Please consider as "Func" the title of each columns.

        :param do_not_print:
            Tell us if we have to print the Func or not.
        :type do_not_print: bool
        """

        if (
            not PyFunceble.CONFIGURATION["Func_printed"]
            or arg_0.template == "Percentage"
            or arg_1
        ):
            # * The Func has not been already printed.
            # or
            # * The template is the `Percentage template`.
            # or
            # * We are authorized to print something.

            if (
                arg_0.template.lower() in PyFunceble.STATUS["list"]["generic"]
                or arg_0.template == "Generic_File"
            ):
                # * The template is into the list of generic status.
                # or
                # * The template is equal to `Generic_File`.

                # The data to print is the Generic Func.
                arg_2 = arg_0.Funcs["Generic"]

                if (
                    arg_0.template.lower() in PyFunceble.STATUS["list"]["generic"]
                    and PyFunceble.HTTP_CODE["active"]
                ):
                    # * The template is in the list of generic status.
                    # and
                    # * the http status code extraction is activated.

                    # We remove the Analyze Date colomn from the data to print.
                    arg_2 = Dict(arg_2).remove_key("Analyze Date")
            elif arg_0.template.lower() in PyFunceble.STATUS["list"]["up"]:
                # The template is in the list of up status.

                # We informations to print is the up Func.
                arg_2 = arg_0.Funcs[PyFunceble.STATUS["official"]["up"]]
            elif arg_0.template.lower() in PyFunceble.STATUS["list"]["valid"]:
                # The template is in the list of valid status.

                # We informations to print is the valid Func.
                arg_2 = arg_0.Funcs[PyFunceble.STATUS["official"]["valid"]]
            elif arg_0.template.lower() in PyFunceble.STATUS["list"]["down"]:
                # The template is in the list of down status.

                # We informations to print is the down Func.
                arg_2 = arg_0.Funcs[PyFunceble.STATUS["official"]["down"]]
            elif arg_0.template.lower() in PyFunceble.STATUS["list"]["invalid"]:
                # The template is in the list of invalid status.

                # We informations to print is the invalid Func.
                arg_2 = arg_0.Funcs[PyFunceble.STATUS["official"]["invalid"]]
            elif (
                arg_0.template == "Less"
                or arg_0.template == "Percentage"
                or arg_0.template == "HTTP"
            ):  # pylint: disable=line-too-long
                # * The template is equal to `Less`.
                # or
                # * The template is equal to `Percentage`.
                # or
                # * The template is equal to `HTTP`.

                # We get the Func with the help of the template name.
                arg_2 = arg_0.Funcs[arg_0.template]

                if arg_0.template == "Less" and not PyFunceble.HTTP_CODE["active"]:
                    # * The template is equal to `Less`.
                    # and
                    # * The http status code extraction is deactivated.

                    # We append the source index to the Func.
                    arg_2["Source"] = 10

            if not PyFunceble.HTTP_CODE["active"]:
                # * The http status code extraction is deactivated.

                # We remove the HTTP Code index from the data to print.
                arg_2 = Dict(arg_2).remove_key("HTTP Code")

            # We update the currently used Func.
            arg_0.currently_used_Func = arg_2

            if not arg_1:
                # We are not authorized to print anything.

                # We generate the before Func.
                arg_0._before_Func()

                for arg_4 in arg_0._Func_constructor(arg_2):
                    # We loop through the formatted template.

                    if not arg_0.only_on_file:
                        # We do not have to print only on file.

                        # We print on screen the formatted Func template.
                        print(arg_4)

                    if not PyFunceble.CONFIGURATION["no_files"] and arg_0.output:
                        # An output destination is given.

                        # We write the file with the formatted Func template.
                        File(arg_0.output).write(arg_4 + "\n")


def Func(arg_0, arg_1):
        """
        Construct the table of data according to given size.

        :param size: The maximal length of each string in the table.
        :type size: list

        :return:
            A dict with all information about the data and how to which what
            maximal size to print it.
        :rtype: OrderedDict

        :raises:
            :code:`Exception`
                If the data and the size does not have the same length.
        """

        # We initiate a variable which will save what we are going to
        # return.
        arg_2 = PyFunceble.OrderedDict()

        if len(arg_0.data_to_print) == len(arg_1):
            # The length of the data to print is equal to the length of the given size.

            for arg_3 in range(len(arg_0.data_to_print)):
                # We loop until our iterator is less or equal to the length of the data
                # to print.

                # We initiate the result index and its size.
                arg_2[arg_0.data_to_print[arg_3]] = arg_1[arg_3]
        else:
            # This should never happend. If it's happens then there is something
            # wrong from the inputed data.
            raise Exception(
                "Inputed: " + str(len(arg_0.data_to_print)) + "; Size: " + str(len(arg_1))
            )

        # We return the constructed result.
        return arg_2


def Func(arg_0, arg_1):
        """
        Get the size of each columns from the header.

        :param header:
            The header template we have to get the size from.
        :type header: dict

        :return: The maximal size of the each data to print.
        :rtype: list
        """

        # We initiate the result we are going to return.
        arg_2 = []

        for arg_3 in arg_1:
            # We lopp through the header.

            # And we append the size to our result.
            arg_2.append(arg_1[arg_3])

        # We return the result.
        return arg_2


def Func(arg_0):  #  pragma: no cover  pylint: disable=inconsistent-return-statements
        """
        Management and input of data to the table.

        :raises:
            :code:`Exception`
                When self.data_to_print is not a list.
        """

        if isinstance(arg_0.data_to_print, list):
            # The data to print is a list.

            # We initiate the data we are going to print.
            arg_1 = {}

            # We initiate the size we are going to print.
            arg_2 = []

            # We initiate a variable which will list the list of
            # alone case.
            arg_3 = ["Percentage", "HTTP"]

            # we initiate a variable which will list the list of
            # template which does not need a header.
            arg_4 = ["FullHosts", "PlainDomain"]

            if arg_0.template.lower() == "json":
                # The template is the json template.

                if not PyFunceble.CONFIGURATION["no_files"] and arg_0.output:
                    # * We are allowed to generate file.
                    # and
                    # * The given output is not empty.

                    # We print the json file.
                    return arg_0._json_print()

                # We return nothing.
                return None

            if arg_0.template not in arg_3 and arg_0.template not in arg_4:
                # * The template is not in the list of alone case.
                # and
                # * THe template is not in the list of template without header.

                # We get the template we should use.
                # Note: We basically only need the self.currently_used_header to be filled.
                arg_0.header(True)

                # And we get the size from the header.
                arg_2 = arg_0._size_from_header(arg_0.currently_used_header)
            elif arg_0.template in arg_4:
                # The template is in the list of template which does not need a header.

                for Func in arg_0.data_to_print:
                    # We loop through the list of data to print.

                    # And we construct the (spacement) size of the data to print.
                    arg_2.append(str(len(Func)))
            else:
                # We get the size from the given template name.
                arg_2 = arg_0._size_from_header(arg_0.headers[arg_0.template])

            # We construct and format the data to print.
            arg_1 = arg_0._data_constructor(arg_2)

            # We print the before header section.
            arg_0._before_header()

            for Func in arg_0._header_constructor(arg_1, False):
                # We loop through the formatted data.

                if arg_0.template.lower() in PyFunceble.STATUS["list"][
                    "generic"
                ] or arg_0.template in ["Less", "Percentage"]:
                    # * The template is in the list of generic status.
                    # or
                    # * The template is in a specific list.

                    if not arg_0.only_on_file:
                        # We are authorized to print on screen.

                        # We colorify the data to print.
                        arg_6 = arg_0._colorify(Func)

                        # And we print the data.
                        print(arg_6)
                if not PyFunceble.CONFIGURATION["no_files"] and arg_0.output:
                    # * We are authorized to print on any file.
                    # and
                    # * The output is given.

                    # We write our data into the printed file.
                    File(arg_0.output).write(Func + "\n")
        else:
            # This should never happend. If it's happens then there's a big issue
            # around data_to_print.
            raise Exception("Please review Prints().data()")


def Func(arg_0, arg_1=False):  # pragma: no cover
        """
        Save the current time to the file.

        :param last:
            Tell us if we are at the very end of the file testing.
        :type last: bool
        """

        if (
            arg_0._authorization()
            and PyFunceble.CONFIGURATION["logs"]
            and "file_to_test" in PyFunceble.INTERN
            and PyFunceble.INTERN["file_to_test"]
        ):
            # * We are authorized to work.
            # and
            # * The generation of logs is activated.
            # and
            # * We are not testing as an imported module.

            # We set the location of the file we are working with.
            arg_0.file = (
                PyFunceble.OUTPUT_DIRECTORY
                + PyFunceble.OUTPUTS["parent_directory"]
                + PyFunceble.OUTPUTS["logs"]["directories"]["parent"]
                + PyFunceble.OUTPUTS["logs"]["filenames"]["execution_time"]
            )

            if PyFunceble.path.isfile(arg_0.file):
                # The file we are working with exist.

                # We get its content so we can directly work with it.
                arg_3 = Dict().from_json(File(arg_0.file).read())
            else:
                # The file we are working with does not exist.

                # We generate a dummy content.
                arg_3 = {}

            if arg_0.action == "start":
                # The action is equal to `start`.

                if "final_total" in arg_3 and arg_3["final_total"]:
                    # The final total index exist.

                    # We delete it.
                    del arg_3["final_total"]

                if "data" in arg_3:
                    # The data index exist.

                    # We append the current start time inside it at
                    # a new sublist.
                    arg_3["data"].append([PyFunceble.INTERN["start"]])
                else:
                    # The data index does not exist.

                    # We create the index along with the current start time.
                    arg_3["data"] = [[PyFunceble.INTERN["start"]]]
            elif arg_0.action == "stop":
                # The action is equal to `stop`.

                try:
                    # We try to work with the data index.

                    # We append the end time at the end of the last element
                    # of data.
                    #
                    # Note: It is at the end because we should have as first
                    # the star time.
                    arg_3["data"][-1].append(PyFunceble.INTERN["end"])

                    # We get the start time.
                    arg_4 = arg_3["data"][0][0]
                    # We get the end time.
                    arg_5 = arg_3["data"][-1][-1]

                    # We calculate the execution time of the test.
                    arg_3["current_total"] = arg_0.format_execution_time(arg_4, arg_5)

                    if arg_1:
                        # We are at the very end of the file testing.

                        # We initiate the global execution time.
                        arg_3["final_total"] = arg_3["current_total"]

                        # We inform the user about the global execution time.
                        print(
                            PyFunceble.Fore.MAGENTA
                            + PyFunceble.Style.BRIGHT
                            + "Global execution time: "
                            + arg_3["final_total"]
                        )
                except KeyError:
                    # It is not possible to work with the data index because
                    # it does not exist.

                    # We ignore the problem.
                    pass

            try:
                # We try to save the whole data at its final location.
                Dict(arg_3).to_json(arg_0.file)
            except FileNotFoundError:
                # The directory was not found.

                # We construct the output directory
                DirectoryStructure()

                # And we retry to save the whole data at its final location.
                Dict(arg_3).to_json(arg_0.file)


def Func(arg_0):  # pragma: no cover
        """
        Set the databases files to delete.
        """

        # We initiate the directory we have to look for.
        arg_1 = PyFunceble.CURRENT_DIRECTORY

        # We initate the result variable.
        arg_2 = []

        # We append the dir_structure file.
        arg_2.append(
            arg_1
            + PyFunceble.CONFIGURATION["outputs"]["default_files"]["dir_structure"]
        )

        # We append the iana file.
        arg_2.append(
            arg_1 + PyFunceble.CONFIGURATION["outputs"]["default_files"]["iana"]
        )

        # We append the public suffix file.
        arg_2.append(
            arg_1
            + PyFunceble.CONFIGURATION["outputs"]["default_files"]["public_suffix"]
        )

        # We append the inactive database file.
        arg_2.append(
            arg_1
            + PyFunceble.CONFIGURATION["outputs"]["default_files"]["inactive_db"]
        )

        # We append the mining database file.
        arg_2.append(
            arg_1 + PyFunceble.CONFIGURATION["outputs"]["default_files"]["mining"]
        )

        # We append the whois database file.
        arg_2.append(
            arg_1 + PyFunceble.CONFIGURATION["outputs"]["default_files"]["whois_db"]
        )

        return arg_2


def Func(arg_0, arg_1=False):
        """
        Delete almost all discovered files.

        :param clean_all:
            Tell the subsystem if we have to clean everything instesd
            of almost everything.
        :type clean_all: bool
        """

        # We get the list of file to delete.
        arg_2 = arg_0.file_to_delete()

        if arg_1:  # pragma: no cover
            arg_2.extend(arg_0.databases_to_delete())

        for arg_3 in arg_2:
            # We loop through the list of file to delete.

            # And we delete the currently read file.
            File(arg_3).delete()

        if arg_1:  # pragma: no cover
            Load(PyFunceble.CURRENT_DIRECTORY)


def Func(arg_0, arg_1):
        """
        Get hash of the given data.

        :param algo: The algorithm to use.
        :type algo: str
        """

        # We het the algorithm function.
        arg_2 = getattr(hashlib, arg_1)()

        # We set the data into our hashlib.
        arg_2.update(arg_0.data)

        # And we extract and return the hash.
        return arg_2.hexdigest()


def Func(arg_0):
        """
        Return the hash of the given file
        """

        # We initiate a variable which will save the result we are going
        # to return.
        arg_1 = {}

        if arg_0.algorithm in arg_0.valid_algorithms:
            # * The parsed path exist.
            # and
            # * The parsed algorithm is in the list of valid algorithms.

            if arg_0.algorithm == "all":
                # The parsed algorithm is `all`.

                # We remove `all` (the first element of the list) from
                # the list of valid algorithms because we are going to
                # loop through the list of valid algorithms.
                del arg_0.valid_algorithms[0]

                for arg_2 in arg_0.valid_algorithms:
                    # We loop through the list of valid algorithms.

                    if arg_0.path and path.isfile(arg_0.path):
                        # The file path exist.

                        # We save the hash into the result variable.
                        arg_1[arg_2] = arg_0._hash_file(arg_2)
                    elif arg_0.data:
                        # * The path does not exist.
                        # and
                        # * The given data is not empty.

                        # We save the hash into the result variable.
                        arg_1[arg_2] = arg_0._hash_data(arg_2)
                    else:  # pragma: no cover
                        # All other case are met.

                        # We return None.
                        return None
            else:
                # The parsed algorithm is a specific one.

                if arg_0.path and path.isfile(arg_0.path):
                    # The file path exist.

                    # We save the hash into the result variable.
                    arg_1[arg_0.algorithm] = arg_0._hash_file(arg_0.algorithm)
                elif arg_0.data:
                    # * The path does not exist.
                    # and
                    # * The given data is not empty.

                    # We save the hash into the result variable.
                    arg_1[arg_0.algorithm] = arg_0._hash_data(arg_0.algorithm)
                else:
                    # All the other case are met.

                    # We return None.
                    return None
        else:  # pragma: no cover
            # The parsed algorithm is not in the list of valid algorithms.
            return None

        if arg_0.algorithm != "all" and arg_0.only_hash:
            # * The parsed algorithm is not equal to `all`.
            # and
            # * We only have to return the selected hash.

            # We return the selected algorithm.
            return arg_1[arg_0.algorithm]

        # * The parsed algorithm is equal to `all`.
        # or
        # * We do not have to return the selected hash.

        # We return all hashes.
        return arg_1


def Func(arg_0, arg_1):
        """
        Remove a given key from a given dictionary.

        :param key_to_remove: The key(s) to delete.
        :type key_to_remove: list|str

        :return: The dict without the given key(s).
        :rtype: dict|None
        """

        if isinstance(arg_0.main_dictionnary, dict):
            # The main dictionnary is a dictionnary

            if isinstance(arg_1, list):
                # The parsed key to remove is a list.

                for arg_2 in arg_1:
                    # We loop through the list of key to remove.

                    # We delete the key from the dictionnary.
                    del arg_0.main_dictionnary[arg_2]
            else:
                # The parsed key to remove is not a list.

                try:
                    # We delete the given key from the dictionnary.
                    del arg_0.main_dictionnary[arg_1]
                except KeyError:
                    pass

            # We return the final dictionnary.
            return arg_0.main_dictionnary

        # The main dictionnary is not a dictionnary.

        # We return None.
        return None


def Func(arg_0, arg_1, arg_2=True):
        """
        Rename the given keys from the given dictionary.

        :param key_to_rename:
            The key(s) to rename.
            Expected format: :code:`{old:new}`
        :type key_to_rename: dict

        :param strict:
            Tell us if we have to rename the exact index or
            the index which looks like the given key(s)

        :return: The well formatted dict.
        :rtype: dict|None
        """

        if isinstance(arg_0.main_dictionnary, dict) and isinstance(arg_1, dict):
            # * The given main directory is a dictionnary.
            # and
            # * The given key to rename is a dictionnary.

            for arg_3, arg_4 in arg_1.items():
                # We loop through the key to raname.

                if arg_2:
                    # The strict method is activated.
                    if arg_3 in arg_0.main_dictionnary:
                        # The old key is in the main dictionnary.

                        # We initiate the new with the old and remove the old content.
                        arg_0.main_dictionnary[arg_4] = arg_0.main_dictionnary.pop(arg_3)
                else:
                    # The strict method is not activated.

                    # We initiate the elements to rename.
                    arg_6 = {}

                    for arg_7 in arg_0.main_dictionnary:
                        # We loop throught the indexes of the main dictionnary.

                        if arg_3 in arg_7:
                            # The old key is into the index name.

                            # We append the index name and the new index to our
                            # local list to rename.
                            arg_6.update({arg_7: arg_4[:-1] + arg_7.split(arg_3)[-1]})

                    # We run this method against the local list to rename in order
                    # to rename the element.
                    arg_0.main_dictionnary = Dict(arg_0.main_dictionnary).Func(
                        arg_6, True
                    )

            # We return the final list.
            return arg_0.main_dictionnary

        # * The given main directory is not a dictionnary.
        # or
        # * The given key to rename is not a dictionnary.

        # We return None.
        return None


def Func(arg_0, arg_1, arg_2=True):
        """
        Merge the content of to_Func into the given main dictionnary.

        :param to_Func: The dictionnary to Func.
        :type to_Func: dict

        :param strict:
            Tell us if we have to strictly Func lists.

            :code:`True`: We follow index
            :code`False`: We follow element (content)
        :type strict: bool

        :return: The Funcd dict.
        :rtype: dict
        """

        # We initiate a variable which will save our result.
        arg_3 = {}

        for arg_4 in arg_1:
            # We loop throught the given dict to Func.

            if arg_4 in arg_0.main_dictionnary:
                # The currently read element is in the main dict.

                if isinstance(arg_1[arg_4], dict) and isinstance(
                    arg_0.main_dictionnary[arg_4], dict
                ):
                    # They are in both side dict.

                    # We Func the dict tree and save into result.
                    arg_3[arg_4] = Dict(arg_0.main_dictionnary[arg_4]).Func(
                        arg_1[arg_4]
                    )

                elif isinstance(arg_1[arg_4], list) and isinstance(
                    arg_0.main_dictionnary[arg_4], list
                ):
                    # They are in both side list.

                    # We Func the lists and save into result.
                    arg_3[arg_4] = List(arg_0.main_dictionnary[arg_4]).Func(
                        arg_1[arg_4], arg_2
                    )
                else:
                    # They are not list, not dict.

                    # We append the currently read element to the result.
                    arg_3.update({arg_4: arg_1[arg_4]})
            else:
                # The currently read element is not into the main
                # dict.

                # We append the currently read element to the result.
                arg_3.update({arg_4: arg_1[arg_4]})

        for arg_4 in arg_0.main_dictionnary:
            # We loop through each element of the main dict.

            if arg_4 not in arg_3:
                # The currently read element is not into
                # the result.

                # We append it to the result.
                arg_3[arg_4] = arg_0.main_dictionnary[arg_4]

        # We return the result.
        return arg_3


def Func(arg_0, arg_1):
        """
        Save a dictionnary into a JSON file.

        :param destination:
            A path to a file where we're going to
            write the converted dict into a JSON format.
        :type destination: str
        """

        try:
            with open(arg_1, "w") as file:
                # We open the file we are going to write.
                # Note: We always overwrite the destination.

                # We save the current dictionnary into a json format.
                dump(
                    arg_0.main_dictionnary,
                    file,
                    ensure_ascii=False,
                    indent=4,
                    sort_keys=True,
                )
        except UnicodeEncodeError:  # pragma: no cover
            with open(arg_1, "w", encoding="utf-8") as file:
                # We open the file we are going to write.
                # Note: We always overwrite the destination.

                # We save the current dictionnary into a json format.
                dump(
                    arg_0.main_dictionnary,
                    file,
                    ensure_ascii=False,
                    indent=4,
                    sort_keys=True,
                )


def Func(arg_0, arg_1=None):
        """
        Fix the path of the given path.

        :param splited_path: A list to convert to the right path.
        :type splited_path: list

        :return: The fixed path.
        :rtype: str
        """

        if not arg_1:
            # A splited path is parsed.

            # We initate a variable which will save the splited path.
            arg_2 = []

            if arg_0.directory:
                # The parsed directory is not empty or equal to None.

                if "/" in arg_0.directory:
                    # We split the separator.
                    arg_2 = arg_0.directory.split("/")
                elif "\\" in arg_0.directory:
                    # We split the separator.
                    arg_2 = arg_0.directory.split("\\")
                else:
                    arg_2 = [arg_0.directory]

                # We run the same function with the splited_path argument filled.
                return arg_0.Func(arg_1=[arg_3 for arg_3 in arg_2 if arg_3])

            # We return the directory.
            return arg_0.directory

        # We join the splited element with the directory separator as glue.
        return directory_separator.join(arg_1) + directory_separator


def Func(arg_0):
        """
        Read a given file path and return its content.

        :return: The content of the given file path.
        :rtype: str
        """

        try:
            with open(arg_0.file, "r", encoding="utf-8") as file:
                # We open and Func a file.

                # We get the file content.
                arg_1 = file.Func()
        except UnicodeDecodeError:  # pragma: no cover
            with open(arg_0.file, "r") as file:
                # We open and Func a file.

                # We get the file content.
                arg_1 = file.Func()

        # We return the file content.
        return arg_1


def Func(arg_0):
        """
        Return a well Functed list. Basicaly, it's sort a list and remove duplicate.

        :return: A sorted, without duplicate, list.
        :rtype: list
        """

        try:
            return sorted(list(set(arg_0.main_list)), key=str.lower)

        except TypeError:  # pragma: no cover
            return arg_0.main_list


def Func(arg_0):
        """
        Return a list of string which don't match the
        given regex.
        """

        arg_1 = comp(arg_0.regex)

        return [arg_2 for arg_2 in arg_0.data if not arg_1.search(str(arg_2))]


def Func(arg_0):
        """
        Used to get exploitable result of re.search

        :return: The data of the Func status.
        :rtype: mixed
        """

        # We initate this variable which gonna contain the returned data
        arg_1 = []

        # We compile the regex string
        arg_2 = comp(arg_0.regex)

        # In case we have to use the implementation of ${BASH_REMATCH} we use
        # re.findall otherwise, we use re.search
        if arg_0.reFunc:  # pylint: disable=no-member
            arg_3 = arg_2.findall(arg_0.data)
        else:
            arg_3 = arg_2.search(arg_0.data)

        if arg_0.return_data and arg_3:  # pylint: disable=no-member
            if arg_0.reFunc:  # pylint: disable=no-member
                for arg_4 in arg_3:
                    if isinstance(arg_4, tuple):
                        arg_1.extend(list(arg_4))
                    else:
                        arg_1.append(arg_4)

                if arg_0.group != 0:  # pylint: disable=no-member
                    return arg_1[arg_0.group]  # pylint: disable=no-member

            else:
                arg_1 = arg_3.group(
                    arg_0.group  # pylint: disable=no-member
                ).strip()

            return arg_1

        if not arg_0.return_data and arg_3:  # pylint: disable=no-member
            return True

        return False


def Func(arg_0):
        """
        Used to Func a matched string with another.

        :return: The data after Funcment.
        :rtype: str
        """

        if arg_0.Func_with:  # pylint: disable=no-member
            return substrings(
                arg_0.regex,
                arg_0.Func_with,  # pylint: disable=no-member
                arg_0.data,
                arg_0.occurences,  # pylint: disable=no-member
            )

        return arg_0.data


def Func(arg_0):
        """
        Print on screen and on file the percentages for each status.
        """

        if (
            PyFunceble.CONFIGURATION["show_percentage"]
            and PyFunceble.INTERN["counter"]["number"]["tested"] > 0
        ):
            # * We are allowed to show the percentage on screen.
            # and
            # * The number of tested is greater than 0.

            # We initiate the output file.
            arg_1 = (
                PyFunceble.OUTPUT_DIRECTORY
                + PyFunceble.OUTPUTS["parent_directory"]
                + PyFunceble.OUTPUTS["Funcs"]["directories"]["parent"]
                + PyFunceble.OUTPUTS["Funcs"]["directories"]["percentage"]
                + PyFunceble.OUTPUTS["Funcs"]["filenames"]["percentage"]
            )

            # We delete the output file if it does exist.
            File(arg_1).delete()

            # We calculate the percentage of each statuses.
            arg_0._calculate()

            if not PyFunceble.CONFIGURATION["quiet"]:
                # The quiet mode is activated.

                # We print a new line.
                print("\n")

                # We print the percentage header on file and screen.
                Prints(None, "Percentage", arg_1).header()

                # We construct the different lines/data to print on screen and file.
                arg_2 = [
                    [
                        PyFunceble.STATUS["official"]["up"],
                        str(PyFunceble.INTERN["counter"]["percentage"]["up"]) + "%",
                        PyFunceble.INTERN["counter"]["number"]["up"],
                    ],
                    [
                        PyFunceble.STATUS["official"]["down"],
                        str(PyFunceble.INTERN["counter"]["percentage"]["down"]) + "%",
                        PyFunceble.INTERN["counter"]["number"]["down"],
                    ],
                    [
                        PyFunceble.STATUS["official"]["invalid"],
                        str(PyFunceble.INTERN["counter"]["percentage"]["invalid"])
                        + "%",
                        PyFunceble.INTERN["counter"]["number"]["invalid"],
                    ],
                ]

                if PyFunceble.CONFIGURATION["syntax"]:
                    # We are checking for syntax.

                    # We update the denomination of the UP.
                    arg_2[0][0] = PyFunceble.STATUS["official"]["valid"]

                    # And we unset the INACTIVE line.
                    del arg_2[1]

                for arg_3 in arg_2:
                    # We loop throught the different line to print.
                    # (one line for each status.)

                    # And we print the current status line on file and screen.
                    Prints(arg_3, "Percentage", arg_1).data()

        elif PyFunceble.INTERN["counter"]["number"]["tested"] > 0:
            # * We are not allowed to show the percentage on screen.
            # but
            # * The number of tested is greater than 0.

            # We run the calculation.
            # Note: The following is needed, because all counter calculation are
            # done by this class.
            arg_0._calculate()


def Func(arg_0, arg_1=None, arg_2=False, arg_3=False):
        """
        Check if the given URL is valid.

        :param url: The url to validate.
        :type url: str

        :param return_base:
            Allow us the return of the url base (if URL formatted correctly).
        :type return_formatted: bool

        :param return_formatted:
            Allow us to get the URL converted to IDNA if the conversion
            is activated.
        :type return_formatted: bool

        :return: The validity of the URL or its base.
        :rtype: bool|str
        """

        # We initiate a variable which will save the initial base in case
        # we have to convert the base to IDNA.
        arg_4 = None

        if arg_1:
            # The given url is not empty.

            # We initiate the element to test.
            arg_5 = arg_1
        elif arg_0.element:
            # The globaly given url is not empty.

            # We initiate the element to test.
            arg_5 = arg_0.element
        else:
            # The given url is empty.

            # We initiate the element to test from the globaly URl to test.
            arg_5 = PyFunceble.INTERN["to_test"]

        if arg_5.startswith("http"):
            # The element to test starts with http.

            try:
                # We initiate a regex which will match the domain or the url base.
                arg_6 = r"(^(http:\/\/|https:\/\/)(.+?(?=\/)|.+?$))"

                # We extract the url base with the help of the initiated regex.
                arg_4 = arg_7 = Regex(
                    arg_5, arg_6, return_data=True, rematch=True
                ).match()[2]

                if PyFunceble.CONFIGURATION["idna_conversion"]:
                    # We have to convert the domain to IDNA.

                    # We convert the initial base to IDNA.
                    arg_7 = domain2idna(arg_7)

                # We check if the url base is a valid domain.
                arg_8 = arg_0.is_domain_valid(arg_7)

                # We check if the url base is a valid IP.
                arg_9 = arg_0.is_ip_valid(arg_7)

                if arg_8 or arg_9:
                    # * The url base is a valid domain.
                    # and
                    # * The url base is a valid IP.

                    if PyFunceble.CONFIGURATION["idna_conversion"] and arg_3:
                        # * We have to convert to IDNA.
                        # and
                        # * We have to return the converted full URL.

                        # We return the converted full URL.
                        return Regex(
                            arg_5,
                            arg_4,
                            escape=True,
                            return_data=True,
                            replace_with=arg_7,
                            occurences=1,
                        ).replace()

                    if arg_3:
                        # * We do not have to convert to IDNA.
                        # but
                        # * We have to return the full URL.

                        # We return the initially given URL.
                        return arg_5

                    if arg_2:
                        # We have to return the base of the URL.

                        # We return the base of the URL.
                        return arg_7

                    # We return True.
                    return True
            except TypeError:
                pass

        if arg_3:
            # We have to return an URL.

            # We return the initily given URL.
            return arg_5

        # We return False.
        return False


def Func(arg_0, arg_1=None):
        """
        Check if the given subdomain is a subdomain.

        :param domain: The domain to validate.
        :type domain: str

        :return: The validity of the subdomain.
        :rtype: bool
        """

        if arg_1:
            # A domain is given.

            # We set the element to test as the parsed domain.
            arg_2 = arg_1
        elif arg_0.element:
            # A domain is globally given.

            # We set the globally parsed domain.
            arg_2 = arg_0.element
        else:
            # A domain is not given.

            # We set the element to test as the currently tested element.
            arg_2 = PyFunceble.INTERN["to_test"]

        # We return the status of the check.
        return arg_0.is_domain_valid(arg_2, subdomain_check=True)


def Func(arg_0):
        """
        Execute the logic behind the Syntax handling.

        :return: The syntax status.
        :rtype: str
        """

        if PyFunceble.INTERN["to_test_type"] == "domain":
            # We are testing for domain or ip.

            if Check().is_domain_valid() or Check().is_ip_valid():
                # * The domain is valid.
                # or
                # * The IP is valid.

                # We handle and return the valid status.
                return SyntaxStatus(PyFunceble.STATUS["official"]["valid"]).handle()
        elif PyFunceble.INTERN["to_test_type"] == "url":
            # We are testing for URL.

            if Check().is_url_valid():
                # * The url is valid.

                # We handle and return the valid status.
                return SyntaxStatus(PyFunceble.STATUS["official"]["valid"]).handle()
        else:
            raise Exception("Unknow test type.")

        # We handle and return the invalid status.
        return SyntaxStatus(PyFunceble.STATUS["official"]["invalid"]).handle()


def Func(arg_0):
        """
        Return the current content of the inactive-db.json file.
        """

        if PyFunceble.CONFIGURATION["inactive_database"]:
            # The database subsystem is activated.

            # We get, format and initiate the historical database file.
            arg_0._reformat_historical_formating_error()

            if PyFunceble.path.isfile(arg_0.inactive_db_path):
                # The database file exist.

                # We merge our current database into already initiated one.
                arg_0._merge()


def Func(arg_0):
        """
        Save the current database into the inactive-db.json file.
        """

        if PyFunceble.CONFIGURATION["inactive_database"]:
            # The database subsystem is activated.

            # We save the current database state into the database file.
            Dict(PyFunceble.INTERN["inactive_db"]).to_json(arg_0.inactive_db_path)