idmtools-platform-general 0.0.0.dev0__py3-none-any.whl → 0.0.2__py3-none-any.whl

idmtools_platform_file/tools/job_history.py

@@ -0,0 +1,334 @@
+"""
+idmtools JobHistory Utility.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""
+import diskcache
+from pathlib import Path
+from datetime import datetime
+from typing import NoReturn, Dict, Tuple, List
+from idmtools.core import ItemType
+from idmtools.core.platform_factory import Platform
+from idmtools.entities.experiment import Experiment
+from idmtools_platform_container.utils.general import normalize_path, is_valid_uuid
+from logging import getLogger
+
+logger = getLogger(__name__)
+user_logger = getLogger('user')
+
+JOB_HISTORY_DIR = "idmtools_experiment_history"
+
+
+def initialize():
+    """
+    Initialization decorator for JobHistory.
+    Returns:
+        Wrapper function
+    """
+
+    def wrap(func):
+        def wrapped_f(*args, **kwargs):
+            JobHistory.initialization()
+            value = func(*args, **kwargs)
+            return value
+
+        return wrapped_f
+
+    return wrap
+
+
+class JobHistory:
+    """Job History Utility for idmtools Container Platform."""
+    history = None
+    history_path = Path.home().joinpath(".idmtools").joinpath(JOB_HISTORY_DIR)
+
+    @classmethod
+    def initialization(cls):
+        """Initialize JobHistory."""
+        if cls.history is None:
+            cls.history_path.mkdir(parents=True, exist_ok=True)
+            cls.history = diskcache.Cache(str(cls.history_path))
+
+    @classmethod
+    @initialize()
+    def save_job(cls, job_dir: str, container_id: str, experiment: Experiment, platform=None) -> NoReturn:
+        """
+        Save job to history.
+        Args:
+            job_dir: job directory
+            container_id: container id
+            experiment: Experiment
+            platform: Platform
+        Returns:
+            NoReturn
+        """
+        cache = cls.history
+
+        if platform is None:
+            platform = Platform("File", job_directory=job_dir)
+
+        # Get current datetime
+        current_datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        if experiment.parent:
+            new_item = {"JOB_DIRECTORY": normalize_path(job_dir),
+                        "SUITE_NAME": experiment.parent.name,
+                        "SUITE_ID": experiment.parent_id,
+                        "EXPERIMENT_DIR": normalize_path(platform.get_directory(experiment)),
+                        "EXPERIMENT_NAME": experiment.name,
+                        "EXPERIMENT_ID": experiment.id,
+                        "CONTAINER": container_id,
+                        "CREATED": current_datetime}
+        else:
+            new_item = {"JOB_DIRECTORY": normalize_path(job_dir),
+                        "EXPERIMENT_DIR": normalize_path(platform.get_directory(experiment)),
+                        "EXPERIMENT_NAME": experiment.name,
+                        "EXPERIMENT_ID": experiment.id,
+                        "CONTAINER": container_id,
+                        "CREATED": current_datetime}
+        cache.set(experiment.id, new_item)
+        cache.close()
+
+    @classmethod
+    @initialize()
+    def get_job(cls, exp_id: str) -> Dict:
+        """
+        Get job from history.
+        Args:
+            exp_id: Experiment ID
+        Returns:
+            job data in dict
+        """
+        if not is_valid_uuid(exp_id):
+            return None
+
+        cache = cls.history
+        value, expire_time = cache.get(exp_id, expire_time=True)
+        if value is None:
+            if exp_id in list(cache):
+                logger.debug(f"Item {exp_id} expired.")
+            else:
+                logger.debug(f"Item {exp_id} not found.")
+        else:
+            local_expire_time = datetime.fromtimestamp(expire_time) if expire_time else None
+            expire_time_str = local_expire_time.strftime('%Y-%m-%d %H:%M:%S') if local_expire_time else None
+            if expire_time_str:
+                value['EXPIRE'] = expire_time_str
+
+        return value
+
+    @classmethod
+    def get_job_dir(cls, exp_id: str) -> str:
+        """
+        Get job directory from history.
+        Args:
+            exp_id: Experiment ID
+        Returns:
+            job directory
+        """
+        if not is_valid_uuid(exp_id):
+            user_logger.info(f"Invalid item id: {exp_id}")
+            return None
+
+        data = cls.get_job(exp_id)
+        if data is None:
+            return None
+        return data['JOB_DIRECTORY']
+
+    @classmethod
+    @initialize()
+    def get_item_path(cls, item_id: str) -> Tuple:
+        """
+        Get item path from history.
+        Args:
+            item_id: Suite/Experiment/Simulation ID
+        Returns:
+            item path, item type
+        """
+        if not is_valid_uuid(item_id):
+            logger.debug(f"Invalid item id: {item_id}")
+            return
+
+        cache = cls.history
+        item = cache.get(item_id)
+        # Consider Experiment case
+        if item:
+            return Path(item['EXPERIMENT_DIR']), ItemType.EXPERIMENT
+
+        for key in cache:
+            value = cache.get(key)
+            suite_id = value.get('SUITE_ID')
+            exp_dir = value.get('EXPERIMENT_DIR')
+
+            # Consider Suite case
+            if suite_id == item_id:
+                return Path(exp_dir).parent, ItemType.SUITE
+
+            # Consider Simulation case
+            pattern = f'*{item_id}/metadata.json'
+            for meta_file in Path(exp_dir).glob(pattern=pattern):
+                sim_dir = meta_file.parent
+                return sim_dir, ItemType.SIMULATION
+
+        return None
+
+    @classmethod
+    @initialize()
+    def view_history(cls, container_id: str = None) -> List:
+        """
+        View job history.
+        Args:
+            container_id: Container ID
+        Returns:
+            list of job data
+        """
+        cache = cls.history
+        data = []
+        for key in cache:
+            value, expire_time = cache.get(key, expire_time=True)
+            if value is None:
+                if key in list(cache):
+                    user_logger.info(f"Item {key} expired.")
+                else:
+                    user_logger.info(f"Item {key} not found.")
+                continue
+
+            local_expire_time = datetime.fromtimestamp(expire_time) if expire_time else None
+            expire_time_str = local_expire_time.strftime('%Y-%m-%d %H:%M:%S') if local_expire_time else None
+            if expire_time_str:
+                value['EXPIRE'] = expire_time_str
+
+            if container_id is not None:
+                if value['CONTAINER'] == container_id:
+                    data.append(value)
+            else:
+                data.append(value)
+
+        # Sort data by datetime
+        sorted_data = sorted(data, key=lambda x: datetime.strptime(x["CREATED"], "%Y-%m-%d %H:%M:%S"), reverse=True)
+        return sorted_data
+
+    @classmethod
+    @initialize()
+    def delete(cls, exp_id: str) -> NoReturn:
+        """
+        Delete job from history.
+        Args:
+            exp_id: Experiment ID
+        Returns:
+            NoReturn
+        """
+        cache = cls.history
+        cache.pop(exp_id)
+        cache.close()
+
+    @classmethod
+    @initialize()
+    def expire_history(cls, dt: str = None) -> NoReturn:
+        """
+        Expire job history based on the input expiration time.
+        Args:
+            dt: datetime to expire (format like "2024-07-30 15:12:05")
+        Returns:
+            NoReturn
+        """
+        from datetime import datetime
+        # Parse the datetime string into a datetime object
+        dt_object = datetime.strptime(dt, '%Y-%m-%d %H:%M:%S') if dt else None
+
+        # Convert the datetime object to a timestamp (seconds since epoch)
+        timestamp = dt_object.timestamp() if dt_object else None
+
+        cache = cls.history
+        cache.expire(now=timestamp)
+        cache.close()
+
+    @classmethod
+    @initialize()
+    def clear(cls, container_id: str = None) -> NoReturn:
+        """
+        Clear job history.
+        Args:
+            container_id: Container ID
+        Returns:
+            NoReturn
+        """
+        cache = cls.history
+        if container_id is None:
+            cache.clear()
+        else:
+            for key in cache:
+                value = cache.get(key)
+                if value is None:
+                    user_logger.info(f"key {key} not found in cache")
+                    continue
+                if value['CONTAINER'] == container_id:
+                    cache.delete(key)
+
+        cache.close()
+
+    @classmethod
+    @initialize()
+    def volume(cls) -> NoReturn:
+        """Clear job history."""
+        cache = cls.history
+        return cache.volume()
+
+    @classmethod
+    @initialize()
+    def sync(cls) -> NoReturn:
+        """Sync job history."""
+        cache = cls.history
+        for key in cache:
+            value = cache.get(key)
+            exp_dir = value.get('EXPERIMENT_DIR')
+
+            root = Path(exp_dir)
+            if not root.exists():
+                cache.pop(key)
+                logger.debug(f"Remove job {key} from job history.")
+
+        cache.close()
+
+    @classmethod
+    @initialize()
+    def count(cls, container_id: str = None) -> int:
+        """
+        Count job history.
+        Args:
+            container_id: Container ID
+        Returns:
+            job history count
+        """
+        if container_id is None:
+            return len(cls.history)
+        else:
+            jobs = [key for key in cls.history if cls.history[key]['CONTAINER'] == container_id]
+            return len(jobs)
+
+    @classmethod
+    @initialize()
+    def container_history(cls) -> List:
+        """List of job containers."""
+        cache = cls.history
+        data = {}
+
+        for key in cache:
+            value = cache[key]
+            container_id = value['CONTAINER']
+            if container_id not in data:
+                data[container_id] = []
+            data[container_id].append(key)
+
+        return data
+
+    @classmethod
+    @initialize()
+    def verify_container(cls, container_id) -> bool:
+        """Verify history container."""
+        cache = cls.history
+
+        for key in cache:
+            value = cache[key]
+            if container_id.startswith(value['CONTAINER']):
+                return True
+        return False

idmtools_platform_file/tools/status_report/__init__.py

@@ -0,0 +1,4 @@
+"""idmtools comps utils.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""

