album-solution-api 0.6.0__tar.gz

album-solution-api-0.6.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021, album developers.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

album-solution-api-0.6.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: album-solution-api
+Version: 0.6.0
+Summary: Album is a framework for unifying computational tools across frameworks, languages, and environments.
+Home-page: https://gitlab.com/album-app/album-solution-api
+Author: Kyle Harrington, Jan Philipp Albrecht, Deborah Schmidt
+Maintainer: Kyle Harrington, Jan Philipp Albrecht, Deborah Schmidt
+Maintainer-email: album@kyleharrington.com
+License: MIT
+Project-URL: Source, https://gitlab.com/album-app/album-solution-api
+Project-URL: Tracker, https://gitlab.com/album-app/album-solution-api/issues
+Keywords: virtual,environments,imaging
+Platform: any
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Utilities
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# album-solution-api
+
+Package installed in any Album solution environment. Provides the API for the solution script.

album-solution-api-0.6.0/README.md

@@ -0,0 +1,3 @@
+# album-solution-api
+
+Package installed in any Album solution environment. Provides the API for the solution script.

album-solution-api-0.6.0/pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"

album-solution-api-0.6.0/setup.cfg

@@ -0,0 +1,44 @@
+[metadata]
+name = album-solution-api
+version = 0.6.0
+description = Album is a framework for unifying computational tools across frameworks, languages, and environments.
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://gitlab.com/album-app/album-solution-api
+author = Kyle Harrington, Jan Philipp Albrecht, Deborah Schmidt
+maintainer = Kyle Harrington, Jan Philipp Albrecht, Deborah Schmidt
+maintainer_email = album@kyleharrington.com
+license = MIT
+license_file = LICENSE
+platforms = any
+classifiers = 
+	Development Status :: 3 - Alpha
+	License :: OSI Approved :: MIT License
+	Operating System :: MacOS :: MacOS X
+	Operating System :: Microsoft :: Windows
+	Operating System :: POSIX
+	Programming Language :: Python :: 3.8
+	Programming Language :: Python :: 3.9
+	Programming Language :: Python :: Implementation :: PyPy
+	Topic :: Utilities
+keywords = virtual, environments, imaging
+project_urls = 
+	Source=https://gitlab.com/album-app/album-solution-api
+	Tracker=https://gitlab.com/album-app/album-solution-api/issues
+
+[options]
+package_dir = 
+	=src
+packages = find_namespace:
+python_requires = >=3.6
+
+[options.package_data]
+* = *.json
+
+[options.packages.find]
+where = src
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

album-solution-api-0.6.0/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup()

album-solution-api-0.6.0/src/album/__init__.py

@@ -0,0 +1 @@
+__import__('pkg_resources').declare_namespace(__name__)

album-solution-api-0.6.0/src/album/runner/album_logging.py

