atomicshop 2.11.47__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/wrappers/elasticsearchw/infrastructure.py

@@ -1,265 +0,0 @@
-import sys
-import time
-import requests
-
-from ...print_api import print_api
-from ... import filesystem
-from .. import ubuntu_terminal
-from . import config_basic
-
-
-def is_elastic_service_running():
-    return ubuntu_terminal.is_service_running(config_basic.UBUNTU_ELASTIC_SERVICE_NAME, return_false_on_error=False)
-
-
-def enable_elastic_service():
-    ubuntu_terminal.enable_service(config_basic.UBUNTU_ELASTIC_SERVICE_NAME, sudo=True)
-
-
-def start_elastic_service():
-    ubuntu_terminal.start_service(config_basic.UBUNTU_ELASTIC_SERVICE_NAME, sudo=True)
-
-
-def is_kibana_service_running():
-    return ubuntu_terminal.is_service_running(config_basic.UBUNTU_KIBANA_SERVICE_NAME, return_false_on_error=False)
-
-
-def enable_kibana_service():
-    ubuntu_terminal.enable_service(config_basic.UBUNTU_KIBANA_SERVICE_NAME, sudo=True)
-
-
-def start_kibana_service():
-    ubuntu_terminal.start_service(config_basic.UBUNTU_KIBANA_SERVICE_NAME, sudo=True)
-
-
-def start_elastic_and_check_service_availability(wait_time_seconds: float = 30, exit_on_error: bool = True):
-    """
-    Function starts the Elasticsearch service and checks its availability.
-    :param wait_time_seconds: float, the time to wait after starting the service before checking
-        the service availability.
-    :param exit_on_error: bool, if True, the function will exit the program if the service is not available.
-    :return:
-    """
-
-    # Start, enable and check the Elasticsearch service.
-    ubuntu_terminal.start_enable_service_check_availability(
-        service_name=config_basic.UBUNTU_ELASTIC_SERVICE_NAME,
-        wait_time_seconds=wait_time_seconds,
-        exit_on_error=exit_on_error
-    )
-
-    # Check if Elasticsearch is running.
-    if not is_server_available():
-        if exit_on_error:
-            sys.exit(1)
-
-
-def start_kibana_and_check_service_availability(wait_time_seconds: float = 30, exit_on_error: bool = True):
-    """
-    Function starts the Kibana service and checks its availability.
-    :param wait_time_seconds: float, the time to wait after starting the service before checking
-        the service availability.
-    :param exit_on_error: bool, if True, the function will exit the program if the service is not available.
-    :return:
-    """
-
-    # Start, enable and check the Elasticsearch service.
-    ubuntu_terminal.start_enable_service_check_availability(
-        service_name=config_basic.UBUNTU_KIBANA_SERVICE_NAME,
-        wait_time_seconds=wait_time_seconds,
-        exit_on_error=exit_on_error
-    )
-
-
-def is_elastic_config_file_exists(
-        config_file_path: str = None,
-        exit_on_error: bool = False,
-        output_message: bool = False
-) -> bool:
-    """
-    The function checks if the Elasticsearch configuration file exists.
-
-    :param config_file_path: str, the path to the configuration file.
-    :param exit_on_error: bool, if True, the function will exit the program if the file does not exist.
-    :param output_message: bool, if True, the function will print a message if the file does not exist.
-    :return:
-    """
-
-    if not config_file_path:
-        config_file_path = config_basic.ELASTIC_CONFIG_FILE
-
-    # if not ubuntu_terminal.is_sudo_file_exists(config_file_path):
-    if not filesystem.check_file_existence(config_file_path):
-        if output_message:
-            message = f"Configuration file does not exist at {config_file_path}."
-            print_api(message, color='red', error_type=True)
-        if exit_on_error:
-            sys.exit(1)
-        return False
-    else:
-        return True
-
-
-def check_xpack_security_setting(config_file_path: str = None):
-    """
-    The function checks if the 'xpack.security.enabled' setting is set to 'false' in the Elasticsearch
-    configuration file.
-
-    :param config_file_path:
-    :return:
-    """
-
-    if not config_file_path:
-        config_file_path = config_basic.ELASTIC_CONFIG_FILE
-
-    with open(config_file_path, 'r') as file:
-        # Read the file contents
-        contents = file.read()
-        # Check if the specific setting exists
-        if f"{config_basic.XPACK_SECURITY_SETTING_NAME}: false" in contents:
-            return False
-        elif f"{config_basic.XPACK_SECURITY_SETTING_NAME}: true" in contents:
-            return True
-        # If the setting doesn't exist, return None.
-        else:
-            return None
-
-
-def modify_xpack_security_setting(
-        config_file_path: str = None,
-        setting: bool = False,
-        output_message: bool = True
-):
-    """
-    The function modifies the 'xpack.security.enabled' setting in the Elasticsearch configuration file.
-    :param config_file_path: str, the path to the configuration file.
-    :param setting: bool, the setting to change to. Will be added, if doesn't exist.
-    :param output_message: bool, if True, the function will print a message.
-    :return:
-    """
-
-    if not config_file_path:
-        config_file_path = config_basic.ELASTIC_CONFIG_FILE
-
-    # The setting to set in the configuration file.
-    xpack_setting_to_set: str = f'{config_basic.XPACK_SECURITY_SETTING_NAME}: {str(setting).lower()}'
-
-    # Check if the setting exists in the configuration file and get its value.
-    current_xpack_security_setting = check_xpack_security_setting(config_file_path)
-
-    # If the setting doesn't exist, add it to the configuration file.
-    if current_xpack_security_setting is None:
-        with open(config_file_path, 'a') as file:
-            file.write(f'{xpack_setting_to_set}\n')
-        if output_message:
-            print_api(f"Added [{xpack_setting_to_set}] to the configuration.")
-    # If the setting exists and is different from the desired setting, change it.
-    elif current_xpack_security_setting != setting:
-        with open(config_file_path, 'r') as file:
-            lines = file.readlines()
-        with open(config_file_path, 'w') as file:
-            for line in lines:
-                if f"{config_basic.XPACK_SECURITY_SETTING_NAME}:" in line:
-                    file.write(f'{xpack_setting_to_set}\n')
-                else:
-                    file.write(line)
-        if output_message:
-            print_api(f"Changed [{config_basic.XPACK_SECURITY_SETTING_NAME}] to [{setting}].")
-    # If the setting is already set to the desired value, print a message.
-    elif current_xpack_security_setting == setting:
-        if output_message:
-            print_api(f"The setting is already set to [{setting}].")
-
-
-def create_jvm_options_custom_file(file_path: str, options: list):
-    """
-    The function creates a custom JVM options file for Elasticsearch.
-    You can use the default directory path as 'config_basic.ELASTIC_JVM_OPTIONS_DIRECTORY'.
-    :param file_path: str, the path to the custom JVM options file.
-    :param options: list, the list of JVM options.
-    :return:
-    """
-
-    # Write the options to the file.
-    with open(file_path, 'w') as file:
-        for option in options:
-            file.write(f"{option}\n")
-
-
-def create_jvm_options_custom_4gb_memory_heap_file(file_path: str = None):
-    """
-    The function creates a custom JVM options file with 4GB memory heap usage.
-    The 4GB memory usage options are needed for the Elasticsearch to work properly and not to crash.
-    :param file_path: str, the path to the custom JVM options file.
-    :return:
-    """
-
-    if not file_path:
-        file_path = config_basic.ELASTIC_JVM_OPTIONS_4GB_CUSTOM_FILE
-
-    create_jvm_options_custom_file(file_path, config_basic.ELASTIC_JVM_OPTIONS_4GB_MEMORY_USAGE)
-
-
-def is_server_available(
-        max_attempts: int = 5,
-        wait_between_attempts_seconds: float = 10,
-        elastic_url: str = None,
-        print_kwargs: dict = None
-):
-    """
-    The function checks if Elasticsearch server is up and running by sending GET request to the Elasticsearch server.
-    :param max_attempts: int, the maximum number of attempts to check if Elasticsearch is running.
-    :param wait_between_attempts_seconds: float, the time to wait between attempts.
-    :param elastic_url: str, the URL of the Elasticsearch server. If None, the default URL will be used.
-    :param print_kwargs: dict, the keyword arguments for the print_api function.
-    :return:
-    """
-
-    if not elastic_url:
-        elastic_url = config_basic.DEFAULT_ELASTIC_URL
-
-    if not print_kwargs:
-        print_kwargs = dict()
-
-    for attempt in range(1, max_attempts + 1):
-        print_api(f"Checking if Elasticsearch is running (Attempt {attempt}/{max_attempts})...", **print_kwargs)
-
-        try:
-            response = requests.get(elastic_url)
-            status_code = response.status_code
-
-            if status_code == 200:
-                print_api("Elasticsearch is up and running.", color='green', **print_kwargs)
-                return True
-            else:
-                print_api(f"Elasticsearch is not running. Status code: {status_code}", color='yellow', **print_kwargs)
-        except requests.exceptions.RequestException as e:
-            print_api(f"Failed to connect to Elasticsearch: {e}", color='yellow', **print_kwargs)
-
-        print_api("Waiting for Elasticsearch to start...", **print_kwargs)
-        time.sleep(wait_between_attempts_seconds)
-
-    print_api("Elasticsearch did not start within the expected time.", color='red', **print_kwargs)
-    return False
-
-
-def is_4gb_memory_heap_options_applied_on_server() -> bool:
-    """
-    The function checks if the 4GB memory heap options are applied on the Elasticsearch server.
-    :return: bool.
-    """
-
-    # Send a GET request
-    response = requests.get(config_basic.DEFAULT_ELASTIC_URL_JVM_OPTIONS)
-    response.raise_for_status()  # Raise an exception for HTTP errors
-
-    # Load JSON data from the response
-    jvm_data = response.json()
-
-    # Check if memory heap options are applied in 'input_arguments' key.
-    for node in jvm_data['nodes'].values():
-        # Get the JVM input arguments values.
-        input_arguments = node['jvm']['input_arguments']
-
-        # Check that the 4GB memory heap options are applied.
-        return all(options in input_arguments for options in config_basic.ELASTIC_JVM_OPTIONS_4GB_MEMORY_USAGE)