idmtools_platform_file/tools/status_report/status_report.py

@@ -0,0 +1,222 @@
+"""
+This is a FilePlatform simulation status utility.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""
+import copy
+import json
+from logging import getLogger
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Dict, List, Tuple, TYPE_CHECKING
+from idmtools.core import ItemType, EntityStatus
+from idmtools.entities.experiment import Experiment
+from idmtools_platform_file.tools.status_report.utils import get_latest_experiment
+from idmtools_platform_file.platform_operations.utils import FILE_MAPS
+
+if TYPE_CHECKING:  # pragma: no cover
+    from idmtools.entities.iplatform import IPlatform
+
+user_logger = getLogger('user')
+
+
+@dataclass(repr=False)
+class StatusReporter:
+    """
+    A class to wrap the functions involved in retrieving simulations status.
+    """
+    platform: 'IPlatform'  # noqa F821
+    scope: Tuple[str, ItemType] = field(default=None)
+
+    _exp: Experiment = field(default=None, init=False, compare=False)
+    _summary: Dict = field(default_factory=dict, init=False, compare=False)
+    _report: Dict = field(default_factory=dict, init=False, compare=False)
+    _pending: List = field(default_factory=list, init=False, compare=False)
+
+    def __post_init__(self):
+        self.initialize()
+
+    def initialize(self) -> None:
+        """
+        Determine the experiment and build dictionary with basic info.
+        Returns:
+            None
+        """
+        if self.scope is not None:
+            item = self.platform.get_item(self.scope[0], self.scope[1])
+            if self.scope[1] == ItemType.SUITE:
+                # Only consider the first experiment
+                self._exp = item.experiments[0]
+            elif self.scope[1] == ItemType.EXPERIMENT:
+                self._exp = item
+            else:
+                raise RuntimeError('Only support Suite/Experiment.')
+        else:
+            exp_dic = get_latest_experiment(self.platform)
+            self._exp = self.platform.get_item(exp_dic['experiment_id'], ItemType.EXPERIMENT)
+            exp_dir = self.platform.get_directory_by_id(exp_dic['experiment_id'], ItemType.EXPERIMENT)
+            last_suite_dir = exp_dir.parent
+
+            user_logger.info('------------------------------')
+            user_logger.info(f'last suite dir: {last_suite_dir}')
+            user_logger.info(f'last experiment dir: {exp_dir}')
+            user_logger.info('------------------------------')
+
+        if self._exp.parent is not None:
+            self._summary = dict(suite=self._exp.parent.id, experiment=self._exp.id,
+                                 job_directory=self.platform.job_directory)
+        else:
+            self._summary = dict(suite=None, experiment=self._exp.id,
+                                 job_directory=self.platform.job_directory)
+
+    def apply_filters(self, status_filter: Tuple[str] = None, sim_filter: Tuple[str] = None,
+                      verbose: bool = True) -> None:
+        """
+        Filter simulations.
+        Args:
+            status_filter: tuple with target status
+            sim_filter: tuple with simulation id
+            verbose: True/False to include simulation directory
+        Returns:
+            None
+        """
+        # Make sure we get the latest status
+        self.platform.refresh_status(self._exp)
+
+        # Filter simulations and format the results
+        _simulations = self._exp.simulations
+        for sim in _simulations:
+            # Apply simulation filter
+            if sim_filter is not None and sim.id not in sim_filter:
+                continue
+
+            sim_dir = self.platform.get_directory(sim)
+            job_status_path = sim_dir.joinpath("job_status.txt")
+            if not job_status_path.exists():
+                self._pending.append(f"    {sim.id}")
+                continue
+
+            status = open(job_status_path).read().strip()
+            # Apply status filter
+            if status_filter is not None and status not in status_filter:
+                continue
+
+            # Format the results
+            d = dict(status=status)
+            if verbose:
+                d["WorkDir"] = str(self.platform.get_directory(sim))
+            self._report[sim.id] = d
+
+    @staticmethod
+    def output_definition() -> None:
+        """
+        Output the status definition.
+        Returns:
+            None
+        """
+        file_map = copy.deepcopy(FILE_MAPS)
+        file_map.pop('None', None)
+        user_logger.info('------------------------------')
+        user_logger.info("STATUS DEFINITION")
+        user_logger.info(f"{'0: '.ljust(20)} {file_map['0'].name}")
+        user_logger.info(f"{'-1: '.ljust(20)} {file_map['-1'].name}")
+        user_logger.info(f"{'100: '.ljust(20)} {file_map['100'].name}")
+        user_logger.info('------------------------------')
+
+    def output_summary(self) -> None:
+        """
+        Output suite/experiment id and job directory.
+        Returns:
+            None
+        """
+        if self._summary:
+            if self._summary['suite'] is not None:
+                user_logger.info(f"{'suite: '.ljust(20)} {self._summary['suite']}")
+            user_logger.info(f"{'experiment: '.ljust(20)} {self._summary['experiment']}")
+            user_logger.info(f"{'job directory: '.ljust(20)} {self._summary['job_directory']}")
+
+    def output_results(self, status_filter: Tuple[str] = None, sim_filter: Tuple[str] = None, verbose: bool = True,
+                       display: bool = True):
+        """
+        Output search results.
+        Args:
+            status_filter: status filter
+            sim_filter: simulation filter
+            verbose: True/False
+            display: True/False
+
+        Returns:
+            None
+        """
+        _status_list = [v["status"] for k, v in self._report.items()]
+        _sim_not_run_list = [sim for sim in self._exp.simulations if sim.status == EntityStatus.CREATED]
+        _simulation_count = len(self._exp.simulations)
+
+        # print report
+        user_logger.info(f"{'status filter: '.ljust(20)} {status_filter}")
+        user_logger.info(f"{'sim filter: '.ljust(20)} {sim_filter}")
+        user_logger.info(f"{'verbose: '.ljust(20)} {verbose}")
+        user_logger.info(f"{'display: '.ljust(20)} {display}")
+        user_logger.info(f"{'Simulation Count: '.ljust(20)} {_simulation_count}")
+        user_logger.info(f"{'Match Count: '.ljust(20)} {len(self._report)} ({dict(Counter(_status_list))})")
+        user_logger.info(f"{'Not Running Count: '.ljust(20)} {len(_sim_not_run_list)}")
+
+        if self._exp.status is None:
+            user_logger.info(f'\nExperiment Status: {None}')
+        else:
+            user_logger.info(f'\nExperiment Status: {self._exp.status.name}')
+
+    def output_status_report(self, status_filter: Tuple[str] = None, sim_filter: Tuple[str] = None,
+                             verbose: bool = True, display: bool = True, display_count: int = 20) -> None:
+        """
+        Output simulations status with possible override parameters.
+        Args:
+            status_filter: tuple with target status
+            sim_filter: tuple with simulation id
+            verbose: True/False to include simulation directory
+            display: True/False to print the searched results
+            display_count: how many to print
+        Returns:
+            None
+        """
+        if status_filter is None:
+            status_filter = ('0', '-1', '100')
+
+        self.apply_filters(status_filter, sim_filter, verbose)
+
+        self.output_summary()
+
+        if display:
+            if display_count is None or len(self._report) <= display_count:
+                report_view_dict = self._report
+            else:
+                report_view_dict = dict(list(self._report.items())[0:display_count])
+            user_logger.info(json.dumps(report_view_dict, indent=3))
+
+        self.output_definition()
+
+        if display and len(self._report) > display_count:
+            user_logger.info(f"ONLY DISPLAY {display_count} ITEMS")
+
+        self.output_results(status_filter, sim_filter, verbose, display)
+
+
+def generate_status_report(platform: 'IPlatform', scope: Tuple[str, ItemType] = None, status_filter: Tuple[str] = None,
+                           sim_filter: Tuple[str] = None, verbose: bool = True, display: bool = True,
+                           display_count: int = 20) -> None:
+    """
+    The entry point of status viewer.
+    Args:
+        platform: idmtools Platform
+        scope: the search base
+        status_filter: tuple with target status
+        sim_filter: tuple with simulation id
+        verbose: True/False to include simulation directory
+        display: True/False to print the search results
+        display_count: how many to print
+    Returns:
+        None
+    """
+    sr = StatusReporter(scope=scope, platform=platform)
+    sr.output_status_report(status_filter=status_filter, sim_filter=sim_filter, verbose=verbose, display=display,
+                            display_count=display_count)