@@ -0,0 +1,196 @@
+import logging
+import threading
+from enum import Enum, unique
+
+"""
+Global variable for tracking the currently active logger. Do not use this
+directly instead use get_active_logger()
+"""
+_active_logger = {}
+
+DEBUG = False
+
+
+def thread_stack():
+    global _active_logger
+    thread_id = threading.current_thread().ident
+    if thread_id not in _active_logger:
+        _active_logger[thread_id] = []
+    return _active_logger.get(thread_id)
+
+
+def push_active_logger(logger):
+    """Insert a logger to the _active_logger stack."""
+    thread_stack().insert(0, logger)
+
+
+def get_active_logger():
+    """Return the currently active logger, which is defined globally."""
+    stack = thread_stack()
+    if len(stack) > 0:
+        return stack[0]
+    return logging.getLogger()  # root logger
+
+
+def get_active_logger_in_thread(thread_ident):
+    """Return the currently active logger, which is defined globally."""
+    if thread_ident in _active_logger:
+        stack = _active_logger.get(thread_ident)
+        if len(stack) > 0:
+            return stack[0]
+    return logging.getLogger()  # root logger
+
+
+def pop_active_logger():
+    """Pop the currently active logger from the _active_solution stack."""
+
+    stack = thread_stack()
+    if len(stack) > 0:
+        logger = stack.pop(0)
+        logger.handlers.clear()
+        return logger
+    else:
+        return logging.getLogger()  # root logger
+
+
+@unique
+class LogLevel(Enum):
+    """LogLevel album allows.
+
+    Notes:
+        Only add Names available in python standard logging module.
+
+    """
+    DEBUG = 1
+    INFO = 0
+    WARNING = 2
+    ERROR = 3
+
+
+def to_loglevel(value):
+    """Converts a string value to a @LogLevel.
+
+    Args:
+        value:
+            The string value
+
+    Returns:
+        The LovLevel class enum
+
+    Raises:
+        KeyError when loglevel unknown.
+
+    """
+    try:
+        return LogLevel[value]
+    except KeyError as err:
+        logger = get_active_logger()
+        logger.error('Loglevel %s not allowed or unknown!' % value)
+        raise err
+
+
+def configure_logging(name, loglevel=None, stream_handler=None, formatter_string=None, parent_thread_id=None,
+                      parent_name=None):
+    """Configures a logger with a certain name and loglevel.
+
+        loglevel:
+            The Loglevel to use. Either DEBUG or INFO.
+        name:
+            The name of the logger.
+
+    Returns:
+        The logger object.
+
+    """
+    # create or get currently active logger
+    if parent_thread_id is None:
+        parent = get_active_logger()
+    else:
+        parent = get_active_logger_in_thread(parent_thread_id)
+
+    if not parent_name:
+        parent_name = parent.name
+
+    # if currently active logger has the same name, just return it
+    if parent_name == name:
+        return parent
+
+    # make sure the new logger is registered as a child of the currently active logger in order to propagate logs
+    if parent_name.endswith("." + name):
+        name = parent_name
+    else:
+        if not name.startswith(parent_name + "."):
+            name = parent_name + "." + name
+
+    logger = logging.getLogger(name)
+    if loglevel is None:
+        logger.setLevel(parent.level)
+    else:
+        logger.setLevel(loglevel.name)
+
+    if stream_handler:
+        # create formatter
+        if not formatter_string:
+            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        else:
+            formatter = logging.Formatter(formatter_string)
+        # create console handler and set level to debug
+        # ToDo: different handlers necessary? e.g. logging additional into a file?
+        ch = logging.StreamHandler(stream_handler)
+        ch.setLevel(loglevel.name)
+        ch.setFormatter(formatter)
+        logger.addHandler(ch)
+
+    # push logger if not already active
+    if get_active_logger() != logger:
+        push_active_logger(logger)
+
+    return logger
+
+
+def get_loglevel():
+    """Returns the loglevel of the current active logger."""
+    return get_active_logger().level
+
+
+def get_loglevel_name():
+    """Returns the Name of the loglevel of the current active logger."""
+    logger = get_active_logger()
+    return logging.getLevelName(logger.level)
+
+
+def set_loglevel(loglevel):
+    """ Sets logLevel for a logger with a certain name for ALL available handlers.
+
+    Args:
+        loglevel:
+            The Loglevel to use. Either DEBUG or INFO.
+
+    """
+    # logger loglevel
+    active_logger = get_active_logger()
+    active_logger.debug('Set loglevel to %s...' % loglevel.name)
+
+    active_logger.setLevel(loglevel.name)
+
+    # set handler loglevel
+    for handler in active_logger.handlers:
+        handler_name = handler.stream.name if hasattr(handler, "stream") and hasattr(handler.stream,
+                                                                                     active_logger.name) else "default handler"
+        active_logger.debug('Set loglevel for handler %s to %s...' % (handler_name, loglevel.name))
+        handler.setLevel(loglevel.name)
+
+
+class LogEntry:
+    name = None
+    level = None
+    message = None
+
+    def __init__(self, name, level, message):
+        self.name = name
+        self.level = level
+        self.message = message
+
+
+def debug_settings():
+    return DEBUG

album-solution-api-0.6.0/src/album/runner/api.py

