idmtools-test 0.0.0.dev0__py3-none-any.whl → 0.0.2__py3-none-any.whl

idmtools_test/utils/test_asset_collection.py

@@ -0,0 +1,223 @@
+import os
+import typing
+from typing import NoReturn
+
+from idmtools.assets import TAssetList, TAssetFilterList, TAsset
+from idmtools.assets.errors import DuplicatedAssetError
+from idmtools.core import FilterMode
+from idmtools.core.interfaces.ientity import IEntity
+from idmtools.frozen.frozen_utils import IFrozen
+from idmtools.utils.file import scan_directory
+from idmtools.utils.filters.asset_filters import default_asset_file_filter
+from idmtools_test.utils.test_asset import Asset
+
+
+class AssetCollection(IEntity, IFrozen):
+    """
+    A class that represents a collection of assets.
+    """
+
+    # region Constructors
+    def __init__(self, assets: 'TAssetList' = None):  # noqa: F821
+        """
+        A constructor.
+
+        Args:
+            assets: An optional list of assets to create the collection with.
+        """
+        super().__init__()
+        self.assets = assets or []
+
+    @classmethod
+    def from_directory(cls, assets_directory: str, recursive: bool = True, flatten: bool = False,
+                       filters: 'TAssetFilterList' = None, filters_mode: 'FilterMode' = FilterMode.OR,  # noqa: F821
+                       relative_path: str = None) -> 'TAssetCollection':
+        """
+        Fill up an :class:`AssetCollection` from the specified directory. See
+         :meth:`~AssetCollection.assets_from_directory` for arguments.
+
+        Returns:
+            A created :class:`AssetCollection` object.
+        """
+        assets = cls.assets_from_directory(assets_directory, recursive, flatten, filters, filters_mode, relative_path)
+        return cls(assets=assets)
+
+    # endregion
+
+    @staticmethod
+    def assets_from_directory(assets_directory: 'str', recursive: 'bool' = True, flatten: 'bool' = False,
+                              filters: 'TAssetFilterList' = None,  # noqa: F821
+                              filters_mode: 'FilterMode' = FilterMode.OR,
+                              forced_relative_path: 'str' = None) -> 'TAssetList':  # noqa: F821
+        """
+        Create assets for files in a given directory.
+
+        Args:
+            assets_directory: The root directory of the assets.
+            recursive: True to recursively traverse the subdirectory.
+            flatten: Put all the files in root regardless of whether they were in a subdirectory or not.
+            filters: A list of filters to apply to the assets. The filters are functions taking an
+                :class:`~idmtools.assets.asset.Asset`
+                as argument and returning true or false. True adds the asset to the collection; False filters
+                it out. See :meth:`~idmtools.utils.filters.asset_filters`.
+            filters_mode: When given multiple filters, either OR or AND the results.
+            forced_relative_path: Prefix a relative path to the path created from the root directory.
+
+        Examples:
+            For **relative_path**, given the following folder structure root/a/1,txt root/b.txt and relative_path="test".
+            Will return assets with relative path: test/a/1,txt and test/b.txt
+
+            Given the previous example, if flatten is also set to True, the following relative_path will be set:
+            /1.txt and /b.txt
+
+        Returns:
+            A list of assets.
+        """
+        found_assets = []
+        for entry in scan_directory(assets_directory, recursive):
+            relative_path = os.path.relpath(os.path.dirname(entry.path), assets_directory)
+            found_assets.append(Asset(absolute_path=os.path.abspath(entry.path),
+                                      relative_path=None if relative_path == "." else relative_path,
+                                      filename=entry.name))
+
+        # Apply the default filter
+        found_assets = list(filter(default_asset_file_filter, found_assets))
+
+        # Operations on assets (filter, flatten, force relative_path)
+        assets = []
+        for asset in found_assets:
+            if filters:
+                results = [f(asset) for f in filters]
+                if filters_mode == FilterMode.OR and not any(results):
+                    continue
+                if filters_mode == FilterMode.AND and not all(results):
+                    continue
+
+            if flatten:
+                asset.relative_path = None
+
+            if forced_relative_path:
+                asset.relative_path = os.path.join(forced_relative_path, asset.relative_path)
+
+            assets.append(asset)
+
+        return assets
+
+    def add_directory(self, assets_directory: 'str', recursive: 'bool' = True, flatten: 'bool' = False,
+                      filters: 'TAssetFilterList' = None, filters_mode: 'FilterMode' = FilterMode.OR,  # noqa: F821
+                      relative_path: 'str' = None):
+        """
+        Retrieve assets from the specified directory and add them to the collection.
+        See :meth:`~AssetCollection.assets_from_directory` for arguments.
+        """
+        assets = AssetCollection.assets_from_directory(assets_directory, recursive, flatten, filters, filters_mode,
+                                                       relative_path)
+        for asset in assets:
+            self.add_asset(asset)
+
+    def add_asset(self, asset: 'TAsset', fail_on_duplicate: 'bool' = True):  # noqa: F821
+        """
+        Add an asset to the collection.
+
+        Args:
+           asset: An :class:`~idmtools.assets.asset.Asset` object to add.
+           fail_on_duplicate: Raise a **DuplicateAssetError** if an asset is duplicated.
+              If not, simply replace it.
+        """
+        if asset in self.assets:
+            if fail_on_duplicate:
+                raise DuplicatedAssetError(asset)
+            else:
+                # The equality not considering the content of the asset, even if it is already present
+                # nothing guarantees that the content is the same. So remove and add the fresh one.
+                self.assets.remove(asset)
+        self.assets.append(asset)
+
+    def get_one(self, **kwargs):
+        """
+        Get an asset out of the collection based on the filers passed.
+        Examples:
+            >>> a = AssetCollection()
+            >>> a.get_one(filename="filename.txt")
+        Args:
+            **kwargs:  keyword argument representing the filters.
+
+        Returns: None or Asset if found
+
+        """
+        try:
+            return next(filter(lambda a: all(getattr(a, k) == kwargs.get(k) for k in kwargs), self.assets))
+        except StopIteration:
+            return None
+
+    def delete(self, **kwargs) -> 'NoReturn':
+        """
+        Delete an asset based on keywords attributes
+
+        Args:
+            **kwargs: Filter for the asset to delete.
+        """
+        if 'index' in kwargs:
+            return self.assets.remove(self.assets[kwargs.get('index')])
+
+        if 'asset' in kwargs:
+            return self.assets.remove(kwargs.get('asset'))
+
+        asset = self.get_one(**kwargs)
+        if asset:
+            self.assets.remove(asset)
+
+    def pop(self, **kwargs) -> 'TAsset':
+        """
+        Get and delete an asset based on keywords.
+        Args:
+            **kwargs: Filter for the asset to pop.
+
+        """
+        if not kwargs:
+            return self.assets.pop()
+
+        asset = self.get_one(**kwargs)
+        if asset:
+            self.assets.remove(asset)
+        return asset
+
+    def extend(self, assets: 'TAssetList', fail_on_duplicate: 'bool' = True) -> 'NoReturn':
+        """
+        Extend the collection with new assets
+        Args:
+            assets: Which assets to add
+            fail_on_duplicate: Fail if duplicated asset is included.
+
+        """
+        for asset in assets:
+            self.add_asset(asset, fail_on_duplicate)
+
+    def clear(self):
+        self.assets.clear()
+
+    def set_all_persisted(self):
+        for a in self:
+            a.persisted = True
+
+    @property
+    def count(self):
+        return len(self.assets)
+
+    @IEntity.uid.getter
+    def uid(self):
+        if self.count == 0:
+            return None
+        return super().uid
+
+    def __len__(self):
+        return len(self.assets)
+
+    def __getitem__(self, index):
+        return self.assets[index]
+
+    def __iter__(self):
+        yield from self.assets
+
+
+TAssetCollection = typing.TypeVar("TAssetCollection", bound=AssetCollection)

