Chimie Théorique » scripts_chimie4psmn » DockOnSurf

import logging

logger = logging.getLogger('DockOnSurf')

def tail(f, lines=20):

    total_lines_wanted = lines

    block_size = 1024

    f.seek(0, 2)

    block_end_byte = f.tell()

    lines_to_go = total_lines_wanted

    block_number = -1

    blocks = []

    while lines_to_go > 0 and block_end_byte > 0:

        if block_end_byte - block_size > 0:

            f.seek(block_number * block_size, 2)

            blocks.append(f.read(block_size))

        else:

            f.seek(0, 0)

            blocks.append(f.read(block_end_byte))

        lines_found = blocks[-1].count(b'\n')

        lines_to_go -= lines_found

        block_end_byte -= block_size

        block_number -= 1

    all_read_text = b''.join(reversed(blocks))

    return b'\n'.join(all_read_text.splitlines()[-total_lines_wanted:]).decode()

def check_bak(file_name):

    """Checks if a file already exists and backs it up if so.

    @param file_name: file to be checked if exists

    """

    import os

    new_name = file_name

    bak_num = 0

    while os.path.isdir(new_name) or os.path.isfile(new_name):

        bak_num += 1

        new_name = new_name.split(".bak")[0] + f".bak{bak_num}"

    if bak_num > 0:

        os.rename(file_name, new_name)

        logger.warning(f"'{file_name}' already present. Backed it up to "

                       f"{new_name}.")

def try_command(command, expct_error_types: list, *args, **kwargs):

    """Try to run a command and record exceptions (expected and not) on a log.

    @param command: method or function, the command to be executed.

    @param expct_error_types: list of tuples, every inner tuple is supposed to

    contain an exception type (eg. ValueError, TypeError, etc.) to be caught and

    a message to print in the log and on the screen explaining the exception.

    Error types that are not allow to be called with a custom message as only

    error argument are not supported.

    The outer tuple encloses all couples of error types and their relative

    messages.

    *args and **kwargs: arguments and keyword-arguments of the command to be

    executed.

    When trying to run 'command' with its args and kwargs, if an exception

    present on the 'error_types' occurs, its relative error message is recorded

    on the log and a same type exception is raised with the custom message.

    """

    unexp_error = "An unexpected error occurred"

    err = False

    try:

        return_val = command(*args, **kwargs)

    except Exception as e:

        for expct_err in expct_error_types:

            if isinstance(e, expct_err[0]):

                logger.error(expct_err[1])

                err = expct_err[0](expct_err[1])

                break

        else:

            logger.exception(unexp_error)

            err = e

    else:

        err = False

        return return_val

    finally:

        if isinstance(err, BaseException):

            raise err

def _human_key(key):

    import re

    parts = re.split('(\d*\.\d+|\d+)', key)

    return tuple((e.swapcase() if i % 2 == 0 else float(e))

                 for i, e in enumerate(parts))