shinestacker 0.2.0.post1.dev1__py3-none-any.whl

shinestacker/config/config.py

@@ -0,0 +1,53 @@
+class _Config:
+    _initialized = False
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._init_defaults()
+        return cls._instance
+
+    def _init_defaults(self):
+        self._DISABLE_TQDM = False
+        self._COMBINED_APP = False
+        self._DONT_USE_NATIVE_MENU = True
+        try:
+            __IPYTHON__ # noqa
+            self._JUPYTER_NOTEBOOK = True
+        except Exception:
+            self._JUPYTER_NOTEBOOK = False
+
+    def init(self, **kwargs):
+        if self._initialized:
+            raise RuntimeError("Config already initialized")
+        for k, v in kwargs.items():
+            if hasattr(self, f"_{k}"):
+                setattr(self, f"_{k}", v)
+            else:
+                raise AttributeError(f"Invalid config key: {k}")
+        self._initialized = True
+
+    @property
+    def DISABLE_TQDM(self):
+        return self._DISABLE_TQDM
+
+    @property
+    def JUPYTER_NOTEBOOK(self):
+        return self._JUPYTER_NOTEBOOK
+
+    @property
+    def DONT_USE_NATIVE_MENU(self):
+        return self._DONT_USE_NATIVE_MENU
+
+    @property
+    def COMBINED_APP(self):
+        return self._COMBINED_APP
+
+    def __setattr__(self, name, value):
+        if self._initialized and name.startswith('_'):
+            raise AttributeError("Can't change config after initialization")
+        super().__setattr__(name, value)
+
+
+config = _Config()

shinestacker/config/constants.py