idmtools_test/utils/test_execute_platform.py

@@ -0,0 +1,137 @@
+import copy
+import os
+import shutil
+from concurrent.futures._base import as_completed, Executor
+from concurrent.futures.process import ProcessPoolExecutor
+from concurrent.futures.thread import ThreadPoolExecutor
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import List, Union, Type
+from tqdm import tqdm
+from idmtools.core import ItemType
+from idmtools.entities import Suite
+from idmtools.entities.experiment import Experiment
+from idmtools.entities.iplatform import IPlatform
+from idmtools.entities.iworkflow_item import IWorkflowItem
+from idmtools.entities.platform_requirements import PlatformRequirements
+from idmtools.registry.platform_specification import PlatformSpecification, get_platform_impl, \
+    example_configuration_impl, get_platform_type_impl
+from idmtools.registry.plugin_specification import get_description_impl
+from idmtools_test.utils.execute_operations.experiment_operations import TestExecutePlatformExperimentOperation
+from idmtools_test.utils.execute_operations.simulate_operations import TestExecutePlatformSimulationOperation
+
+supported_types = [PlatformRequirements.SHELL, PlatformRequirements.NativeBinary, PlatformRequirements.PYTHON,
+                   PlatformRequirements.WINDOWS if os.name == "nt" else PlatformRequirements.LINUX]
+
+
+class PoolType(Enum):
+    thread = ThreadPoolExecutor
+    process = ProcessPoolExecutor
+
+
+DEFAULT_OUTPUT_PATH = Path(os.getenv("IDMTOOLS_TEST_EXECUTE_PATH", Path().cwd().joinpath(".test_platform")))
+
+
+def clear_execute_platform():
+    if Path.exists(DEFAULT_OUTPUT_PATH):
+        for file in os.listdir(DEFAULT_OUTPUT_PATH):
+            path = Path(DEFAULT_OUTPUT_PATH).joinpath(file)
+            try:
+                shutil.rmtree(path)
+            except OSError:
+                os.remove(path)
+
+
+@dataclass(repr=False)
+class TestExecutePlatform(IPlatform):
+    _experiments: TestExecutePlatformExperimentOperation = field(
+        default=None, compare=False, metadata={"pickle_ignore": True}, repr=False, init=False
+    )
+    _simulations: TestExecutePlatformSimulationOperation = field(default=None, compare=False, metadata={"pickle_ignore": True},
+                                                                 repr=False, init=False)
+
+    _platform_supports: List[PlatformRequirements] = field(default_factory=lambda: copy.deepcopy(supported_types),
+                                                           repr=False, init=False)
+
+    __test__ = False  # Hide from test discovery
+    execute_directory: str = field(default=DEFAULT_OUTPUT_PATH)
+    pool: Executor = field(default=None, compare=False, metadata={"pickle_ignore": True}, repr=False, init=False)
+    pool_type: PoolType = field(default=PoolType.thread)
+    queue: List = field(default_factory=list, compare=False, metadata={"pickle_ignore": True}, repr=False, init=False)
+    workers: int = field(default=os.cpu_count()-1 if os.cpu_count() > 1 else 1)
+
+    def __post_init__(self):
+        self.init_interfaces()
+        self.supported_types = {ItemType.EXPERIMENT, ItemType.SIMULATION}
+        self.pool = self.pool_type.value(max_workers=self.workers)
+        super().__post_init__()
+
+    def init_interfaces(self):
+        self._experiments = TestExecutePlatformExperimentOperation(self)
+        self._simulations = TestExecutePlatformSimulationOperation(self)
+
+    def post_setstate(self):
+        self.init_interfaces()
+
+    def run_simulations(self, experiment: Experiment) -> None:
+        from idmtools.core import EntityStatus
+        self._simulations.set_simulation_status(experiment.uid, EntityStatus.RUNNING)
+
+    def cleanup(self):
+        self._experiments.experiments = dict()
+        self._simulations.simulations = dict()
+
+    def wait_till_done(self, item: Union[Experiment, IWorkflowItem, Suite], timeout: int = 60 * 60 * 24,
+                       refresh_interval: int = 5, progress=True):
+        for future in as_completed(self.queue):
+            result = future.result()
+            for sim in self._simulations.simulations[result[0]]:
+                if sim.id == result[1]:
+                    sim.status = result[2]
+                    break
+
+    def wait_till_done_progress(self, item: Union[Experiment, IWorkflowItem, Suite], timeout: int = 60 * 60 * 24,
+                                refresh_interval: int = 5):
+        for future in tqdm(as_completed(self.queue), total=len(self.queue)):
+            result = future.result()
+            if isinstance(item, Experiment):
+                for sim in item.simulations:
+                    if sim.id == result[1]:
+                        sim.status = result[2]
+                        self._simulations.save_metadata(sim, update_data=dict(status=result[2]))
+                        break
+        del self.queue
+        self.queue = []
+
+    def __del__(self):
+        self.pool.shutdown(False)
+
+
+class TestExecutePlatformSpecification(PlatformSpecification):
+
+    @get_description_impl
+    def get_description(self) -> str:
+        return "Provides access to the Test Platform to IDM Tools"
+
+    @get_platform_impl
+    def get(self, **configuration) -> IPlatform:
+        """
+        Build our test platform from the passed in configuration object
+
+        We do our import of platform here to avoid any weir
+        Args:
+            configuration:
+
+        Returns:
+
+        """
+        return TestExecutePlatform(**configuration)
+
+    @example_configuration_impl
+    def example_configuration(self):
+        return ""
+
+    @get_platform_type_impl
+    def get_type(self) -> Type[TestExecutePlatform]:
+        return TestExecutePlatform