@@ -0,0 +1,187 @@
+import os
+import sys
+import tarfile
+from pathlib import Path
+from typing import Optional
+from urllib.request import urlretrieve
+
+from album.runner import album_logging
+from album.runner.album_logging import get_active_logger, configure_logging
+from album.runner.core.api.model.solution import ISolution
+from album.runner.core.default_values_runner import DefaultValuesRunner
+from album.runner.core.model.solution import Solution
+from album.runner.core.model.solution_script import SolutionScript
+
+
+def download_if_not_exists(url, file_name):
+    """Downloads resource if not already cached and returns local resource path.
+
+    Args:
+        url: The URL of the download.
+        file_name: The local filename of the download.
+
+    Returns: The path to the downloaded resource.
+
+    """
+    download_dir = get_cache_path()
+    download_path = download_dir.joinpath(file_name)
+
+    if download_path.exists():
+        get_active_logger().info(f"Found cache of {url}: {download_path}...")
+        return download_path
+    if not download_dir.exists():
+        download_dir.mkdir(parents=True)
+
+    get_active_logger().info(f"Downloading {url} to {download_path}...")
+
+    urlretrieve(url, download_path)
+
+    return download_path
+
+
+def extract_tar(in_tar, out_dir):
+    """
+
+    Args:
+        out_dir: Directory where the TAR file should be extracted to
+        in_tar: TAR file to be extracted
+    """
+    out_path = Path(out_dir)
+
+    if not out_path.exists():
+        out_path.mkdir(parents=True)
+
+    get_active_logger().info(f"Extracting {in_tar} to {out_dir}...")
+
+    my_tar = tarfile.open(in_tar)
+    my_tar.extractall(out_dir)
+    my_tar.close()
+
+
+# todo: extract_zip
+
+
+def get_environment_path() -> Path:
+    """Returns the path of the environment the solution runs in."""
+    active_solution = get_active_solution()
+    res = active_solution.installation().environment_path()
+    return Path(res) if res else res
+
+
+def get_data_path() -> Path:
+    """Returns the data path provided for the solution."""
+    active_solution = get_active_solution()
+    res = active_solution.installation().data_path()
+    return Path(res) if res else res
+
+
+def get_package_path() -> Path:
+    """Returns the package path provided for the solution."""
+    active_solution = get_active_solution()
+    res = active_solution.installation().package_path()
+    return Path(res) if res else res
+
+
+def get_app_path() -> Path:
+    """Returns the app path provided for the solution."""
+    active_solution = get_active_solution()
+    res = active_solution.installation().app_path()
+    return Path(res) if res else res
+
+
+def get_cache_path() -> Path:
+    """Returns the cache path provided for the solution."""
+    active_solution = get_active_solution()
+    res = active_solution.installation().user_cache_path()
+    return Path(res) if res else res
+
+
+def in_target_environment() -> bool:
+    """Gives the boolean information whether or not current python is the python from the album target environment.
+
+    Returns:
+        True when current active python is the album target environment else False.
+
+    """
+    active_solution = get_active_solution()
+
+    return True if sys.executable.startswith(
+        active_solution.installation().environment_path()) else False
+
+
+def get_args():
+    """Get the parsed argument from the solution call.
+
+    Returns:
+        The namespace object of the parsed arguments.
+
+    """
+    active_solution = get_active_solution()
+
+    return active_solution.args()
+
+
+"""
+Global variable for tracking the currently active solution. Do not use this 
+directly instead use get_active_solution()
+"""
+_active_solution = []
+
+enc = sys.getfilesystemencoding()
+
+
+def setup(**attrs):
+    """This configures a solution for the use by the main album tool."""
+    global _active_solution
+    loglevel = os.getenv(DefaultValuesRunner.env_variable_logger_level.value, "INFO")
+    configure_logging("script", loglevel=album_logging.to_loglevel(loglevel),
+                      stream_handler=sys.stdout, formatter_string=SolutionScript.get_script_logging_formatter_str())
+    next_solution = Solution(attrs)
+    push_active_solution(next_solution)
+    goal = os.getenv(DefaultValuesRunner.env_variable_action.value, None)
+    if goal:
+        goal = Solution.Action[goal]
+    package_path = os.getenv(DefaultValuesRunner.env_variable_package.value, os.path.abspath(__file__))
+    if package_path:
+        package_path = Path(package_path)
+    installation_base_path = os.getenv(DefaultValuesRunner.env_variable_installation.value, None)
+    if installation_base_path:
+        installation_base_path = Path(installation_base_path)
+    environment_path = os.getenv(DefaultValuesRunner.env_variable_environment.value, None)
+    if environment_path:
+        environment_path = Path(environment_path)
+    if goal:
+        next_solution.installation().set_package_path(package_path)
+        SolutionScript.trigger_solution_goal(next_solution, goal, package_path, installation_base_path, environment_path)
+
+
+def push_active_solution(solution_object: ISolution):
+    """Pop a solution to the _active_solution stack."""
+    global _active_solution
+    _active_solution.insert(0, solution_object)
+
+
+def get_parent_solution() -> Optional[ISolution]:
+    """Return the parent solution of the currently active solution."""
+    global _active_solution
+    if len(_active_solution) > 1:
+        return _active_solution[1]
+    return None
+
+
+def get_active_solution() -> Optional[ISolution]:
+    """Return the currently active solution, which is defined globally."""
+    global _active_solution
+    if len(_active_solution) > 0:
+        return _active_solution[0]
+    return None
+
+
+def pop_active_solution():
+    """Pop the currently active solution from the _active_solution stack."""
+    global _active_solution
+
+    if len(_active_solution) > 0:
+        return _active_solution.pop(0)
+    else:
+        return None