@@ -0,0 +1,174 @@
+import sys
+import re
+
+
+class _Constants:
+    APP_TITLE = "Shine Stacker"
+    APP_STRING = "ShineStacker"
+    EXTENSIONS = set(["jpeg", "jpg", "png", "tif", "tiff"])
+
+    NUM_UINT8 = 256
+    NUM_UINT16 = 65536
+    MAX_UINT8 = 255
+    MAX_UINT16 = 65535
+
+    LOG_FONTS = ['Monaco', 'Menlo', ' Lucida Console', 'Courier New', 'Courier', 'monospace']
+    LOG_FONTS_STR = ", ".join(LOG_FONTS)
+
+    ANSI_ESCAPE = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+
+    ACTION_JOB = "Job"
+    ACTION_COMBO = "CombinedActions"
+    ACTION_NOISEDETECTION = "NoiseDetection"
+    ACTION_FOCUSSTACK = "FocusStack"
+    ACTION_FOCUSSTACKBUNCH = "FocusStackBunch"
+    ACTION_MULTILAYER = "MultiLayer"
+    ACTION_TYPES = [ACTION_COMBO, ACTION_FOCUSSTACKBUNCH, ACTION_FOCUSSTACK,
+                    ACTION_MULTILAYER, ACTION_NOISEDETECTION]
+    COMPOSITE_TYPES = [ACTION_COMBO]
+    ACTION_MASKNOISE = "MaskNoise"
+    ACTION_VIGNETTING = "Vignetting"
+    ACTION_ALIGNFRAMES = "AlignFrames"
+    ACTION_BALANCEFRAMES = "BalanceFrames"
+    SUB_ACTION_TYPES = [ACTION_MASKNOISE, ACTION_VIGNETTING, ACTION_ALIGNFRAMES,
+                        ACTION_BALANCEFRAMES]
+    STACK_ALGO_PYRAMID = 'Pyramid'
+    STACK_ALGO_DEPTH_MAP = 'Depth map'
+    STACK_ALGO_OPTIONS = [STACK_ALGO_PYRAMID, STACK_ALGO_DEPTH_MAP]
+    STACK_ALGO_DEFAULT = STACK_ALGO_PYRAMID
+    DEFAULT_PLOTS_PATH = 'plots'
+
+    PATH_SEPARATOR = ';'
+
+    DEFAULT_FILE_REVERSE_ORDER = False
+    DEFAULT_MULTILAYER_FILE_REVERSE_ORDER = True
+
+    DEFAULT_NOISE_MAP_FILENAME = "noise-map/hot_pixels.png"
+    DEFAULT_MN_KERNEL_SIZE = 3
+    INTERPOLATE_MEAN = 'MEAN'
+    INTERPOLATE_MEDIAN = 'MEDIAN'
+    RGB_LABELS = ['r', 'g', 'b']
+    RGBA_LABELS = ['r', 'g', 'b', 'a']
+    DEFAULT_CHANNEL_THRESHOLDS = [13, 13, 13]
+    DEFAULT_BLUR_SIZE = 5
+    DEFAULT_NOISE_PLOT_RANGE = [5, 30]
+    VALID_INTERPOLATE = {INTERPOLATE_MEAN, INTERPOLATE_MEDIAN}
+
+    ALIGN_HOMOGRAPHY = "ALIGN_HOMOGRAPHY"
+    ALIGN_RIGID = "ALIGN_RIGID"
+    BORDER_CONSTANT = "BORDER_CONSTANT"
+    BORDER_REPLICATE = "BORDER_REPLICATE"
+    BORDER_REPLICATE_BLUR = "BORDER_REPLICATE_BLUR"
+    DETECTOR_SIFT = "SIFT"
+    DETECTOR_ORB = "ORB"
+    DETECTOR_SURF = "SURF"
+    DETECTOR_AKAZE = "AKAZE"
+    DETECTOR_BRISK = "BRISK"
+    DESCRIPTOR_SIFT = "SIFT"
+    DESCRIPTOR_ORB = "ORB"
+    DESCRIPTOR_AKAZE = "AKAZE"
+    DESCRIPTOR_BRISK = "BRISK"
+    MATCHING_KNN = "KNN"
+    MATCHING_NORM_HAMMING = "NORM_HAMMING"
+    ALIGN_RANSAC = "RANSAC"
+    ALIGN_LMEDS = "LMEDS"
+
+    VALID_DETECTORS = [DETECTOR_SIFT, DETECTOR_ORB, DETECTOR_SURF, DETECTOR_AKAZE, DETECTOR_BRISK]
+    VALID_DESCRIPTORS = [DESCRIPTOR_SIFT, DESCRIPTOR_ORB, DESCRIPTOR_AKAZE, DESCRIPTOR_BRISK]
+    VALID_MATCHING_METHODS = [MATCHING_KNN, MATCHING_NORM_HAMMING]
+    VALID_TRANSFORMS = [ALIGN_RIGID, ALIGN_HOMOGRAPHY]
+    VALID_BORDER_MODES = [BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REPLICATE_BLUR]
+    VALID_ALIGN_METHODS = [ALIGN_RANSAC, ALIGN_LMEDS]
+    NOKNN_METHODS = {'detectors': [DETECTOR_ORB, DETECTOR_SURF, DETECTOR_AKAZE, DETECTOR_BRISK],
+                     'descriptors': [DESCRIPTOR_ORB, DESCRIPTOR_AKAZE, DESCRIPTOR_BRISK]}
+
+    DEFAULT_DETECTOR = DETECTOR_SIFT
+    DEFAULT_DESCRIPTOR = DESCRIPTOR_SIFT
+    DEFAULT_MATCHING_METHOD = MATCHING_KNN
+    DEFAULT_FLANN_IDX_KDTREE = 2
+    DEFAULT_FLANN_TREES = 5
+    DEFAULT_FLANN_CHECKS = 50
+    DEFAULT_ALIGN_THRESHOLD = 0.75
+    DEFAULT_TRANSFORM = ALIGN_RIGID
+    DEFAULT_BORDER_MODE = BORDER_REPLICATE_BLUR
+    DEFAULT_ALIGN_METHOD = 'RANSAC'
+    DEFAULT_RANS_THRESHOLD = 3.0  # px
+    DEFAULT_REFINE_ITERS = 100
+    DEFAULT_ALIGN_CONFIDENCE = 99.9
+    DEFAULT_ALIGN_MAX_ITERS = 2000
+    DEFAULT_BORDER_VALUE = [0] * 4
+    DEFAULT_BORDER_BLUR = 50
+    DEFAULT_ALIGN_SUBSAMPLE = 1
+    DEFAULT_ALIGN_FAST_SUBSAMPLING = False
+
+    BALANCE_LINEAR = "LINEAR"
+    BALANCE_GAMMA = "GAMMA"
+    BALANCE_MATCH_HIST = "MATCH_HIST"
+    VALID_BALANCE = [BALANCE_LINEAR, BALANCE_GAMMA, BALANCE_MATCH_HIST]
+
+    BALANCE_LUMI = "LUMI"
+    BALANCE_RGB = "RGB"
+    BALANCE_HSV = "HSV"
+    BALANCE_HLS = "HLS"
+    VALID_BALANCE_CHANNELS = [BALANCE_LUMI, BALANCE_RGB, BALANCE_HSV, BALANCE_HLS]
+
+    DEFAULT_BALANCE_SUBSAMPLE = 8
+    DEFAULT_CORR_MAP = BALANCE_LINEAR
+    DEFAULT_CHANNEL = BALANCE_LUMI
+    DEFAULT_INTENSITY_INTERVAL = {'min': 0, 'max': -1}
+
+    DEFAULT_R_STEPS = 100
+    DEFAULT_BLACK_THRESHOLD = 1
+    DEFAULT_MAX_CORRECTION = 1
+
+    FLOAT_32 = 'float-32'
+    FLOAT_64 = 'float-64'
+    VALID_FLOATS = [FLOAT_32, FLOAT_64]
+
+    DEFAULT_FRAMES = 10
+    DEFAULT_OVERLAP = 2
+    DEFAULT_STACK_PREFIX = "stack_"
+    DEFAULT_BUNCH_PREFIX = "bunch_"
+
+    DEFAULT_DM_FLOAT = FLOAT_32
+    DM_ENERGY_LAPLACIAN = "laplacian"
+    DM_ENERGY_SOBEL = "sobel"
+    DM_MAP_AVERAGE = "average"
+    DM_MAP_MAX = "max"
+    VALID_DM_MAP = [DM_MAP_AVERAGE, DM_MAP_MAX]
+    VALID_DM_ENERGY = [DM_ENERGY_LAPLACIAN, DM_ENERGY_SOBEL]
+    DEFAULT_DM_MAP = DM_MAP_AVERAGE
+    DEFAULT_DM_ENERGY = DM_ENERGY_LAPLACIAN
+    DEFAULT_DM_KERNEL_SIZE = 5
+    DEFAULT_DM_BLUR_SIZE = 5
+    DEFAULT_DM_SMOOTH_SIZE = 15
+    DEFAULT_DM_TEMPERATURE = 0.1
+    DEFAULT_DM_LEVELS = 3
+
+    DEFAULT_PY_FLOAT = FLOAT_32
+    DEFAULT_PY_MIN_SIZE = 32
+    DEFAULT_PY_KERNEL_SIZE = 5
+    DEFAULT_PY_GEN_KERNEL = 0.4
+
+    DEFAULT_PLOT_STACK_BUNCH = False
+    DEFAULT_PLOT_STACK = True
+
+    STATUS_RUNNING = 1
+    STATUS_PAUSED = 2
+    STATUS_STOPPED = 3
+
+    RUN_COMPLETED = 0
+    RUN_ONGOING = 1
+    RUN_FAILED = 2
+    RUN_STOPPED = 3
+
+    def __setattr__aux(self, name, value):
+        raise AttributeError(f"Can't reassign constant '{name}'")
+
+    def __init__(self):
+        self.PYTHON_APP = sys.executable
+        self.RETOUCH_APP = "shinestacker-retouch"
+        _Constants.__setattr__ = _Constants.__setattr__aux
+
+
+constants = _Constants()