idmtools_test/utils/test_platform.py

@@ -0,0 +1,94 @@
+import copy
+import os
+from dataclasses import dataclass, field
+from logging import getLogger
+from typing import List, Type
+
+from idmtools.core import ItemType
+from idmtools.entities.experiment import Experiment
+from idmtools.entities.iplatform import IPlatform
+from idmtools.entities.platform_requirements import PlatformRequirements
+from idmtools.registry.platform_specification import example_configuration_impl, get_platform_impl, \
+    get_platform_type_impl, PlatformSpecification
+from idmtools.registry.plugin_specification import get_description_impl
+from idmtools_test.utils.operations.experiment_operations import TestPlatformExperimentOperation
+from idmtools_test.utils.operations.simulation_operations import TestPlatformSimulationOperation
+
+logger = getLogger(__name__)
+current_directory = os.path.dirname(os.path.realpath(__file__))
+data_path = os.path.abspath(os.path.join(current_directory, "..", "data"))
+
+supported_types = [PlatformRequirements.SHELL, PlatformRequirements.NativeBinary, PlatformRequirements.PYTHON,
+                   PlatformRequirements.WINDOWS if os.name == "nt" else PlatformRequirements.LINUX]
+
+
+@dataclass(repr=False)
+class TestPlatform(IPlatform):
+    """
+    Test platform simulating a working platform to use in the test suites.
+    """
+
+    _experiments: TestPlatformExperimentOperation = field(default=None, compare=False, metadata={"pickle_ignore": True},
+                                                         repr=False, init=False)
+    _simulations: TestPlatformSimulationOperation = field(default=None, compare=False, metadata={"pickle_ignore": True},
+                                                         repr=False, init=False)
+
+    _platform_supports: List[PlatformRequirements] = field(default_factory=lambda: copy.deepcopy(supported_types),
+                                                           repr=False, init=False)
+
+    __test__ = False  # Hide from test discovery
+
+    def __post_init__(self):
+        self.init_interfaces()
+        self.supported_types = {ItemType.EXPERIMENT, ItemType.SIMULATION}
+        super().__post_init__()
+
+    def init_interfaces(self):
+        self._experiments = TestPlatformExperimentOperation(self)
+        self._simulations = TestPlatformSimulationOperation(self)
+
+    def post_setstate(self):
+        self.init_interfaces()
+
+    def run_simulations(self, experiment: Experiment) -> None:
+        from idmtools.core import EntityStatus
+        self._simulations.set_simulation_status(experiment.uid, EntityStatus.RUNNING)
+
+    def cleanup(self):
+        self._experiments.experiments = dict()
+        self._simulations.simulations = dict()
+
+
+TEST_PLATFORM_EXAMPLE_CONFIG = """
+[Test]
+
+"""
+
+
+class TestPlatformSpecification(PlatformSpecification):
+
+    @get_description_impl
+    def get_description(self) -> str:
+        return "Provides access to the Test Platform to IDM Tools"
+
+    @get_platform_impl
+    def get(self, **configuration) -> IPlatform:
+        """
+        Build our test platform from the passed in configuration object
+
+        We do our import of platform here to avoid any weir
+        Args:
+            configuration:
+
+        Returns:
+
+        """
+        return TestPlatform(**configuration)
+
+    @example_configuration_impl
+    def example_configuration(self):
+        return TEST_PLATFORM_EXAMPLE_CONFIG
+
+    @get_platform_type_impl
+    def get_type(self) -> Type[TestPlatform]:
+        return TestPlatform