atomicshop/wrappers/elasticsearchw/install_elastic.py

@@ -1,232 +0,0 @@
-import sys
-
-from ...print_api import print_api
-from ... import process, permissions
-from .. import ubuntu_terminal
-from . import config_basic, infrastructure
-
-
-def install_elastic_kibana_ubuntu(install_elastic: bool = True, install_kibana: bool = True):
-    """
-    The function will install docker on ubuntu.
-
-    :param install_elastic: bool, if True, install Elasticsearch.
-    :param install_kibana: bool, if True, install Kibana.
-
-    Usage in main.py (run with sudo):
-        from atomicshop.wrappers.elasticw import install_elastic
-
-
-        def main():
-            install_elastic.install_elastic_ubuntu()
-
-
-        if __name__ == '__main__':
-            main()
-    """
-
-    # This is pure bash script.
-    """
-    #!/bin/bash
-
-    # Color text in red.
-    echo_red() {
-        local color="\e[31m"  # Red color
-        local reset="\e[0m"   # Reset formatting
-        echo -e "${color}$1${reset}"
-    }
-    
-    # Function to check if a service is running
-    check_service_running() {
-        local service_name=$1
-        local status=$(systemctl is-active "$service_name")
-    
-        if [ "$status" == "active" ]; then
-            echo "$service_name service is active and running."
-            return 0
-        else
-            echo_red "$service_name service is not running or has failed. Status: $service_status, Failed: $service_failed"
-            return 1
-        fi
-    }
-    
-    # Update and upgrade system packages
-    sudo apt-get update && sudo apt-get upgrade -y
-    
-    # Install necessary dependencies
-    sudo apt-get install apt-transport-https openjdk-11-jdk wget -y
-    
-    # Download and install the GPG signing key
-    wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | gpg --dearmor | sudo tee /usr/share/keyrings/elasticsearch-keyring.gpg > /dev/null
-    
-    # Add the Elastic repository to the system
-    echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list
-    
-    # Update package index
-    sudo apt-get update
-    
-    # Install Elasticsearch
-    sudo apt-get install elasticsearch -y
-    
-    # Path to the Elasticsearch configuration file
-    CONFIG_FILE="/etc/elasticsearch/elasticsearch.yml"
-    
-    # Check if the configuration file exists
-    if [ ! -f "$CONFIG_FILE" ]; then
-        echo "Configuration file does not exist at $CONFIG_FILE."
-        exit 1
-    fi
-    
-    # Function to check the setting in the configuration file
-    check_setting() {
-        if grep -q "^xpack.security.enabled: false" "$CONFIG_FILE"; then
-            echo "The setting is confirmed to be 'xpack.security.enabled: false'."
-        else
-            echo "Failed to set 'xpack.security.enabled: false'."
-            exit 1
-        fi
-    }
-    
-    # Check if 'xpack.security.enabled' is set to 'false'
-    if grep -q "^xpack.security.enabled: false" "$CONFIG_FILE"; then
-        echo "The setting is already set to false."
-    elif grep -q "^xpack.security.enabled: true" "$CONFIG_FILE"; then
-        # If the setting is true, change it to false
-        sudo sed -i 's/^xpack.security.enabled: true/xpack.security.enabled: false/' "$CONFIG_FILE"
-        echo "Changed xpack.security.enabled to false."
-        check_setting
-    else
-        # If the setting doesn't exist, add it
-        echo "xpack.security.enabled: false" | sudo tee -a "$CONFIG_FILE" > /dev/null
-        echo "Added xpack.security.enabled: false to the configuration."
-        check_setting
-    fi
-    
-    # Start and enable Elasticsearch service
-    sudo systemctl start elasticsearch
-    sudo systemctl enable elasticsearch
-    
-    echo "Waiting 30 seconds for program to start before availability check..."
-    sleep 30
-    
-    # Check if Elasticsearch service is running
-    if ! check_service_running "elasticsearch"; then
-        echo "Elasticsearch service failed to start. Exiting."
-        exit 1
-    fi
-    
-    # Function to check if Elasticsearch is up and running
-    check_elasticsearch() {
-        max_attempts=5
-        wait_seconds=10
-    
-        for ((i=1; i<=max_attempts; i++)); do
-            echo "Checking if Elasticsearch is running (Attempt $i/$max_attempts)..."
-    
-            # Using curl to get the HTTP status code
-            status=$(curl --write-out %{http_code} --silent --output /dev/null http://localhost:9200)
-    
-            if [ "$status" -eq 200 ]; then
-                echo "Elasticsearch is up and running."
-                return 0
-            else
-                echo "Elasticsearch is not running. Status code: $status"
-            fi
-    
-            echo "Waiting for Elasticsearch to start..."
-            sleep $wait_seconds
-        done
-    
-        echo "Elasticsearch did not start within the expected time."
-        return 1
-    }
-    
-    # Check if Elasticsearch is running
-    if ! check_elasticsearch; then
-        echo "Elasticsearch failed to start. Exiting."
-        exit 1
-    fi
-    
-    # Install Kibana
-    sudo apt-get install kibana -y
-    
-    # Start and enable Kibana service
-    sudo systemctl start kibana
-    sudo systemctl enable kibana
-    
-    echo "Waiting 30 seconds for program to start before availability check..."
-    sleep 30
-    
-    # Check if Kibana service is running
-    if ! check_service_running "kibana"; then
-        echo "Kibana service failed to start. Exiting."
-        exit 1
-    fi
-    
-    # Print status
-    echo "Elasticsearch and Kibana installation completed."
-    echo "Elasticsearch is running on http://localhost:9200"
-    echo "Kibana is running on http://localhost:5601"
-    """
-
-    if not install_elastic and not install_kibana:
-        raise ValueError("At least one of the services (Elasticsearch or Kibana) must be installed.")
-
-    # Update and upgrade system packages.
-    ubuntu_terminal.update_system_packages()
-    ubuntu_terminal.upgrade_system_packages()
-
-    # Install necessary dependencies.
-    ubuntu_terminal.install_packages(config_basic.UBUNTU_DEPENDENCY_PACKAGES)
-
-    # Install the GPG key and add elastic repository.
-    script = f"""
-    # Download and install the GPG signing key
-    wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | gpg --dearmor | sudo tee /usr/share/keyrings/elasticsearch-keyring.gpg > /dev/null
-    
-    # Add the Elastic repository to the system
-    echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list
-    """
-    process.execute_script(script, shell=True)
-
-    # Update system with elastic search packages.
-    ubuntu_terminal.update_system_packages()
-
-    if install_elastic:
-        # Install Elasticsearch.
-        ubuntu_terminal.install_packages([config_basic.UBUNTU_ELASTIC_PACKAGE_NAME])
-
-        if not permissions.is_admin():
-            print_api("This script requires root privileges...", color='red')
-            sys.exit(1)
-
-        # Check if the configuration file exists.
-        infrastructure.is_elastic_config_file_exists(exit_on_error=True, output_message=True)
-
-        # Check if the specific setting exists or not and set it to false.
-        infrastructure.modify_xpack_security_setting(setting=False, output_message=True)
-
-        # Check if the setting was really set to false.
-        if infrastructure.check_xpack_security_setting() is False:
-            print_api(f"The setting is confirmed to be [{config_basic.XPACK_SECURITY_SETTING_NAME}: false].")
-        else:
-            print_api(f"Failed to set [{config_basic.XPACK_SECURITY_SETTING_NAME}: false].")
-            sys.exit(1)
-
-        infrastructure.start_elastic_and_check_service_availability()
-
-        print_api("Creating custom JVM options file with 4GB memory usage.")
-        infrastructure.create_jvm_options_custom_4gb_memory_heap_file()
-
-    if install_kibana:
-        # Install Kibana.
-        ubuntu_terminal.install_packages([config_basic.UBUNTU_KIBANA_PACKAGE_NAME])
-
-        # Start and enable Kibana service.
-        infrastructure.start_kibana_and_check_service_availability()
-
-    print_api("Installation completed.", color='green')
-    if install_elastic:
-        print_api(f"Default Elasticsearch on {config_basic.DEFAULT_ELASTIC_URL}")
-    if install_kibana:
-        print_api(f"Default Kibana on {config_basic.DEFAULT_KIBANA_URL}")