shinestacker/config/gui_constants.py

@@ -0,0 +1,85 @@
+import math
+
+
+class _GuiConstants:
+    GUI_IMG_WIDTH = 250  # px
+    DISABLED_TAG = ""  # " <disabled>"
+
+    MIN_ZOOMED_IMG_WIDTH = 400
+    MAX_ZOOMED_IMG_PX_SIZE = 50
+    MAX_UNDO_SIZE = 65535
+
+    NEW_PROJECT_NOISE_DETECTION = False
+    NEW_PROJECT_VIGNETTING_CORRECTION = False
+    NEW_PROJECT_ALIGN_FRAMES = True
+    NEW_PROJECT_BALANCE_FRAMES = True
+    NEW_PROJECT_BUNCH_STACK = False
+    NEW_PROJECT_BUNCH_FRAMES = {'min': 2, 'max': 20}
+    NEW_PROJECT_BUNCH_OVERLAP = {'min': 0, 'max': 10}
+    NEW_PROJECT_FOCUS_STACK_PYRAMID = True
+    NEW_PROJECT_FOCUS_STACK_DEPTH_MAP = False
+    NEW_PROJECT_MULTI_LAYER = False
+
+    BRUSH_COLORS = {
+        'outer': (255, 0, 0, 200),
+        'inner': (255, 0, 0, 150),
+        'gradient_end': (255, 0, 0, 0),
+        'pen': (255, 0, 0, 150),
+        'preview': (255, 180, 180),
+        'cursor_inner': (255, 0, 0, 120),
+        'preview_inner': (255, 255, 255, 150)
+    }
+
+    MIN_MOUSE_STEP_BRUSH_FRACTION = 0.25
+    PAINT_REFRESH_TIMER = 50  # milliseconds
+
+    THUMB_WIDTH = 120  # px
+    THUMB_HEIGHT = 80  # px
+    IMG_WIDTH = 100  # px
+    IMG_HEIGHT = 80  # px
+    LABEL_HEIGHT = 20  # px
+
+    MAX_UNDO_STEPS = 50
+
+    BRUSH_SIZE_SLIDER_MAX = 1000
+
+    UI_SIZES = {
+        'brush_preview': (100, 80),
+        'thumbnail': (IMG_WIDTH, IMG_HEIGHT),
+        'master_thumb': (THUMB_WIDTH, THUMB_HEIGHT)
+    }
+
+    DEFAULT_BRUSH_HARDNESS = 50
+    DEFAULT_BRUSH_OPACITY = 100
+    DEFAULT_BRUSH_FLOW = 100
+    BRUSH_SIZES = {
+        'default': 50,
+        'min': 5,
+        'mid': 50,
+        'max': 1000
+    }
+    DEFAULT_CURSOR_STYLE = 'preview'
+    BRUSH_LINE_WIDTH = 2
+    BRUSH_PREVIEW_LINE_WIDTH = 1.5
+    ZOOM_IN_FACTOR = 1.25
+    ZOOM_OUT_FACTOR = 0.80
+
+    def calculate_gamma(self):
+        if self.BRUSH_SIZES['mid'] <= self.BRUSH_SIZES['min'] or self.BRUSH_SIZES['max'] <= 0:
+            return 1.0
+        ratio = (self.BRUSH_SIZES['mid'] - self.BRUSH_SIZES['min']) / self.BRUSH_SIZES['max']
+        half_point = self.BRUSH_SIZE_SLIDER_MAX / 2
+        if ratio <= 0:
+            return 1.0
+        gamma = math.log(ratio) / math.log(half_point / self.BRUSH_SIZE_SLIDER_MAX)
+        return gamma
+
+    def __setattr__aux(self, name, value):
+        raise AttributeError(f"Can't reassign constant '{name}'")
+
+    def __init__(self):
+        self.BRUSH_GAMMA = self.calculate_gamma()
+        _GuiConstants.__setattr__ = _GuiConstants.__setattr__aux
+
+
+gui_constants = _GuiConstants()