idmtools_test/utils/test_task.py

@@ -0,0 +1,69 @@
+import json
+from dataclasses import dataclass, field
+from typing import Type
+
+from idmtools.assets import Asset, AssetCollection
+from idmtools.entities import CommandLine
+from idmtools.entities.itask import ITask
+from idmtools.entities.simulation import Simulation
+from idmtools.registry.task_specification import TaskSpecification
+
+
+@dataclass(repr=False)
+class TestTask(ITask):
+    command: CommandLine = field(default=None, metadata={"md": True})
+    parameters: dict = field(default_factory=lambda: {}, metadata={"md": True})
+    common_asset_paths: list = field(default_factory=lambda: [])
+
+    __test__ = False  # Hide from test discovery
+
+    def __post_init__(self):
+        if self.command is None:
+            self.command = CommandLine.from_string('echo this is a test')
+
+    def set_parameter(self, name: str, value: any) -> dict:
+        self.parameters[name] = value
+        return {"name": value}
+
+    def get_parameter(self, name, default=None):
+        """
+        Get a parameter in the simulation
+        Args:
+            name: Name of the parameter
+        Returns:the Value of the parameter
+        """
+        return self.parameters.get(name, default)
+
+    def update_parameters(self, params):
+        """
+        Bulk update parameters
+        Args:
+            params: dict with new values
+        Returns:None
+        """
+        self.parameters.update(params)
+
+    def gather_common_assets(self) -> AssetCollection:
+        # modified for test (uid hashing means changing uids) copied version from python_task.py
+        assets = [Asset(absolute_path=path) for path in self.common_asset_paths]
+        return AssetCollection(assets=assets)
+
+    def gather_transient_assets(self) -> AssetCollection:
+        if not self.transient_assets.has_asset(filename="config.json"):
+            self.transient_assets.add_asset(Asset(filename="config.json", content=json.dumps(self.parameters)))
+        return self.transient_assets
+
+    def reload_from_simulation(self, simulation: 'Simulation'):
+        pass
+
+
+class TestTaskSpecification(TaskSpecification):
+
+    def get(self, configuration: dict) -> TestTask:
+        return TestTask(**configuration)
+
+    def get_description(self) -> str:
+        return "Defines a task that is just used for testing purposes"
+
+    def get_type(self) -> Type[TestTask]:
+        return TestTask

