db_sync_tool.utility.output

Complexity

Total Complexity

33

Size/Duplication

Total Lines	143
Duplicated Lines	0 %

Importance

Changes

0

5 Functions

Rating	Name	Duplication	Size	Complexity
F	message()	0	42	14
A	subject_to_host()	0	12	4
B	extend_output_by_sync_mode()	0	23	8
A	host_to_subject()	0	12	4
A	remove_multiple_elements_from_string()	0	11	3

#!/usr/bin/env python3
# -*- coding: future_fstrings -*-

"""
Output script
"""
import time

The import time seems to be unused.

from yaspin import yaspin
from db_sync_tool.utility import log, mode, system


class CliFormat:

Missing class docstring

    BEIGE = '\033[96m'
    PURPLE = '\033[95m'
    BLUE = '\033[94m'
    YELLOW = '\033[93m'
    GREEN = '\033[92m'
    RED = '\033[91m'
    BLACK = '\033[90m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'


class Subject:

Missing class docstring

    INFO = CliFormat.GREEN + '[INFO]' + CliFormat.ENDC
    LOCAL = CliFormat.BEIGE + '[LOCAL]' + CliFormat.ENDC
    TARGET = CliFormat.BLUE + '[TARGET]' + CliFormat.ENDC
    ORIGIN = CliFormat.PURPLE + '[ORIGIN]' + CliFormat.ENDC
    ERROR = CliFormat.RED + '[ERROR]' + CliFormat.ENDC
    WARNING = CliFormat.YELLOW + '[WARNING]' + CliFormat.ENDC
    DEBUG = CliFormat.BLACK + '[DEBUG]' + CliFormat.ENDC


def message(header, message, do_print=True, do_log=False, debug=False, verbose_only=False):

message is re-defining a name which is already available in the outer-scope (previously defined on line 35).

Too many arguments (6/5)

Either all return statements in a function should return an expression, or none of them should.

    """
    Formatting a message for print or log
    :param header: String
    :param message: String
    :param do_print: Boolean
    :param do_log: Boolean
    :param debug: Boolean
    :param verbose_only: Boolean
    :return: String message
    """
    # Logging if explicitly forced or verbose option is active
    if do_log or system.config['verbose']:
        _message = remove_multiple_elements_from_string([CliFormat.BEIGE,
                                                         CliFormat.PURPLE,
                                                         CliFormat.BLUE,
                                                         CliFormat.YELLOW,
                                                         CliFormat.GREEN,
                                                         CliFormat.RED,
                                                         CliFormat.BLACK,
                                                         CliFormat.ENDC,
                                                         CliFormat.BOLD,
                                                         CliFormat.UNDERLINE], message)
        # @ToDo: Can this be done better? Dynamic functions?
        if debug:
            log.get_logger().debug(_message)
        elif header == Subject.WARNING:
            log.get_logger().warning(_message)
        elif header == Subject.ERROR:
            log.get_logger().error(_message)
        else:
            log.get_logger().info(_message)

    # Formatting message if mute option is inactive
    if (system.config['mute'] and header == Subject.ERROR) or (not system.config['mute']):
        if do_print:
            if not verbose_only or (verbose_only and system.config['verbose']):
                _message = header + extend_output_by_sync_mode(header, debug) + ' ' + message
                with yaspin(text=_message, color="yellow", side="right") as spinner:
                    spinner.ok("\b\b")
        else:
            return header + extend_output_by_sync_mode(header, debug) + ' ' + message


def extend_output_by_sync_mode(header, debug=False):
    """
    Extending the output by a client information (LOCAL|REMOTE)
    :param header: String
    :return: String message
    """
    _sync_mode = mode.get_sync_mode()
    _debug = ''

    if debug:
        _debug = Subject.DEBUG

    if header == Subject.INFO or header == Subject.LOCAL or \

Unnecessary "else" after "return"

Consider merging these comparisons with "in" to 'header in (Subject.INFO, Subject.LOCAL, Subject.WARNING, Subject.ERROR)'

            header == Subject.WARNING or header == Subject.ERROR:
        return ''
    else:
        if mode.is_remote(subject_to_host(header)):

Unnecessary "else" after "return"

            return CliFormat.BLACK + '[REMOTE]' + CliFormat.ENDC + _debug
        else:
            if subject_to_host(header) == mode.Client.LOCAL:

Unnecessary "else" after "return"

                return _debug
            else:
                return CliFormat.BLACK + '[LOCAL]' + CliFormat.ENDC + _debug


def host_to_subject(host):

Either all return statements in a function should return an expression, or none of them should.

    """
    Converting the client to the according subject
    :param host: String
    :return: String subject
    """
    if host == mode.Client.ORIGIN:

Unnecessary "elif" after "return"

        return Subject.ORIGIN
    elif host == mode.Client.TARGET:
        return Subject.TARGET
    elif host == mode.Client.LOCAL:
        return Subject.LOCAL


def subject_to_host(subject):

Either all return statements in a function should return an expression, or none of them should.

    """
    Converting the subject to the according host
    :param subject: String
    :return: String host
    """
    if subject == Subject.ORIGIN:

Unnecessary "elif" after "return"

        return mode.Client.ORIGIN
    elif subject == Subject.TARGET:
        return mode.Client.TARGET
    elif subject == Subject.LOCAL:
        return mode.Client.LOCAL


def remove_multiple_elements_from_string(elements, string):
    """
    Removing multiple elements from a string
    :param elements: List
    :param string: String
    :return: String string
    """
    for element in elements:
        if element in string:
            string = string.replace(element, '')
    return string

Trailing newlines