shinestacker/core/__init__.py

@@ -0,0 +1,5 @@
+# flake8: noqa F401
+from .logging import setup_logging, console_logging_overwrite, console_logging_newline
+from .exceptions import (FocusStackError, InvalidOptionError, ImageLoadError, AlignmentError,
+                                    BitDepthError, ShapeError)
+from .framework import TqdmCallbacks

shinestacker/core/colors.py

@@ -0,0 +1,60 @@
+COLORS = {
+    "black": 30,
+    "red": 31,
+    "green": 32,
+    "yellow": 33,
+    "blue": 34,
+    "magenta": 35,
+    "cyan": 36,
+    "light_grey": 37,
+    "dark_grey": 90,
+    "light_red": 91,
+    "light_green": 92,
+    "light_yellow": 93,
+    "light_blue": 94,
+    "light_magenta": 95,
+    "light_cyan": 96,
+    "white": 97,
+}
+
+BG_COLORS = {
+    "bg_black": 40,
+    "bg_red": 41,
+    "bg_green": 42,
+    "bg_yellow": 43,
+    "bg_blue": 44,
+    "bg_magenta": 45,
+    "bg_cyan": 46,
+    "bg_light_grey": 47,
+    "bg_dark_grey": 100,
+    "bg_light_red": 101,
+    "bg_light_green": 102,
+    "bg_light_yellow": 103,
+    "bg_light_blue": 104,
+    "bg_light_magenta": 105,
+    "bg_light_cyan": 106,
+    "bg_white": 107,
+}
+
+EFFECTS = {
+    "bold": 1,
+    "dark": 2,
+    "italic": 3,
+    "underline": 4,
+    "blink": 5,
+    "reverse": 7,
+}
+
+
+def color_str(text, *args):
+    text_colored = text
+    for arg in args:
+        if arg in COLORS.keys():
+            text_colored = f"\033[{COLORS[arg]}m{text_colored}"
+        elif arg in BG_COLORS.keys():
+            text_colored = f"\033[{BG_COLORS[arg]}m{text_colored}"
+        elif arg in EFFECTS.keys():
+            text_colored = f"\033[{EFFECTS[arg]}m{text_colored}"
+        else:
+            raise ValueError(f"Color or effect not supported: {arg}")
+    return text_colored + "\033[0m"