idmtools_test/utils/utils.py

@@ -0,0 +1,146 @@
+import sys
+from io import StringIO
+from contextlib import contextmanager
+import os
+import shutil
+import subprocess
+import pandas as pd
+from idmtools.entities.simulation import Simulation
+
+
+def get_case_name(name: str):
+    """
+    Add prefix from environment var to names of experiments
+    Args:
+        name:
+
+    Returns:
+
+    """
+    if os.environ.get("IDMTOOLS_TEST_PREFIX", None):
+        return f'{os.environ["IDMTOOLS_TEST_PREFIX"]}.{name}'
+    return name
+
+
+def del_folder(path: str):
+    """
+    Delete Folder
+
+    Args:
+        path: Path to delete
+
+    Returns:
+
+    """
+    if os.path.exists(path):
+        shutil.rmtree(path)
+
+
+def del_file(filename: str, dir: str = None):
+    """
+    Delete a file
+
+    Args:
+        filename: Filename
+        dir: Optional Directory
+
+    Returns:
+
+    """
+    if dir:
+        filepath = os.path.join(dir, filename)
+    else:
+        filepath = os.path.join(os.path.curdir, filename)
+
+    if os.path.exists(filepath):
+        print(filepath)
+        os.remove(filepath)
+
+
+def load_csv_file(filename: str, dir: str = None) -> pd.DataFrame():
+    """
+    Load CSV File
+
+    Args:
+        filename: Filename
+        dir: Optional Directory
+
+    Returns:
+
+    """
+    df = None
+    if dir:
+        filepath = os.path.join(dir, filename)
+    else:
+        filepath = os.path.join(os.path.curdir, filename)
+
+    if os.path.exists(filepath):
+        df = pd.read_csv(filepath)
+    return df
+
+
+def verify_simulation(simulation: Simulation, expected_parameters, expected_values):
+    for value_set in expected_values:
+        for i, value in enumerate(list(value_set)):
+            if not simulation.task.parameters[expected_parameters[i]] == expected_values:
+                break
+        return True
+    return False
+
+
+def load_python_files_from_folder(analyzers_folder):
+    for file in os.listdir(analyzers_folder):
+        if '.py' in file:
+            yield file
+
+
+def execute_example(cmd, cwd=None, shell=True):
+    popen_opts = dict(shell=shell)
+    if cwd:
+        popen_opts['cwd'] = cwd
+    popen = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True,
+                             **popen_opts)
+    for stdout_line in iter(popen.stdout.readline, ""):
+        print(stdout_line.strip())
+    popen.stdout.close()
+    return_code = popen.wait()
+    if return_code:
+        raise subprocess.CalledProcessError(return_code, cmd)
+    return return_code
+
+
+def test_example_folder(tc, analyzers_folder):
+    for file in load_python_files_from_folder(analyzers_folder):
+        with tc.subTest(file):
+            working_directory = analyzers_folder
+            try:
+                print(f'Running example: python {file}')
+                result = execute_example(f'python {file}', cwd=working_directory, shell=True)
+                tc.assertEqual(result, 0)
+            except subprocess.CalledProcessError as e:
+                tc.assertEqual(result, e.returncode, f'Result for example {file} failed. See {e.output}')
+
+
+@contextmanager
+def captured_output():
+    new_out, new_err = StringIO(), StringIO()
+    old_out, old_err = sys.stdout, sys.stderr
+    try:
+        sys.stdout, sys.stderr = new_out, new_err
+        yield sys.stdout, sys.stderr
+    finally:
+        sys.stdout, sys.stderr = old_out, old_err
+
+
+def is_global_configuration_enabled() -> bool:
+    from idmtools import IdmConfigParser
+    return os.path.exists(IdmConfigParser.get_global_configuration_name()) or os.environ.get("IDMTOOLS_CONFIG_FILE", None) is not None
+
+
+def get_performance_scale() -> int:
+    try:
+        scale = int(os.getenv("IDMTOOLS_TEST_SCALE", "1"))
+    except:
+        scale = 1
+    return scale
+