atomicshop/wrappers/ffmpegw.py

@@ -1,125 +0,0 @@
-import fnmatch
-import os
-import shlex
-
-from ..print_api import print_api
-from ..tempfiles import TempFile
-from .githubw import GitHubWrapper
-from ..process import execute_with_live_output
-from ..filesystem import create_directory
-
-
-class FFmpegWrapper:
-    def __init__(self, working_directory: str = str(), ffmpeg_exe_path: str = str()):
-        self.working_directory: str = working_directory
-        self.ffmpeg_exe_path: str = ffmpeg_exe_path
-        self.relative_path: str = 'bin'
-        self.ffmpeg_exe_name: str = 'ffmpeg.exe'
-
-        # Variables to download the latest release from GitHub in case execution fails.
-        self.git_user: str = 'GyanD'
-        self.git_repo: str = 'codexffmpeg'
-        self.git_latest_release_pattern: str = '*full_build.zip'
-
-        # ffmpeg Release directory name.
-        self.ffmpeg_release_directory_name: str = \
-            f"ffmpeg_{self.git_latest_release_pattern.replace('*', '').split('.')[0]}"
-        self.ffmpeg_release_directory_path: str = str()
-
-        # Execute functions.
-        self.build_ffmpeg_exe_and_directory_path()
-
-    def build_ffmpeg_exe_and_directory_path(self):
-        # If working directory was specified, but not the full path to exe.
-        if self.working_directory and not self.ffmpeg_exe_path:
-            self.ffmpeg_release_directory_path = self.working_directory + os.sep + self.ffmpeg_release_directory_name
-            self.ffmpeg_exe_path = \
-                self.ffmpeg_release_directory_path + os.sep + self.relative_path + os.sep + self.ffmpeg_exe_name
-        # If no working directory and no path to exe was specified.
-        elif not self.working_directory and not self.ffmpeg_exe_path:
-            # Use just 'ffmpeg.exe' as path to exe. Maybe it is already installed and is in environment PATH var.
-            self.ffmpeg_exe_path = self.ffmpeg_exe_name
-
-    def change_to_temp_directory(self):
-        temp_file = TempFile()
-        self.working_directory = temp_file.directory
-        self.ffmpeg_exe_path = str()
-        self.build_ffmpeg_exe_and_directory_path()
-
-    def download_ffmpeg_and_extract(self):
-        github_wrapper = GitHubWrapper(user_name=self.git_user, repo_name=self.git_repo)
-        github_wrapper.build_links_from_user_and_repo()
-        github_wrapper.download_and_extract_latest_release(
-            target_directory=self.ffmpeg_release_directory_path, string_pattern=self.git_latest_release_pattern,
-            archive_remove_first_directory=True)
-
-    def execute_ffmpeg(self, cmd_list: list):
-        continue_loop: bool = True
-        while continue_loop:
-            # If first entry contains 'ffmpeg.exe' and it is not 'self.ffmpeg_exe_path' already.
-            if self.ffmpeg_exe_name in cmd_list[0] and cmd_list[0] != self.ffmpeg_exe_path:
-                # We'll change it to the updated one.
-                cmd_list[0] = self.ffmpeg_exe_path
-            # If first entry doesn't contain 'ffmpeg.exe'.
-            elif self.ffmpeg_exe_name not in cmd_list[0]:
-                # We'll insert the current path into first entry.
-                cmd_list.insert(0, self.ffmpeg_exe_path)
-
-            output_strings: list = [
-                'Input',
-                'Output',
-                'video:'
-            ]
-
-            try:
-                print(f'FFmpeg processing: {shlex.join(cmd_list)}')
-                result_lines = execute_with_live_output(
-                    cmd=cmd_list, output_strings=output_strings, raise_exception=True, exit_on_error=False)
-            # If 'ffmpeg.exe' is non-existent.
-            except FileNotFoundError:
-                # Check if full path to 'ffmpeg.exe' is just 'ffmpeg.exe'.
-                if self.ffmpeg_exe_path == self.ffmpeg_exe_name:
-                    print_api('Will try temp folder...', raise_exception=False)
-                    # Change to temp folder and try executing again.
-                    self.change_to_temp_directory()
-                    continue
-
-                print_api('Trying to download...', raise_exception=False)
-                create_directory(self.ffmpeg_release_directory_path)
-                self.download_ffmpeg_and_extract()
-                continue
-
-            # === At this point python exceptions are finished. ==========================
-            # If 'Invalid argument' was returned by 'ffmpeg' in the last line.
-            if 'Invalid argument' in result_lines[-1]:
-                print_api(result_lines[-1], message_type_error=True, color="red", exit_on_error=True)
-
-            # === Successful execution section ==========================================
-            string_pattern = 'video:*audio:*subtitle*'
-            # if 'video:' in result_lines[-1] and 'audio:' in result_lines[-1] and 'subtitle:' in result_lines[-1]:
-            if fnmatch.fnmatch(result_lines[-1], string_pattern):
-                print_api(f'FFmpeg finished successfully.', color="green")
-
-            # Since exceptions are finished, we can stop the while loop.
-            continue_loop = False
-
-    def convert_file(self, source_file_path: str, dest_file_path: str, overwrite: bool = False) -> None:
-        """
-        The function converts source file to destination file. The source format is defined by the file extension
-        as well as destination file format defined by the destination file extension.
-
-        Example convert MP3 file to WAV:
-            convert_file(source_file_path=some_music.mp3, dest_file_path=converted_file.wav)
-
-        :param source_file_path: string, full file path to source file.
-        :param dest_file_path: string, full file path to destination file.
-        :param overwrite: boolean, set if destination file should be overwritten if it exists.
-        :return: None.
-        """
-
-        cmd_list = ['-i', source_file_path, dest_file_path]
-
-        if overwrite:
-            cmd_list.append('-y')
-
-        self.execute_ffmpeg(cmd_list)

atomicshop/wrappers/loggingw/checks.py

@@ -1,20 +0,0 @@
-import logging
-
-
-def has_handlers(logger: logging.Logger) -> bool:
-    """
-    Function to check if the logger has handlers.
-    :param logger: Logger to check
-    :return: True if logger has handlers, False otherwise
-    """
-
-    # Omitted the usage of "hasHandlers()" method, since sometimes returned "True" even when there were no handlers
-    # Didn't research the issue much, just used the "len(logger.handlers)" to check how many handlers there are
-    # in the logger.
-    # if not logging.getLogger(function_module_name).hasHandlers():
-    # if len(logging.getLogger(function_module_name).handlers) == 0:
-
-    if len(logger.handlers) == 0:
-        return False
-    else:
-        return True