shinestacker/core/core_utils.py

@@ -0,0 +1,52 @@
+import os
+import sys
+import platform
+from .. config.config import config
+
+if not config.DISABLE_TQDM:
+    from tqdm import tqdm
+    from tqdm.notebook import tqdm_notebook
+
+
+def check_path_exists(path):
+    if not os.path.exists(path):
+        raise Exception('Path does not exist: ' + path)
+
+
+def make_tqdm_bar(name, size, ncols=80):
+    if not config.DISABLE_TQDM:
+        if config.JUPYTER_NOTEBOOK:
+            bar = tqdm_notebook(desc=name, total=size)
+        else:
+            bar = tqdm(desc=name, total=size, ncols=ncols)
+        return bar
+    else:
+        return None
+
+
+def get_app_base_path():
+    sep = '\\' if (platform.system() == 'Windows') else '/'
+    if getattr(sys, 'frozen', False):
+        path = os.path.dirname(os.path.realpath(sys.executable))
+        dirs = path.split(sep)
+        last = -1
+        for i in range(len(dirs) - 1, -1, -1):
+            if dirs[i] == 'shinestacker':
+                last = i
+                break
+        path = sep.join(dirs if last == 1 else dirs[:last + 1])
+    elif __file__:
+        path = sep.join(os.path.dirname(os.path.abspath(__file__)).split(sep)[:-3])
+    return path
+
+
+def running_under_windows() -> bool:
+    return platform.system().lower() == 'windows'
+
+
+def running_under_macos() -> bool:
+    return platform.system().lower() == "darwin"
+
+
+def running_under_linux() -> bool:
+    return platform.system().lower() == 'linux'

shinestacker/core/exceptions.py

