zrb 0.1.0a0__py3-none-any.whl → 0.2.0__py3-none-any.whl

zrb/task/base_task/base_task.py

@@ -37,6 +37,8 @@ class BaseTask(
     Base class for all tasks.
     Every task definition should be extended from this class.
     '''
+    __xcom: Mapping[str, Mapping[str, str]] = {}
+
     def __init__(
         self,
         name: str,
@@ -104,7 +106,9 @@ class BaseTask(
         self.__is_execution_triggered: bool = False
         self.__is_execution_started: bool = False
 
-    def __rshift__(self, operand: Union[AnyParallel, AnyTask]):
+    def __rshift__(
+        self, operand: Union[AnyParallel, AnyTask]
+    ) -> Union[AnyParallel, AnyTask]:
         if isinstance(operand, AnyTask):
             operand.add_upstream(self)
             return operand
@@ -114,6 +118,33 @@ class BaseTask(
                 other_task.add_upstream(self)
             return operand
 
+    def set_task_xcom(self, key: str, value: Any) -> str:
+        return self.set_xcom(
+            key='.'.join([self.get_name(), key]),
+            value=value
+        )
+
+    def set_xcom(self, key: str, value: Any) -> str:
+        execution_id = self.get_execution_id()
+        if execution_id not in self.__xcom:
+            self.__xcom[execution_id] = {}
+        execution_id = self.get_execution_id()
+        self.__xcom[execution_id][key] = f'{value}'
+        return ''
+
+    def get_xcom(self, key: str) -> str:
+        execution_id = self.get_execution_id()
+        if execution_id not in self.__xcom:
+            return ''
+        return self.__xcom[execution_id].get(key, '')
+
+    def clear_xcom(self, execution_id: str = '') -> str:
+        if execution_id == '':
+            execution_id = self.get_execution_id()
+        if execution_id in self.__xcom:
+            del self.__xcom[execution_id]
+            return ''
+
     def copy(self) -> AnyTask:
         return copy.deepcopy(self)
 
@@ -224,6 +255,7 @@ class BaseTask(
             ]
             results = await asyncio.gather(*coroutines)
             result = results[-1]
+            self.set_xcom(self.get_name(), f'{result}')
             self._print_result(result)
             return result
         except Exception as e:
@@ -270,14 +302,14 @@ class BaseTask(
           this will return True once every self.checkers is completed
         - Otherwise, this will return check method's return value.
         '''
-        if len(self._checkers) == 0:
+        if len(self._get_checkers()) == 0:
             return await self.check()
         self.log_debug('Waiting execution to be started')
         while not self.__is_execution_started:
             # Don't start checking before the execution itself has been started
             await asyncio.sleep(0.1)
         check_coroutines: Iterable[asyncio.Task] = []
-        for checker_task in self._checkers:
+        for checker_task in self._get_checkers():
             checker_task._set_execution_id(self.get_execution_id())
             check_coroutines.append(
                 asyncio.create_task(checker_task._run_all())
@@ -397,6 +429,7 @@ class BaseTask(
         if self.__is_keyval_set:
             return True
         self.__is_keyval_set = True
+        # Set input_map for rendering
         self.log_info('Set input map')
         for task_input in self._get_combined_inputs():
             input_name = to_variable_name(task_input.get_name())
@@ -408,6 +441,7 @@ class BaseTask(
             'Input map:\n' + map_to_str(self.get_input_map(), item_prefix='  ')
         )
         self.log_info('Merging task envs, task env files, and native envs')
+        # Set env_map for rendering
         for env_name, env in self._get_combined_env().items():
             env_value = env.get(env_prefix)
             if env.should_render():
@@ -417,6 +451,8 @@ class BaseTask(
         self.log_debug(
             'Env map:\n' + map_to_str(self.get_env_map(), item_prefix='  ')
         )
+        # set task
+        self._set_task(self)
 
     def __repr__(self) -> str:
         cls_name = self.__class__.__name__

zrb/task/base_task/component/base_task_model.py

@@ -2,7 +2,7 @@ from zrb.helper.typing import (
     Any, Callable, Iterable, List, Mapping, Optional, Union
 )
 from zrb.helper.typecheck import typechecked
-from zrb.config.config import show_time
+from zrb.config.config import show_time, logging_level
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
@@ -19,8 +19,10 @@ from zrb.task.base_task.component.trackers import TimeTracker
 from zrb.config.config import env_prefix
 from zrb.helper.string.modification import double_quote
 from zrb.helper.string.conversion import to_variable_name
+from functools import lru_cache
 
 import datetime
+import logging
 import os
 import sys
 
@@ -90,12 +92,20 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         self.__kwargs: Mapping[str, Any] = {}
 
     def _set_args(self, args: Iterable[Any]):
+        '''
+        Set args that will be shown at the end of the execution
+        '''
         self.__args = list(args)
 
     def _set_kwargs(self, kwargs: Mapping[str, Any]):
+        '''
+        Set kwargs that will be shown at the end of the execution
+        '''
         self.__kwargs = kwargs
 
     def log_debug(self, message: Any):
+        if logging_level > logging.DEBUG:
+            return
         prefix = self.__get_log_prefix()
         colored_message = colored(
             f'{prefix} • {message}', attrs=['dark']
@@ -103,6 +113,8 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         logger.debug(colored_message)
 
     def log_warn(self, message: Any):
+        if logging_level > logging.WARNING:
+            return
         prefix = self.__get_log_prefix()
         colored_message = colored(
             f'{prefix} • {message}', attrs=['dark']
@@ -110,6 +122,8 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         logger.warning(colored_message)
 
     def log_info(self, message: Any):
+        if logging_level > logging.INFO:
+            return
         prefix = self.__get_log_prefix()
         colored_message = colored(
             f'{prefix} • {message}', attrs=['dark']
@@ -117,6 +131,8 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         logger.info(colored_message)
 
     def log_error(self, message: Any):
+        if logging_level > logging.ERROR:
+            return
         prefix = self.__get_log_prefix()
         colored_message = colored(
             f'{prefix} • {message}', color='red', attrs=['bold']
@@ -124,6 +140,8 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         logger.error(colored_message, exc_info=True)
 
     def log_critical(self, message: Any):
+        if logging_level > logging.CRITICAL:
+            return
         prefix = self.__get_log_prefix()
         colored_message = colored(
             f'{prefix} • {message}', color='red', attrs=['bold']
@@ -203,13 +221,15 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
     def __get_print_prefix(self) -> str:
         common_prefix = self.__get_common_prefix(show_time=show_time)
         icon = self.get_icon()
-        rjust_cli_name = self.__get_rjust_full_cli_name()
+        length = LOG_NAME_LENGTH - len(icon)
+        rjust_cli_name = self.__get_rjust_full_cli_name(length)
         return f'{common_prefix} {icon} {rjust_cli_name}'
 
     def __get_log_prefix(self) -> str:
         common_prefix = self.__get_common_prefix(show_time=False)
         icon = self.get_icon()
-        filled_name = self.__get_rjust_full_cli_name()
+        length = LOG_NAME_LENGTH - len(icon)
+        filled_name = self.__get_rjust_full_cli_name(length)
         return f'{common_prefix} {icon} {filled_name}'
 
     def __get_common_prefix(self, show_time: bool) -> str:
@@ -221,18 +241,21 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
             return f'◷ {now} ❁ {pid} → {attempt}/{max_attempt}'
         return f'❁ {pid} → {attempt}/{max_attempt}'
 
-    def __get_rjust_full_cli_name(self) -> str:
+    @lru_cache
+    def __get_rjust_full_cli_name(self, length: int) -> str:
         if self.__rjust_full_cli_name is not None:
             return self.__rjust_full_cli_name
         complete_name = self._get_full_cli_name()
-        self.__rjust_full_cli_name = complete_name.rjust(LOG_NAME_LENGTH, ' ')
+        self.__rjust_full_cli_name = complete_name.rjust(length, ' ')
         return self.__rjust_full_cli_name
 
+    @lru_cache
     def __get_executable_name(self) -> str:
         if len(sys.argv) > 0 and sys.argv[0] != '':
             return os.path.basename(sys.argv[0])
         return 'zrb'
 
+    @lru_cache
     def _get_full_cli_name(self) -> str:
         if self.__complete_name is not None:
             return self.__complete_name

zrb/task/base_task/component/common_task_model.py

@@ -60,7 +60,7 @@ class CommonTaskModel():
         self._retry = retry
         self._retry_interval = retry_interval
         self._upstreams = upstreams
-        self._checkers = checkers
+        self._checkers = [checker.copy() for checker in checkers]
         self._checking_interval = checking_interval
         self._run_function: Optional[Callable[..., Any]] = run
         self._on_triggered = on_triggered
@@ -77,10 +77,10 @@ class CommonTaskModel():
         self.__allow_add_env_files = True
         self.__allow_add_inputs = True
         self.__allow_add_upstreams: bool = True
+        self.__allow_add_checkers: bool = True
         self.__has_already_inject_env_files: bool = False
         self.__has_already_inject_envs: bool = False
         self.__has_already_inject_inputs: bool = False
-        self.__has_already_inject_checkers: bool = False
         self.__has_already_inject_upstreams: bool = False
         self.__all_inputs: Optional[List[AnyInput]] = None
 
@@ -104,12 +104,15 @@ class CommonTaskModel():
         return self.__execution_id
 
     def set_name(self, new_name: str):
-        if self._description == self._name:
+        if self._description == self.get_name():
             self._description = new_name
         self._name = new_name
 
+    def get_name(self) -> str:
+        return self._name
+
     def get_cli_name(self) -> str:
-        return to_cli_name(self._name)
+        return to_cli_name(self.get_name())
 
     def set_description(self, new_description: str):
         self._description = new_description
@@ -139,12 +142,12 @@ class CommonTaskModel():
 
     def insert_input(self, *inputs: AnyInput):
         if not self.__allow_add_inputs:
-            raise Exception(f'Cannot insert inputs for `{self._name}`')
+            raise Exception(f'Cannot insert inputs for `{self.get_name()}`')
         self._inputs = list(inputs) + list(self._inputs)
 
     def add_input(self, *inputs: AnyInput):
         if not self.__allow_add_inputs:
-            raise Exception(f'Cannot add inputs for `{self._name}`')
+            raise Exception(f'Cannot add inputs for `{self.get_name()}`')
         self._inputs = list(self._inputs) + list(inputs)
 
     def inject_inputs(self):
@@ -194,12 +197,12 @@ class CommonTaskModel():
 
     def insert_env(self, *envs: Env):
         if not self.__allow_add_envs:
-            raise Exception(f'Cannot insert envs to `{self._name}`')
+            raise Exception(f'Cannot insert envs to `{self.get_name()}`')
         self._envs = list(envs) + list(self._envs)
 
     def add_env(self, *envs: Env):
         if not self.__allow_add_envs:
-            raise Exception(f'Cannot add envs to `{self._name}`')
+            raise Exception(f'Cannot add envs to `{self.get_name()}`')
         self._envs = list(self._envs) + list(envs)
 
     def inject_envs(self):
@@ -230,12 +233,12 @@ class CommonTaskModel():
 
     def insert_env_file(self, *env_files: EnvFile):
         if not self.__allow_add_env_files:
-            raise Exception(f'Cannot insert env_files to `{self._name}`')
+            raise Exception(f'Cannot insert env_files to `{self.get_name()}`')
         self._env_files = list(env_files) + list(self._env_files)
 
     def add_env_file(self, *env_files: EnvFile):
         if not self.__allow_add_env_files:
-            raise Exception(f'Cannot add env_files to `{self._name}`')
+            raise Exception(f'Cannot add env_files to `{self.get_name()}`')
         self._env_files = list(self._env_files) + list(env_files)
 
     def inject_env_files(self):
@@ -243,12 +246,12 @@ class CommonTaskModel():
 
     def insert_upstream(self, *upstreams: AnyTask):
         if not self.__allow_add_upstreams:
-            raise Exception(f'Cannot insert upstreams to `{self._name}`')
+            raise Exception(f'Cannot insert upstreams to `{self.get_name()}`')
         self._upstreams = list(upstreams) + list(self._upstreams)
 
     def add_upstream(self, *upstreams: AnyTask):
         if not self.__allow_add_upstreams:
-            raise Exception(f'Cannot add upstreams to `{self._name}`')
+            raise Exception(f'Cannot add upstreams to `{self.get_name()}`')
         self._upstreams = list(self._upstreams) + list(upstreams)
 
     def inject_upstreams(self):
@@ -272,11 +275,23 @@ class CommonTaskModel():
             self.__has_already_inject_env_files = True
         return self._env_files
 
+    def insert_checker(self, *checkers: AnyTask):
+        if not self.__allow_add_checkers:
+            raise Exception(f'Cannot insert checkers to `{self.get_name()}`')
+        additional_checkers = [checker.copy() for checker in checkers]
+        self._checkers = additional_checkers + self._checkers
+
+    def add_checker(self, *checkers: AnyTask):
+        if not self.__allow_add_checkers:
+            raise Exception(f'Cannot add checkers to `{self.get_name()}`')
+        additional_checkers = [checker.copy() for checker in checkers]
+        self._checkers = self._checkers + additional_checkers
+
     def inject_checkers(self):
         pass
 
     def _get_checkers(self) -> List[AnyTask]:
-        if not self.__has_already_inject_checkers:
+        if not self.__allow_add_checkers:
             self.inject_checkers()
-            self.__has_already_inject_checkers = True
-        return list(self._checkers)
+            self.__allow_add_checkers = True
+        return self._checkers

zrb/task/base_task/component/renderer.py

@@ -1,3 +1,4 @@
+from zrb.task.any_task import AnyTask
 from zrb.helper.typing import Any, JinjaTemplate, Mapping, Optional, Union
 from zrb.helper.typecheck import typechecked
 from zrb.helper.string.conversion import to_boolean
@@ -24,10 +25,14 @@ class Renderer():
 
     def __init__(self):
         self.__input_map: Mapping[str, Any] = {}
+        self.__task: Optional[AnyTask] = None
         self.__env_map: Mapping[str, str] = {}
         self.__render_data: Optional[Mapping[str, Any]] = None
         self.__rendered_str: Mapping[str, str] = {}
 
+    def _set_task(self, task: AnyTask):
+        self.__task = task
+
     def get_input_map(self) -> Mapping[str, Any]:
         # This return reference to input map, so input map can be updated
         return self.__input_map
@@ -126,6 +131,7 @@ class Renderer():
         render_data.update({
             'env': self.__env_map,
             'input': self.__input_map,
+            'task': self.__task,
         })
         self.__render_data = render_data
         return render_data

zrb/task/cmd_task.py

@@ -48,6 +48,9 @@ class CmdResult():
         self.output = output
         self.error = error
 
+    def __str__(self) -> str:
+        return self.output
+
 
 class CmdGlobalState():
     def __init__(self):
@@ -61,30 +64,18 @@ class CmdTask(BaseTask):
     Command Task.
     You can use this task to run shell command.
 
-    For example:
-    ```python
-    # run a simple task
-    hello = CmdTask(
-        name='hello',
-        inputs=[StrInput(name='name', default='World')],
-        envs=[Env(name='HOME_DIR', os_name='HOME')],
-        cmd=[
-            'echo Hello {{ input.name }}',
-            'echo Home directory is: $HOME_DIR',
-        ]
-    )
-    runner.register(hello)
-
-    # run a long running process
-    run_server = CmdTask(
-        name='run',
-        inputs=[StrInput(name='dir', default='.')],
-        envs=[Env(name='PORT', os_name='WEB_PORT', default='3000')],
-        cmd='python -m http.server $PORT --directory {{input.dir}}',
-        checkers=[HTTPChecker(port='{{env.PORT}}')]
-    )
-    runner.register(run_server)
-    ```
+    Examples:
+        >>> from zrb import runner, CmdTask, StrInput, Env
+        >>> hello = CmdTask(
+        >>>     name='hello',
+        >>>     inputs=[StrInput(name='name', default='World')],
+        >>>     envs=[Env(name='HOME_DIR', os_name='HOME')],
+        >>>     cmd=[
+        >>>         'echo Hello {{ input.name }}',
+        >>>         'echo Home directory is: $HOME_DIR',
+        >>>     ]
+        >>> )
+        >>> runner.register(hello)
     '''
 
     _pids: List[int] = []
@@ -246,6 +237,8 @@ class CmdTask(BaseTask):
             raise Exception(
                 f'Process {self._name} exited ({return_code}): {error}'
             )
+        self.set_task_xcom(key='output', value=output)
+        self.set_task_xcom(key='error', value=error)
         return CmdResult(output, error)
 
     def _should_attempt(self) -> bool:

zrb/task/docker_compose_task.py

@@ -293,7 +293,6 @@ class DockerComposeTask(CmdTask):
             ]:
                 if os.path.exists(os.path.join(self._cwd, _compose_file)):
                     return os.path.join(self._cwd, _compose_file)
-                    return
             raise Exception(f'Cannot find compose file on {self._cwd}')
         if os.path.isabs(compose_file) and os.path.exists(compose_file):
             return compose_file

zrb/task/path_checker.py

@@ -1,5 +1,8 @@
-from zrb.helper.typing import Any, Callable, Iterable, Optional, Union, TypeVar
+from zrb.helper.typing import (
+    Any, Callable, Iterable, List, Optional, Union, TypeVar
+)
 from zrb.helper.typecheck import typechecked
+from zrb.helper.file.match import get_file_names
 from zrb.task.checker import Checker
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
@@ -10,8 +13,6 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
-import glob
-
 TPathChecker = TypeVar('TPathChecker', bound='PathChecker')
 
 
@@ -37,6 +38,7 @@ class PathChecker(Checker):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         path: str = '',
+        ignored_path: Union[str, Iterable[str]] = [],
         checking_interval: Union[int, float] = 0.1,
         progress_interval: Union[int, float] = 5,
         expected_result: bool = True,
@@ -66,7 +68,9 @@ class PathChecker(Checker):
             should_execute=should_execute,
         )
         self._path = path
+        self._ignored_path = ignored_path
         self._rendered_path: str = ''
+        self._rendered_ignored_paths: List[str] = []
 
     def copy(self) -> TPathChecker:
         return super().copy()
@@ -84,12 +88,29 @@ class PathChecker(Checker):
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         self._rendered_path = self.render_str(self._path)
+        self._rendered_ignored_paths = [
+            ignored_path
+            for ignored_path in self._get_rendered_ignored_paths()
+            if ignored_path != ''
+        ]
         return await super().run(*args, **kwargs)
 
+    def _get_rendered_ignored_paths(self) -> List[str]:
+        if isinstance(self._ignored_path, str):
+            return [self.render_str(self._ignored_path)]
+        return [
+            self.render_str(ignored_path)
+            for ignored_path in self._ignored_path
+        ]
+
     async def inspect(self, *args: Any, **kwargs: Any) -> bool:
         label = f'Checking {self._rendered_path}'
         try:
-            if len(glob.glob(self._rendered_path, recursive=True)) > 0:
+            matches = get_file_names(
+                glob_path=self._rendered_path,
+                glob_ignored_paths=self._rendered_ignored_paths
+            )
+            if len(matches) > 0:
                 self.print_out(f'{label} (Exist)')
                 return True
             self.show_progress(f'{label} (Not Exist)')

zrb/task/path_watcher.py

@@ -1,7 +1,8 @@
 from zrb.helper.typing import (
-    Any, Callable, Iterable, Mapping, Optional, Union, TypeVar
+    Any, Callable, Iterable, List, Mapping, Optional, Union, TypeVar
 )
 from zrb.helper.typecheck import typechecked
+from zrb.helper.file.match import get_file_names
 from zrb.task.checker import Checker
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
@@ -12,7 +13,6 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
-import glob
 import os
 
 TPathWatcher = TypeVar('TPathWatcher', bound='PathWatcher')
@@ -20,6 +20,16 @@ TPathWatcher = TypeVar('TPathWatcher', bound='PathWatcher')
 
 @typechecked
 class PathWatcher(Checker):
+    '''
+    PathWatcher will wait for any changes specified on  path.
+
+    Once the changes detected, PathWatcher will be completed
+    and several xcom will be set:
+    - <task-name>.file
+    - <task-name>.new-file
+    - <task-name>.modified-file
+    - <task-name>.deleted-file
+    '''
 
     def __init__(
         self,
@@ -40,6 +50,7 @@ class PathWatcher(Checker):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         path: str = '',
+        ignored_path: Union[str, Iterable[str]] = [],
         checking_interval: Union[int, float] = 0.1,
         progress_interval: Union[int, float] = 30,
         watch_new_files: bool = True,
@@ -70,10 +81,12 @@ class PathWatcher(Checker):
             should_execute=should_execute,
         )
         self._path = path
+        self._ignored_path = ignored_path
         self._watch_new_files = watch_new_files
         self._watch_modified_files = watch_modified_files
         self._watch_deleted_files = watch_deleted_files
         self._rendered_path: str = ''
+        self._rendered_ignored_paths: List[str] = []
         self._init_times: Mapping[str, float] = {}
 
     def copy(self) -> TPathWatcher:
@@ -92,25 +105,43 @@ class PathWatcher(Checker):
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         self._rendered_path = self.render_str(self._path)
+        self._rendered_ignored_paths = [
+            ignored_path
+            for ignored_path in self._get_rendered_ignored_paths()
+            if ignored_path != ''
+        ]
         self._init_times = self._get_mod_times()
         return await super().run(*args, **kwargs)
 
+    def _get_rendered_ignored_paths(self) -> List[str]:
+        if isinstance(self._ignored_path, str):
+            return [self.render_str(self._ignored_path)]
+        return [
+            self.render_str(ignored_path)
+            for ignored_path in self._ignored_path
+        ]
+
     async def inspect(self, *args: Any, **kwargs: Any) -> bool:
         label = f'Watching {self._rendered_path}'
         try:
             mod_times = self._get_mod_times()
-        except Exception:
+        except Exception as e:
             self.show_progress(f'{label} Cannot inspect')
+            raise e
         # watch changes
         if self._watch_new_files:
             new_files = mod_times.keys() - self._init_times.keys()
             for file in new_files:
                 self.print_out_dark(f'{label} [+] New file detected: {file}')
+                self.set_task_xcom('new-file', file)
+                self.set_task_xcom('file', file)
                 return True
         if self._watch_deleted_files:
             deleted_files = self._init_times.keys() - mod_times.keys()
             for file in deleted_files:
                 self.print_out_dark(f'{label} [-] File deleted: {file}')
+                self.set_task_xcom('deleted-file', file)
+                self.set_task_xcom('file', file)
                 return True
         if self._watch_modified_files:
             modified_files = {
@@ -119,12 +150,22 @@ class PathWatcher(Checker):
             }
             for file in modified_files:
                 self.print_out_dark(f'{label} [/] File modified: {file}')
+                self.set_task_xcom('modified-file', file)
+                self.set_task_xcom('file', file)
                 return True
         self.show_progress(f'{label} (Nothing changed)')
         return False
 
     def _get_mod_times(self) -> Mapping[str, float]:
-        return {
-            file_name: os.stat(file_name).st_mtime
-            for file_name in glob.glob(self._rendered_path, recursive=True)
-        }
+        matches = get_file_names(
+            glob_path=self._rendered_path,
+            glob_ignored_paths=self._rendered_ignored_paths
+        )
+        mod_times: Mapping[str, float] = {}
+        for file_name in matches:
+            try:
+                mod_time = os.stat(file_name).st_mtime
+                mod_times[file_name] = mod_time
+            except Exception as e:
+                self.print_err(e)
+        return mod_times