db_sync_tool.utility.output

Complexity

Total Complexity

29

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Importance

Changes

0

5 Functions

Rating	Name	Duplication	Size	Complexity
D	message()	0	31	13
A	subject_to_host()	0	10	3
B	extend_output_by_sync_mode()	0	19	7
A	host_to_subject()	0	10	3
A	remove_multiple_elements_from_string()	0	11	3

#!/usr/bin/env python3

Missing module docstring

# -*- coding: future_fstrings -*-

from db_sync_tool.utility import log, mode, system


#
# GLOBALS
#

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


#
# FUNCTIONS
#

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 37).

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)

This line is too long as per the coding-style (237/100).

        # @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']):
                print(header + extend_output_by_sync_mode(header, debug) + ' ' + message)
        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 = CliFormat.BLACK + '[DEBUG]' + CliFormat.ENDC

    if header == Subject.INFO or header == Subject.LOCAL or header == Subject.WARNING or header == Subject.ERROR:

This line is too long as per the coding-style (113/100).

Unnecessary "else" after "return"

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

        return ''
    else:
        if mode.is_remote(subject_to_host(header)):

Unnecessary "else" after "return"

            return CliFormat.BLACK + '[REMOTE]' + CliFormat.ENDC + _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


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


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