@@ -0,0 +1,50 @@
+class FocusStackError(Exception):
+    pass
+
+
+class InvalidOptionError(FocusStackError):
+    def __init__(self, option, value, details=""):
+        self.option = option
+        self.value = value
+        self.details = details
+        super().__init__(f"Invalid option {option} = {value}" + ("" if details == "" else f": {details}"))
+
+
+class ImageLoadError(FocusStackError):
+    def __init__(self, path, details=""):
+        self.path = path
+        self.details = details
+        super().__init__(f"Failed to load {path}" + ("" if details == "" else f": {details}"))
+
+
+class ImageSaveError(FocusStackError):
+    def __init__(self, path, details=""):
+        self.path = path
+        self.details = details
+        super().__init__(f"Failed to save {path}" + ("" if details == "" else f": {details}"))
+
+
+class AlignmentError(FocusStackError):
+    def __init__(self, index, details):
+        self.index = index
+        self.details = details
+        super().__init__(f"Alignment failed for image {index}: {details}")
+
+
+class BitDepthError(FocusStackError):
+    def __init__(self, dtype_ref, dtype):
+        super().__init__(f"Image has type {dtype}, expected {dtype_ref}.")
+
+
+class ShapeError(FocusStackError):
+    def __init__(self, shape_ref, shape):
+        super().__init__(f'''
+Image has shape ({shape[1]}x{shape[0]}), while it was expected ({shape_ref[1]}x{shape_ref[0]}).
+''')
+
+
+class RunStopException(FocusStackError):
+    def __init__(self, name):
+        if name != "":
+            name = f"{name} "
+        super().__init__(f"Job {name}stopped")

shinestacker/core/framework.py