album-solution-api-0.6.0/src/album/runner/core/api/model/coordinates.py

@@ -0,0 +1,18 @@
+from abc import ABCMeta, abstractmethod
+
+
+class ICoordinates:
+
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def name(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def group(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def version(self):
+        raise NotImplementedError

album-solution-api-0.6.0/src/album/runner/core/api/model/solution.py

@@ -0,0 +1,103 @@
+from abc import ABCMeta, abstractmethod
+from enum import Enum
+from pathlib import Path
+from typing import List
+
+from album.runner.core.api.model.coordinates import ICoordinates
+
+
+class ISolution:
+
+    __metaclass__ = ABCMeta
+
+    class Action(Enum):
+        NO_ACTION = 0
+        INSTALL = 1
+        RUN = 2
+        TEST = 3
+        UNINSTALL = 4
+
+    class ISetup(dict):
+        __metaclass__ = ABCMeta
+        __getattr__ = dict.get
+        __setattr__ = dict.__setitem__
+        __delattr__ = dict.__delitem__
+
+    class IInstallation:
+        __metaclass__ = ABCMeta
+
+        @abstractmethod
+        def environment_path(self) -> Path:
+            raise NotImplementedError
+
+        @abstractmethod
+        def user_cache_path(self) -> Path:
+            raise NotImplementedError
+
+        @abstractmethod
+        def internal_cache_path(self) -> Path:
+            raise NotImplementedError
+
+        @abstractmethod
+        def package_path(self) -> Path:
+            raise NotImplementedError
+
+        @abstractmethod
+        def data_path(self) -> Path:
+            raise NotImplementedError
+
+        @abstractmethod
+        def app_path(self) -> Path:
+            raise NotImplementedError
+
+        @abstractmethod
+        def installation_path(self) -> Path:
+            raise NotImplementedError
+
+        @abstractmethod
+        def set_environment_path(self, path: Path):
+            raise NotImplementedError
+
+        @abstractmethod
+        def set_package_path(self, package_path: Path):
+            raise NotImplementedError
+
+        @abstractmethod
+        def set_installation_path(self, solution_base_path: Path):
+            raise NotImplementedError
+
+    @abstractmethod
+    def setup(self) -> ISetup:
+        raise NotImplementedError
+
+    @abstractmethod
+    def installation(self) -> IInstallation:
+        raise NotImplementedError
+
+    @abstractmethod
+    def coordinates(self) -> ICoordinates:
+        raise NotImplementedError
+
+    @abstractmethod
+    def script(self) -> Path:
+        raise NotImplementedError
+
+    @abstractmethod
+    def args(self) -> List:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_arg(self, name: str):
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_identifier(self) -> str:
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_script(self, script: str):
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_args(self, args: List):
+        raise NotImplementedError

album-solution-api-0.6.0/src/album/runner/core/default_values_runner.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+
+class DefaultValuesRunner(Enum):
+    """Add an entry here to initialize default attributes for a album runner instance."""
+
+    solution_app_prefix = "app"  # solution specific app files
+    solution_data_prefix = "data"  # solution specific data files
+    solution_internal_cache_prefix = (
+        "icache"  # solution specific album internal cache files
+    )
+    solution_user_cache_prefix = (
+        "ucache"  # solution specific user cache files, accessible via runner API
+    )
+
+    env_variable_action = "ALBUM_SOLUTION_ACTION"
+    env_variable_logger_level = "ALBUM_LOGGER_LEVEL"
+    env_variable_package = "ALBUM_SOLUTION_PACKAGE"
+    env_variable_installation = "ALBUM_SOLUTION_INSTALLATION"
+    env_variable_environment = "ALBUM_SOLUTION_ENVIRONMENT"

album-solution-api-0.6.0/src/album/runner/core/model/coordinates.py

@@ -0,0 +1,31 @@
+from album.runner.core.api.model.coordinates import ICoordinates
+
+
+class Coordinates(ICoordinates):
+    """Class for the Coordinates of a solution."""
+
+    def __init__(self, group: str, name: str, version: str) -> None:
+        self._group = group
+        self._name = name
+        self._version = version
+
+
+    def name(self):
+        return self._name
+
+    def group(self):
+        return self._group
+
+    def version(self):
+        return self._version
+
+    def __str__(self) -> str:
+        return f"{self._group}:{self._name}:{self._version}"
+
+    def __eq__(self, o: object) -> bool:
+        return isinstance(
+            o, ICoordinates
+        ) and o.group() == self._group and o.name() == self._name and o.version() == self._version
+
+    def __hash__(self):
+        return hash(self.__str__())

album-solution-api-0.6.0/src/album/runner/core/model/solution.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+from typing import List
+
+from album.runner.core.api.model.coordinates import ICoordinates
+from album.runner.core.api.model.solution import ISolution
+from album.runner.core.default_values_runner import DefaultValuesRunner
+from album.runner.core.model.coordinates import Coordinates
+
+
+class Solution(ISolution):
+    """Encapsulates a album solution configuration."""
+
+    class Setup(ISolution.ISetup):
+
+        def __init__(self, attrs=None):
+            """sets object attributes
+
+            Args:
+                attrs:
+                    Dictionary containing the attributes.
+            """
+            if attrs:
+                super().__init__(attrs)
+            else:
+                super().__init__()
+
+        def __str__(self, indent=2):
+            s = '\n'
+            for attr in self.__dict__:
+                for i in range(0, indent):
+                    s += '\t'
+                s += (attr + ':\t' + str(getattr(self, attr))) + '\n'
+            return s
+
+    class Installation (ISolution.IInstallation):
+        def __init__(self):
+            super().__init__()
+            # API keywords
+            self._installation_path = None
+            self._environment_path = None
+            self._package_path = None
+
+        def environment_path(self) -> Path:
+            return self._environment_path
+
+        def user_cache_path(self) -> Path:
+            return self._installation_path.joinpath(DefaultValuesRunner.solution_user_cache_prefix.value)
+
+        def internal_cache_path(self) -> Path:
+            return self._installation_path.joinpath(DefaultValuesRunner.solution_internal_cache_prefix.value)
+
+        def package_path(self) -> Path:
+            return self._package_path
+
+        def installation_path(self) -> Path:
+            return self._installation_path
+
+        def data_path(self) -> Path:
+            return self._installation_path.joinpath(DefaultValuesRunner.solution_data_prefix.value)
+
+        def app_path(self) -> Path:
+            return self._installation_path.joinpath(DefaultValuesRunner.solution_app_prefix.value)
+
+        def set_environment_path(self, path: Path):
+            self._environment_path = path
+
+        def set_package_path(self, package_path: Path):
+            self._package_path = package_path
+
+        def set_installation_path(self, solution_base_path: Path):
+            self._installation_path = solution_base_path
+
+    def __init__(self, attrs=None):
+        self._installation = Solution.Installation()
+        self._setup = Solution.Setup(attrs)
+        self._coordinates = Coordinates(attrs['group'], attrs['name'], attrs['version'])
+        self._args = None
+        self._script = None
+
+    def setup(self) -> ISolution.ISetup:
+        return self._setup
+
+    def installation(self) -> ISolution.IInstallation:
+        return self._installation
+
+    def coordinates(self) -> ICoordinates:
+        return self._coordinates
+
+    def script(self) -> Path:
+        return self._script
+
+    def get_arg(self, k):
+        """Get a specific named argument for this album if it exists."""
+        matches = [arg for arg in self._setup.args if arg['name'] == k]
+        return matches[0]
+
+    def get_identifier(self) -> str:
+        identifier = '_'.join([self._setup.group, self._setup.name, self._setup.version])
+        return identifier
+
+    def set_script(self, script: str):
+        self._script = script
+
+    def __eq__(self, other):
+        return isinstance(other, Solution) and \
+               other.coordinates() == self._coordinates
+
+    def set_args(self, args: List):
+        self._args = args
+
+    def args(self) -> List:
+        return self._args

album-solution-api-0.6.0/src/album/runner/core/model/solution_script.py

@@ -0,0 +1,173 @@
+import argparse
+import sys
+from argparse import ArgumentError
+from pathlib import Path
+
+from album.runner import album_logging
+from album.runner.album_logging import get_active_logger, configure_logging
+from album.runner.core.api.model.solution import ISolution
+from album.runner.core.model.solution import Solution
+
+
+class SolutionScript:
+
+    @staticmethod
+    def make_action(solution, mydest):
+        class CustomAction(argparse.Action):
+            def __call__(self, parser, namespace, values, option_string=None):
+                setattr(namespace, mydest, solution.get_arg(mydest)['action'](values))
+
+        return CustomAction
+
+    @staticmethod
+    def get_script_logging_formatter_str():
+        return '%(levelname)-7s %(name)s - %(message)s'
+
+    @staticmethod
+    def get_script_logging_formatter_regex():
+        regex_log_level = 'DEBUG|INFO|WARNING|ERROR'
+        return r'(%s)\s+([\s\S]+) - ([\s\S]+)?' % regex_log_level
+
+    @staticmethod
+    def trigger_solution_goal(solution, goal, package_path=None, installation_base_path=None, environment_path=None):
+        SolutionScript.api_access(solution, package_path, installation_base_path, environment_path)
+        parser = None
+        if package_path:
+            sys.path.append(package_path)
+        if solution.setup().args:
+            append_arguments = (goal == Solution.Action.RUN) or (goal == Solution.Action.TEST)
+            if append_arguments:
+                parser = SolutionScript.append_arguments(solution)
+        if goal == Solution.Action.INSTALL:
+            solution.setup().install()
+        if goal == Solution.Action.UNINSTALL:
+            solution.setup().uninstall()
+        if goal == Solution.Action.RUN:
+            SolutionScript.execute_run_action(solution)
+        if goal == Solution.Action.TEST:
+            if 'pre_test' in solution.setup():
+                d = solution.setup().pre_test()
+            else:
+                d = {}
+            if d is None:
+                d = {}
+            sys.argv = sys.argv + ["=".join([c, d[c]]) for c in d]
+
+            # parse args again after pre_test() routine if necessary.
+            if parser and "args" in solution.setup().keys():
+                args = parser.parse_args()
+                solution.set_args(args)
+
+            SolutionScript.execute_run_action(solution)
+            solution.setup().test()
+
+    @staticmethod
+    def execute_run_action(solution):
+        get_active_logger().info("Starting %s" % solution.setup().name)
+        if solution.setup().run and callable(solution.setup().run):
+            solution.setup().run()
+        else:
+            get_active_logger().warn(
+                "No \"run\" routine configured for solution \"%s\"." % solution.setup().name)
+        if solution.setup().close and callable(solution.setup().close):
+            solution.setup().close()
+        get_active_logger().info("Finished %s" % solution.setup().name)
+
+    @staticmethod
+    def init_logging():
+        configure_logging("script", loglevel=album_logging.to_loglevel(album_logging.get_loglevel_name()),
+                          stream_handler=sys.stdout,
+                          formatter_string=SolutionScript.get_script_logging_formatter_str())
+
+    @staticmethod
+    def api_access(solution: ISolution, package_path, installation_base_path, environment_path):
+        if package_path:
+            solution.installation().set_package_path(package_path)
+            sys.path.insert(0, solution.installation().package_path())
+        if installation_base_path:
+            solution.installation().set_installation_path(installation_base_path)
+            # add app_path to syspath
+            sys.path.insert(0, solution.installation().app_path())
+        if environment_path:
+            solution.installation().set_environment_path(environment_path)
+
+    @staticmethod
+    def append_arguments(solution: ISolution):
+        parser = None
+        if isinstance(solution.setup().args, str):
+            SolutionScript._handle_args_string(solution.setup().args)
+        else:
+            parser = SolutionScript._handle_args_list(solution)
+        return parser
+
+    @staticmethod
+    def _handle_args_string(args):
+        # pass through to module
+        if args == 'pass-through':
+            get_active_logger().info(
+                'Argument parsing not specified in album solution. Passing arguments through...'
+            )
+        else:
+            message = 'Argument keyword \'%s\' not supported!' % args
+            get_active_logger().error(message)
+            raise ArgumentError(argument=args, message=message)
+
+    @staticmethod
+    def _handle_args_list(solution: ISolution):
+        parser = argparse.ArgumentParser(description='album run %s' % solution.setup().name)
+        for arg in solution.setup().args:
+            SolutionScript._add_parser_argument(solution, parser, arg)
+        args = parser.parse_args()
+        solution.set_args(args)
+        return parser
+
+    @staticmethod
+    def _add_parser_argument(solution, parser, arg):
+        keys = arg.keys()
+
+        if 'default' in keys and 'action' in keys:
+            get_active_logger().warning("Default values cannot be automatically set when an action is provided! "
+                                        "Ignoring default values...")
+
+        args = {}
+        if 'action' in keys:
+            args['action'] = SolutionScript.make_action(solution, arg['name'])
+        if 'default' in keys:
+            args['default'] = arg['default']
+        if 'description' in keys:
+            args['help'] = arg['description']
+        if 'type' in keys:
+            args['type'] = SolutionScript._parse_type(arg['type'])
+        if 'required' in keys:
+            args['required'] = arg['required']
+        parser.add_argument('--%s' % arg['name'], **args)
+
+    @staticmethod
+    def _get_action_class_name(name):
+        class_name = '%sAction' % name.capitalize()
+        return class_name
+
+    @staticmethod
+    def strtobool(val):
+        val = val.lower()
+        if val in ('y', 'yes', 't', 'true', 'on', '1'):
+            return True
+        elif val in ('n', 'no', 'f', 'false', 'off', '0'):
+            return False
+        else:
+            raise ValueError("invalid truth value %r" % (val,))
+
+    @staticmethod
+    def _parse_type(type_str):
+        if type_str == 'string':
+            return str
+        if type_str == 'file':
+            return Path
+        if type_str == 'directory':
+            return Path
+        if type_str == 'integer':
+            return int
+        if type_str == 'float':
+            return float
+        if type_str == 'boolean':
+            return SolutionScript.strtobool

album-solution-api-0.6.0/src/album/runner/core/schema/solution_schema.json

@@ -0,0 +1,287 @@
+{
+    "$ref": "#/definitions/RDF",
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "definitions": {
+        "Parent": {
+            "anyOf": [
+                {
+                    "type": "object",
+                    "properties": {
+                        "group": {
+                            "title": "group",
+                            "type": "string"
+                        },
+                        "name": {
+                            "title": "name",
+                            "type": "string"
+                        },
+                        "version": {
+                            "title": "version",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "group",
+                        "name",
+                        "version"
+                    ]
+                }, {
+                    "type": "object",
+                    "properties": {
+                        "resolve_solution": {
+                            "title": "resolve_solution",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "resolve_solution"
+                    ]
+                }, {
+                    "type": "object",
+                    "properties": {
+                        "doi": {
+                            "title": "doi",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "doi"
+                    ]
+                }
+            ]
+        },
+        "Argument": {
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "title": "name",
+                    "type": "string"
+                },
+                "description": {
+                    "title": "description",
+                    "type": "string"
+                },
+                "type": {
+                    "title": "type",
+                    "type": "string",
+                    "enum": ["string", "file", "directory", "boolean", "integer", "float"]
+                },
+                "default": {
+                    "title": "default"
+                },
+                "required": {
+                    "title": "required",
+                    "type": "boolean"
+                },
+                "action": {
+                    "title": "action"
+                }
+            },
+            "required": [
+                "name"
+            ],
+            "type": "object"
+        },
+        "Dependencies": {
+            "additionalProperties": false,
+            "properties": {
+                "parent": {
+                    "title": "parent",
+                    "$ref": "#/definitions/Parent"
+                },
+                "environment_file": {
+                    "title": "environment_file"
+                },
+                "plugins": {
+                    "items": {
+                        "$ref": "#/definitions/Plugin"
+                    },
+                    "title": "plugins",
+                    "type": "array"
+                }
+            },
+            "required": [],
+            "type": "object"
+        },
+        "Plugin": {
+            "additionalProperties": false,
+            "properties": {
+                "id": {
+                    "title": "id",
+                    "type": "string"
+                },
+                "args": {
+                    "title": "args",
+                    "type": "object"
+                }
+            },
+            "required": [
+                "id"
+            ],
+            "type": "object"
+        },
+        "Citation": {
+            "additionalProperties": false,
+            "properties": {
+                "doi": {
+                    "title": "doi",
+                    "type": "string"
+                },
+                "text": {
+                    "title": "text",
+                    "type": "string"
+                },
+                "url": {
+                    "title": "url",
+                    "type": "string"
+                }
+            },
+            "required": [
+                "text"
+            ],
+            "type": "object"
+        },
+        "Cover": {
+            "additionalProperties": false,
+            "properties": {
+                "source": {
+                    "title": "source",
+                    "type": "string"
+                },
+                "description": {
+                    "title": "description",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "RDF": {
+            "additionalProperties": false,
+            "properties": {
+                "solution_creators": {
+                    "type": "array",
+                    "title": "solution_creators",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "args": {
+                    "items": {
+                        "$ref": "#/definitions/Argument"
+                    },
+                    "type": "array"
+                },
+                "cite": {
+                    "items": {
+                        "$ref": "#/definitions/Citation"
+                    },
+                    "type": "array"
+                },
+                "covers": {
+                    "items": {
+                        "$ref": "#/definitions/Cover"
+                    },
+                    "title": "covers",
+                    "type": "array"
+                },
+                "description": {
+                    "title": "description",
+                    "type": "string"
+                },
+                "documentation": {
+                    "title": "documentation",
+                    "anyOf": [
+                        {
+                            "type": "string"
+                        },
+                        {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        }
+                    ]
+                },
+                "acknowledgement": {
+                    "title": "acknowledgement",
+                    "type": "string"
+                },
+                "license": {
+                    "title": "license",
+                    "type": "string"
+                },
+                "name": {
+                    "title": "name",
+                    "type": "string"
+                },
+                "group": {
+                    "title": "group",
+                    "type": "string"
+                },
+                "title": {
+                    "title": "title",
+                    "type": "string"
+                },
+                "album_api_version": {
+                    "title": "album_api_version",
+                    "type": "string"
+                },
+                "tags": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "title": "tags",
+                    "type": "array"
+                },
+                "version": {
+                    "title": "version",
+                    "type": "string"
+                },
+                "changelog": {
+                    "title": "changelog",
+                    "type": "string"
+                },
+                "doi": {
+                    "title": "doi",
+                    "type": "string"
+                },
+                "dependencies": {
+                    "title": "dependencies",
+                    "type": "object",
+                    "$ref": "#/definitions/Dependencies"
+                },
+                "steps": {
+                    "title": "steps"
+                },
+                "custom": {
+                    "title": "custom",
+                    "type": "object"
+                },
+                "install": {
+                    "title": "install"
+                },
+                "uninstall": {
+                    "title": "uninstall"
+                },
+                "run": {
+                    "title": "run"
+                },
+                "test": {
+                    "title": "test"
+                },
+                "pre_test": {
+                    "title": "pre_test"
+                },
+                "close": {
+                    "title": "close"
+                }
+            },
+            "required": [
+                "group",
+                "name",
+                "version"
+            ],
+            "type": "object"
+        }
+    }
+}

album-solution-api-0.6.0/src/album_solution_api.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: album-solution-api
+Version: 0.6.0
+Summary: Album is a framework for unifying computational tools across frameworks, languages, and environments.
+Home-page: https://gitlab.com/album-app/album-solution-api
+Author: Kyle Harrington, Jan Philipp Albrecht, Deborah Schmidt
+Maintainer: Kyle Harrington, Jan Philipp Albrecht, Deborah Schmidt
+Maintainer-email: album@kyleharrington.com
+License: MIT
+Project-URL: Source, https://gitlab.com/album-app/album-solution-api
+Project-URL: Tracker, https://gitlab.com/album-app/album-solution-api/issues
+Keywords: virtual,environments,imaging
+Platform: any
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Utilities
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# album-solution-api
+
+Package installed in any Album solution environment. Provides the API for the solution script.

album-solution-api-0.6.0/src/album_solution_api.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+src/album/__init__.py
+src/album/runner/__init__.py
+src/album/runner/album_logging.py
+src/album/runner/api.py
+src/album/runner/core/__init__.py
+src/album/runner/core/default_values_runner.py
+src/album/runner/core/api/__init__.py
+src/album/runner/core/api/model/__init__.py
+src/album/runner/core/api/model/coordinates.py
+src/album/runner/core/api/model/solution.py
+src/album/runner/core/model/__init__.py
+src/album/runner/core/model/coordinates.py
+src/album/runner/core/model/solution.py
+src/album/runner/core/model/solution_script.py
+src/album/runner/core/schema/__init__.py
+src/album/runner/core/schema/solution_schema.json
+src/album_solution_api.egg-info/PKG-INFO
+src/album_solution_api.egg-info/SOURCES.txt
+src/album_solution_api.egg-info/dependency_links.txt
+src/album_solution_api.egg-info/top_level.txt

album-solution-api-0.6.0/src/album_solution_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

album-solution-api-0.6.0/src/album_solution_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+album