@@ -0,0 +1,210 @@
+import time
+import logging
+from .. config.config import config
+from .colors import color_str
+from .logging import setup_logging
+from .core_utils import make_tqdm_bar
+from .exceptions import RunStopException
+
+LINE_UP = "\r\033[A"
+trailing_spaces = " " * 30
+
+
+class TqdmCallbacks:
+    _instance = None
+
+    callbacks = {
+        'step_counts': lambda id, name, counts: TqdmCallbacks.instance().step_counts(name, counts),
+        'begin_steps': lambda id, name: TqdmCallbacks.instance().begin_steps(name),
+        'end_steps': lambda id, name: TqdmCallbacks.instance().end_steps(name),
+        'after_step': lambda id, name, steps: TqdmCallbacks.instance().after_step(name)
+    }
+
+    def __init__(self):
+        self.bar = None
+        self.counts = -1
+
+    @classmethod
+    def instance(cls):
+        if cls._instance is None:
+            cls._instance = TqdmCallbacks()
+        return cls._instance
+
+    def step_counts(self, name, counts):
+        self.counts = counts
+        self.bar = make_tqdm_bar(name, self.counts)
+
+    def begin_steps(self, name):
+        pass
+
+    def end_steps(self, name):
+        if self.bar is None:
+            raise RuntimeError("tqdm bar not initialized")
+        self.bar.close()
+        self.bar = None
+
+    def after_step(self, name):
+        self.bar.write("")
+        self.bar.update(1)
+
+
+tqdm_callbacks = TqdmCallbacks()
+
+
+def elapsed_time_str(start):
+    dt = time.time() - start
+    mm = int(dt // 60)
+    ss = dt - mm * 60
+    hh = mm // 60
+    mm -= hh * 60
+    return ("{:02d}:{:02d}:{:05.2f}s".format(hh, mm, ss))
+
+
+class JobBase:
+    def __init__(self, name, enabled=True):
+        self.id = -1
+        self.name = name
+        self.enabled = enabled
+        self.base_message = ''
+        if config.JUPYTER_NOTEBOOK:
+            self.begin_r, self.end_r = "", "\r",
+        else:
+            self.begin_r, self.end_r = LINE_UP, None
+
+    def callback(self, key, *args):
+        has_callbacks = hasattr(self, 'callbacks')
+        if has_callbacks and self.callbacks is not None:
+            callback = self.callbacks.get(key, None)
+            if callback:
+                return callback(*args)
+        return None
+
+    def run(self):
+        self.__t0 = time.time()
+        if not self.enabled:
+            self.get_logger().warning(color_str(self.name + ": entire job disabled", 'red'))
+        self.callback('before_action', self.id, self.name)
+        self.run_core()
+        self.callback('after_action', self.id, self.name)
+        self.get_logger().info(
+            color_str(self.name + ": ",
+                      "green", "bold") + color_str("elapsed "
+                                                   "time: {}".format(elapsed_time_str(self.__t0)),
+                                                   "green") + trailing_spaces)
+        self.get_logger().info(
+            color_str(self.name + ": ",
+                      "green", "bold") + color_str("completed", "green") + trailing_spaces)
+
+    def get_logger(self, tqdm=False):
+        if config.DISABLE_TQDM:
+            tqdm = False
+        if self.logger is None:
+            return logging.getLogger("tqdm" if tqdm else __name__)
+        else:
+            return self.logger
+
+    def set_terminator(self, tqdm=False, end='\n'):
+        if config.DISABLE_TQDM:
+            tqdm = False
+        if end is not None:
+            logging.getLogger("tqdm" if tqdm else None).handlers[0].terminator = end
+
+    def print_message(self, msg='', level=logging.INFO, end=None, begin='', tqdm=False):
+        if config.DISABLE_TQDM:
+            tqdm = False
+        self.base_message = color_str(self.name, "blue", "bold")
+        if msg != '':
+            self.base_message += (': ' + msg)
+        self.set_terminator(tqdm, end)
+        self.get_logger(tqdm).log(level, begin + color_str(self.base_message, 'blue', 'bold') + trailing_spaces)
+        self.set_terminator(tqdm)
+
+    def sub_message(self, msg, level=logging.INFO, end=None, begin='', tqdm=False):
+        if config.DISABLE_TQDM:
+            tqdm = False
+        self.set_terminator(tqdm, end)
+        self.get_logger(tqdm).log(level, begin + self.base_message + msg + trailing_spaces)
+        self.set_terminator(tqdm)
+
+    def print_message_r(self, msg='', level=logging.INFO):
+        self.print_message(msg, level, self.end_r, self.begin_r, False)
+
+    def sub_message_r(self, msg='', level=logging.INFO):
+        self.sub_message(msg, level, self.end_r, self.begin_r, False)
+
+
+class Job(JobBase):
+    def __init__(self, name, logger_name=None, log_file='', callbacks=None, **kwargs):
+        JobBase.__init__(self, name, **kwargs)
+        self.action_counter = 0
+        self.__actions = []
+        if logger_name is None:
+            setup_logging(log_file=log_file)
+        self.logger = None if logger_name is None else logging.getLogger(logger_name)
+        self.callbacks = TqdmCallbacks.callbacks if callbacks == 'tqdm' else callbacks
+
+    def time(self):
+        return time.time() - self.__t0
+
+    def init(self, a):
+        pass
+
+    def add_action(self, a: JobBase):
+        a.id = self.action_counter
+        self.action_counter += 1
+        a.logger = self.logger
+        a.callbacks = self.callbacks
+        self.init(a)
+        self.__actions.append(a)
+
+    def run_core(self):
+        for a in self.__actions:
+            if not (a.enabled and self.enabled):
+                z = []
+                if not a.enabled:
+                    z.append("action")
+                if not self.enabled:
+                    z.append("job")
+                msg = " and ".join(z)
+                self.get_logger().warning(color_str(a.name + f": {msg} disabled", 'red'))
+            else:
+                if self.callback('check_running', self.id, self.name) is False:
+                    raise RunStopException(self.name)
+                a.run()
+
+
+class ActionList(JobBase):
+    def __init__(self, name, enabled=True, **kwargs):
+        JobBase.__init__(self, name, enabled, **kwargs)
+
+    def set_counts(self, counts):
+        self.counts = counts
+        self.callback('step_counts', self.id, self.name, self.counts)
+
+    def begin(self):
+        self.callback('begin_steps', self.id, self.name)
+
+    def end(self):
+        self.callback('end_steps', self.id, self.name)
+
+    def __iter__(self):
+        self.count = 1
+        return self
+
+    def __next__(self):
+        if self.count <= self.counts:
+            self.run_step()
+            x = self.count
+            self.count += 1
+            return x
+        else:
+            raise StopIteration
+
+    def run_core(self):
+        self.print_message('begin run', end='\n')
+        self.begin()
+        for x in iter(self):
+            self.callback('after_step', self.id, self.name, self.count)
+            if self.callback('check_running', self.id, self.name) is False:
+                raise RunStopException(self.name)
+        self.end()