cloud-submit 0.1__py3-none-any.whl

cloud_submit/execution/base_execution_handler.py

@@ -0,0 +1,49 @@
+import os
+import shutil
+import datetime as dt
+
+
+class BaseExecutionHandler:
+    def __init__(self):
+        pass
+
+    def get_local_artifact_path(self, artifact):
+        if artifact.kind != 'file':
+            raise RuntimeError(
+                f'Cannot construct local path for artifact {artifact.name} '
+                f'of kind {artifact.kind}'
+            )
+        if artifact.scope not in ['run', 'user', 'project']:
+            raise RuntimeError(
+                f'Invalid scope {artifact.scope} '
+                f'for artifact {artifact.name} '
+            )
+        return os.path.join(
+            '/mnt/artifacts',
+            artifact.scope,
+            artifact.name,
+        )
+
+    def get_remote_artifact_path(self, artifact):
+        raise RuntimeError(
+            'Cannot construct remote path for artifact '
+            f'{artifact.name}.'
+        )
+
+    def download_artifact(self, artifact):
+        pass
+
+    def upload_artifact(self, artifact):
+        pass
+
+    def get_submit_timestamp(self):
+        return dt.datetime.fromisoformat(os.environ['CSUB_TIMESTAMP'])
+
+    def get_run_id(self):
+        return os.environ['CSUB_RUN_ID']
+
+    def get_worker_index(self):
+        return int(os.environ['CSUB_WORKER_INDEX'])
+
+    def get_run_steps(self):
+        return os.environ['CSUB_RUN_STEPS'].split(',')

cloud_submit/execution/config.py

@@ -0,0 +1,248 @@
+import os
+import datetime as dt
+
+from .utils import read_json
+
+
+class ConfigError(Exception):
+    pass
+
+
+def to_utc(timestamp):
+    if timestamp is None:
+        return None
+    if timestamp.tzinfo is None:
+        timestamp = timestamp.replace(tzinfo=dt.UTC)
+    return timestamp.astimezone(dt.UTC)
+
+
+class Artifact:
+    def __init__(
+        self,
+        name,
+        kind='file',
+        scope='run',
+    ):
+        if scope not in ['run', 'user', 'project']:
+            raise ValueError(
+                f'Invalid value {repr(scope)} for scope. '
+                "Must be 'run', 'user' or 'project'."
+            )
+        self.name = name
+        self.kind = kind
+        self.scope = scope
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, Artifact)
+            and other.name == self.name
+            and other.kind == self.kind
+            and other.scope == self.scope
+        )
+
+    def copy(self):
+        return Artifact(self.name, kind=self.kind, scope=self.scope)
+
+    def to_dict(self):
+        return {
+            'name': self.name,
+            'kind': self.kind,
+            'scope': self.scope,
+        }
+
+    @staticmethod
+    def from_dict(obj):
+        return Artifact(
+            obj['name'],
+            kind=obj['kind'],
+            scope=obj['scope'],
+        )
+
+
+class ArtifactLocation:
+    def __init__(
+        self,
+        artifact_name,
+        is_local,
+        sync=True,
+    ):
+        self.artifact_name = str(artifact_name)
+        self.is_local = bool(is_local)
+        self.sync = bool(sync)
+
+    def to_dict(self):
+        return {
+            'artifact_name': self.artifact_name,
+            'is_local': self.is_local,
+            'sync': self.sync
+        }
+
+    @staticmethod
+    def from_dict(obj):
+        return ArtifactLocation(
+            obj['artifact_name'],
+            obj['is_local'],
+            sync=obj['sync'],
+        )
+
+
+def local(name, sync=True):
+    return ArtifactLocation(name, is_local=True, sync=sync)
+
+
+def remote(name, sync=True):
+    return ArtifactLocation(name, is_local=False, sync=sync)
+
+
+class Spec:
+    def __init__(self, **kwargs):
+        self._spec = kwargs
+
+    def get(self, attr, default=None):
+        return self._spec.get(attr, default)
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+        return self._spec == other._spec
+
+
+class Step:
+    def __init__(
+        self,
+        name,
+        function,
+        image=None,
+        spec=None,
+        params=None,
+        inputs=None,
+        outputs=None,
+        temporaries=None,
+        num_workers=None,
+        pass_num_workers_as='num_workers',
+        pass_worker_index_as='worker_index',
+        pass_submit_timestamp_as=None,
+        pass_run_id_as=None,
+    ):
+        self.name = name
+        self.function = function
+        self.params = params
+        if self.params is None:
+            self.params = {}
+        self.inputs = inputs
+        if self.inputs is None:
+            self.inputs = {}
+        self.outputs = outputs
+        if self.outputs is None:
+            self.outputs = {}
+        self.temporaries = temporaries
+        if self.temporaries is None:
+            self.temporaries = {}
+        self.image = image
+        self.spec = spec
+        if self.spec is None:
+            self.spec = Spec()
+        self.num_workers = None
+        if num_workers is not None:
+            self.num_workers = int(num_workers)
+        self.pass_num_workers_as = pass_num_workers_as
+        self.pass_worker_index_as = pass_worker_index_as
+        self.pass_submit_timestamp_as = pass_submit_timestamp_as
+        self.pass_run_id_as = pass_run_id_as
+
+    def to_dict(self):
+        return {
+            'name': self.name,
+            'function': self.function,
+            'params': self.params,
+            'inputs': {k: v.to_dict() for k, v in self.inputs.items()},
+            'outputs': {k: v.to_dict() for k, v in self.outputs.items()},
+            'temporaries':
+                {k: v.to_dict() for k, v in self.temporaries.items()},
+            'num_workers': self.num_workers,
+            'pass_num_workers_as': self.pass_num_workers_as,
+            'pass_worker_index_as': self.pass_worker_index_as,
+            'pass_submit_timestamp_as': self.pass_submit_timestamp_as,
+            'pass_run_id_as': self.pass_run_id_as,
+        }
+
+    @staticmethod
+    def from_dict(obj):
+        return Step(
+            obj['name'],
+            obj['function'],
+            params=obj['params'],
+            inputs={
+                k: ArtifactLocation.from_dict(v)
+                for k, v in obj['inputs'].items()
+            },
+            outputs={
+                k: ArtifactLocation.from_dict(v)
+                for k, v in obj['outputs'].items()
+            },
+            temporaries={
+                k: ArtifactLocation.from_dict(v)
+                for k, v in obj['temporaries'].items()
+            },
+            num_workers=obj['num_workers'],
+            pass_num_workers_as=obj['pass_num_workers_as'],
+            pass_worker_index_as=obj['pass_worker_index_as'],
+            pass_submit_timestamp_as=obj['pass_submit_timestamp_as'],
+            pass_run_id_as=obj['pass_run_id_as'],
+        )
+
+
+class Pipeline:
+    def __init__(
+        self,
+        name,
+        steps,
+        default_submit_timestamp=None,
+    ):
+        self.name = name
+        self.steps = list(steps)
+        self.default_submit_timestamp = to_utc(default_submit_timestamp)
+
+        step_names = set()
+        for step in self.steps:
+            if step.name in step_names:
+                raise ConfigError(
+                    f'Duplicate step name {step.name} '
+                    f'in pipeline {self.name}.'
+                )
+            step_names.add(step.name)
+
+    def to_dict(self):
+        return {
+            'name': self.name,
+            'steps': [s.to_dict() for s in self.steps],
+            'default_submit_timestamp': self.default_submit_timestamp
+        }
+
+    @staticmethod
+    def from_dict(obj):
+        return Pipeline(
+            name=obj['name'],
+            steps=[Step.from_dict(s) for s in obj['steps']],
+            default_submit_timestamp=obj['default_submit_timestamp']
+        )
+
+
+def read_pipelines():
+    path = os.path.join(os.path.dirname(__file__), 'pipelines.json')
+    obj = read_json(path)
+    pipelines = {}
+    for name, steps in obj.items():
+        pipelines[name] = [Step.from_dict(s) for s in steps]
+    return pipelines
+
+
+def read_artifacts():
+    path = os.path.join(os.path.dirname(__file__), 'artifacts.json')
+    obj = read_json(path)
+    artifacts = {}
+    for artifact in obj['artifacts']:
+        artifact = Artifact.from_dict(artifact)
+        artifacts[artifact.name] = artifact
+    return artifacts
+

cloud_submit/execution/execute.py

@@ -0,0 +1,108 @@
+import os
+import sys
+import importlib
+import copy
+import datetime as dt
+
+from .config import read_pipelines, read_artifacts
+from .execution_handler import create_execution_handler
+
+
+if __name__ == '__main__':
+    if len(sys.argv) != 3:
+        raise SystemExit(
+            'Invalid number of command line arguments. '
+            'Expected PIPELINE and STEPS.'
+        )
+    pipeline_name = sys.argv[1]
+    steps = set(sys.argv[2].split(','))
+
+    os.makedirs('/mnt/artifacts/project', exist_ok=True)
+    os.makedirs('/mnt/artifacts/user', exist_ok=True)
+    os.makedirs('/mnt/artifacts/run', exist_ok=True)
+
+    pipelines = read_pipelines()
+    artifacts = read_artifacts()
+    try:
+        pipeline_steps = pipelines[pipeline_name]
+    except KeyError:
+        raise SystemExit(
+            f'Invalid pipeline name: {pipeline_name}')
+
+    def get_artifact(name):
+        try:
+            return artifacts[name]
+        except KeyError:
+            raise SystemExit(f'Invalid artifact name {name}')
+
+    def get_artifact_path(eh, loc):
+        artifact = get_artifact(loc.artifact_name)
+        if loc.is_local:
+            return eh.get_local_artifact_path(artifact)
+        return eh.get_remote_artifact_path(artifact)
+
+    eh = create_execution_handler()
+    timestamp = eh.get_submit_timestamp()
+    run_id = eh.get_run_id()
+    worker_index = eh.get_worker_index()
+    run_steps = set(eh.get_run_steps())
+    run_steps = [step.name for step in pipeline_steps if step.name in run_steps]
+
+    synced_artifacts = set()
+
+    for step in pipeline_steps:
+        if step.name not in steps:
+            continue
+        if step.name == run_steps[0] and step.num_workers is None:
+            print('STARTING EXECUTION.')
+
+        print(f'Executing step: {step.name}')
+        for loc in step.inputs.values():
+            if loc.is_local and loc.artifact_name not in synced_artifacts:
+                artifact = get_artifact(loc.artifact_name)
+                eh.download_artifact(artifact)
+                synced_artifacts.add(loc.artifact_name)
+
+        module_name, function_name = step.function.split(':')
+        module = importlib.import_module(module_name)
+        function = getattr(module, function_name)
+
+        kwargs = copy.deepcopy(step.params)
+        for kw, loc in step.inputs.items():
+            kwargs[kw] = get_artifact_path(eh, loc)
+        for kw, loc in step.outputs.items():
+            kwargs[kw] = get_artifact_path(eh, loc)
+        for kw, loc in step.temporaries.items():
+            kwargs[kw] = get_artifact_path(eh, loc)
+        if step.num_workers is not None:
+            if worker_index < 0:
+                raise SystemExit(
+                    f'Invalid worker index {worker_index} in step {step.name}.'
+                )
+            kwargs[step.pass_num_workers_as] = step.num_workers
+            kwargs[step.pass_worker_index_as] = worker_index
+        if step.pass_submit_timestamp_as is not None:
+            kwargs[step.pass_submit_timestamp_as] = timestamp
+        if step.pass_run_id_as is not None:
+            kwargs[step.pass_run_id_as] = run_id
+
+        success = True
+        try:
+            function(**kwargs)
+        except Exception:
+            success = False
+            raise
+        finally:
+            remote_outputs = set(
+                l.artifact_name for l in step.outputs.values()
+                if not l.is_local
+            )
+            for loc in step.outputs.values():
+                artifact = get_artifact(loc.artifact_name)
+                if loc.is_local:
+                    synced_artifacts.add(loc.artifact_name)
+                    if loc.artifact_name not in remote_outputs:
+                        eh.upload_artifact(artifact)
+            if success and step.name == run_steps[-1]:
+                print('EXECUTION FINISHED SUCCESSFULLY.')
+

cloud_submit/execution/utils.py

@@ -0,0 +1,98 @@
+import os
+import sys
+import shutil
+import shlex
+import json
+import subprocess
+import datetime as dt
+import re
+
+
+_timedelta_regex = re.compile(r'^(-?[\d]+)d([\d]+)s([\d]+)u$')
+
+
+class DecodingError(Exception):
+    pass
+
+
+class CloudSubmitError(Exception):
+    pass
+
+
+def clear_path(path):
+    shutil.rmtree(path, ignore_errors=True)
+    try:
+        os.remove(path)
+    except FileNotFoundError:
+        pass
+
+
+def ensure_path(path, clear=False):
+    if clear:
+        clear_path(path)
+    os.makedirs(path, exist_ok=True)
+
+
+def _encode(obj):
+    if isinstance(obj, dt.datetime):
+        return {'$datetime': obj.isoformat()}
+    elif isinstance(obj, dt.date):
+        return {'$date': obj.isoformat()}
+    elif isinstance(obj, dt.timedelta):
+        return {'$timedelta': f'{obj.days}d{obj.seconds}s{obj.microseconds}u'}
+    else:
+        raise TypeError(f'Object of type {type(obj)} is not JSON serializable')
+
+
+def _decode(obj):
+    if len(obj) == 1:
+        key, value = next(iter(obj.items()))
+        if key == '$datetime':
+            return dt.datetime.fromisoformat(value)
+        elif key == '$date':
+            return dt.date.fromisoformat(value)
+        elif key == '$timedelta':
+            match = _timedelta_regex.match(value)
+            if not match:
+                raise DecodingError(
+                    f'Expecting timedelta expression but got {repr(value)}')
+            return dt.timedelta(
+                days=int(match.group(1)),
+                seconds=int(match.group(2)),
+                microseconds=int(match.group(3)),
+            )
+    return obj
+
+
+def read_json(path):
+    with open(path, 'r') as stream:
+        obj = json.load(stream, object_hook=_decode)
+    return obj
+
+
+def write_json(obj, path):
+    with open(path, 'w') as stream:
+        json.dump(obj, stream, default=_encode, indent=4)
+
+
+def run_command(command, check=True, hide_stderr=False, **kwargs):
+    if check and hide_stderr:
+        kwargs['stderr'] = subprocess.PIPE
+    try:
+        result = subprocess.run(command, **kwargs)
+    except FileNotFoundError:
+        raise CloudSubmitError(
+            'Error. Command not found when trying to execute:\n'
+            + ' '.join([shlex.quote(part) for part in command])
+        )
+    except KeyboardInterrupt:
+        raise CloudSubmitError('Aborted on user request.')
+    if check and result.returncode != 0:
+        if hide_stderr:
+            sys.stderr.write(result.stderr)
+        msg = (
+            f'Command exited with status code {result.returncode}:\n'
+            + ' '.join([shlex.quote(part) for part in command])
+        )
+        raise CloudSubmitError(msg)
+    return result

cloud_submit/images.py

@@ -0,0 +1,58 @@
+import os
+
+
+class Image:
+    def __init__(
+        self,
+        name,
+        parent=None,
+        instructions=None,
+        setup_builddir_callback=None,
+    ):
+        self.name = name
+        self.parent = parent
+        self._instructions = instructions if instructions is not None else ''
+        self._setup_builddir_callback = setup_builddir_callback
+
+    def setup_builddir(self, path, base_image):
+        if self._setup_builddir_callback is not None:
+            self._setup_builddir_callback(path, mode)
+        with open(os.path.join(path, 'Dockerfile'), 'w') as dockerfile:
+            if self.parent is not None:
+                dockerfile.write(f'FROM {base_image}\n\n')
+            dockerfile.write(self._instructions)
+            dockerfile.write('\n')
+
+
+class BaseImage(Image):
+    pass
+
+
+class ExecutionImage(Image):
+    def __init__(
+        self,
+        name,
+        parent=None,
+        instructions=None,
+        setup_builddir_callback=None,
+        python_cmd='python',
+    ):
+        super().__init__(
+            name=name,
+            parent=parent,
+            instructions=instructions,
+            setup_builddir_callback=setup_builddir_callback,
+        )
+        self._python_cmd = python_cmd
+
+    def setup_builddir(self, path, base_image):
+        super().setup_builddir(path, base_image)
+        with open(os.path.join(path, 'Dockerfile'), 'a') as dockerfile:
+            dockerfile.write(
+                '\nCOPY --chown=root:root src /root/src/\n'
+                'ENV PYTHONPATH="/root/src:$PYTHONPATH"\n'
+                'WORKDIR /root\n'
+                f'ENTRYPOINT ["/usr/bin/env", "{self._python_cmd}", "-u", '
+                '"-m", "csub.execute"]\n'
+            )
+

cloud_submit/utils.py

@@ -0,0 +1,67 @@
+import os
+import re
+
+
+def build_docker_mount_option(source, dest):
+    source = os.path.abspath(source)
+    volume = os.environ.get('CSUB_DOD_VOLUME', None)
+    if not volume:
+        return f'type=bind,src={source},dst={dest}'
+    dod_mount = os.environ.get('CSUB_DOD_MOUNT_POINT', None)
+    if not dod_mount:
+        raise CloudSubmitError(
+            'CSUB_DOD_MOUNT_POINT variable must be set to use cloud-submit '
+            'in a docker-outside-docker setup. If do not want to use '
+            'cloud-submit in docker-outside-docker mode make sure that the '
+            'variable CSUB_DOD_VOLUME is *not* set.'
+        )
+    dod_mount = os.path.abspath(dod_mount)
+    if os.path.commonpath([source, dod_mount]) != dod_mount:
+        raise CloudSubmitError(
+            f'Artifact directory {path} is not a subpath of {dod_mount}. '
+            'Change the CSUB_DOD_MOUNT_POINT variable or move your '
+            'project directory.'
+        )
+    subpath = os.path.relpath(source, start=dod_mount)
+    return (
+        'type=volume,'
+        f'src={volume},'
+        f'dst={dest},'
+        f'volume-subpath={subpath}'
+    )
+
+
+def run_command(command, check=True, **kwargs):
+    try:
+        result = subprocess.run(command, **kwargs)
+    except FileNotFoundError:
+        raise CloudSubmitError(
+            'Error. Command not found when trying to execute:\n'
+            + ' '.join([shlex.quote(part) for part in command])
+        )
+    except KeyboardInterrupt:
+        raise CloudSubmitError('Aborted on user request.')
+    if check and result.returncode != 0:
+        msg = (
+            f'Command exited with status code {result.returncode}:\n'
+            + ' '.join([shlex.quote(part) for part in command])
+        )
+        raise CloudSubmitError(msg)
+    return result
+
+
+_IMAGE_REF_REGEX = re.compile(
+    '^([a-zA-Z0-9-.:]+)/([a-z0-9-_./]+):([a-zA-Z0-9-_.]+)(@([a-zA-Z0-9:]+))?$'
+)
+
+
+def parse_image_ref(ref):
+    match = _IMAGE_REF_REGEX.match(ref)
+    if match is None:
+        raise CloudSubmitError(f'Could not parse image ref {ref}')
+    return (
+        match.group(1),
+        match.group(2),
+        match.group(3),
+        match.group(5),
+    )

cloud_submit-0.1.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: cloud-submit
+Version: 0.1
+Summary: A tool for building processing pipelines in Python and executing them locally or in the cloud.
+Author: Martin Wiebusch
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Requires-Dist: click
+Requires-Dist: pyyaml

cloud_submit-0.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+cloud_submit/__init__.py,sha256=Oy7My15-bLvmL6G_Y53e_OBG4xk7TC69G60GvZUrgHY,659
+cloud_submit/cli.py,sha256=POr0dPo8pN1xyBcqvAtIyampdIp0QW_XSY7RXl3p_8I,26805
+cloud_submit/config.py,sha256=nNZheN9r0vZ9jisolifrnb5SRe4GdSiAz5SjrfJ_lrQ,6226
+cloud_submit/controller.py,sha256=peLTcrkgQ-LHrFUbiCvO_gTkJ1vqAd6ADOIBHtEIFLw,13626
+cloud_submit/environment_handler.py,sha256=W1xp5DNa9MAGqz42034sF38BfWjKKsLKaUu9lKGVpss,14245
+cloud_submit/images.py,sha256=6zo0XP8qaZ17J4bpZp4pzMS6kDmDWoF6UeU8fgW1Fig,1716
+cloud_submit/utils.py,sha256=vG4sDrxfs-Irem6zncjk38K4ALBR350N_DclhWDd2e0,2176
+cloud_submit/envs/aws/__init__.py,sha256=9YzB6gf91zqKVy_jrRc8AvNW1vdIdIowRf79s1LK5QE,104
+cloud_submit/envs/aws/local_environment_handler.py,sha256=xTRrJ5MKU7tjqKAtnVBl-4vxbjq8Lg1cVocShfx2d2U,15800
+cloud_submit/envs/aws/local_execution_handler.py,sha256=hpJJFjYYw3u2SPK53yBd_k6AVGOiv4DyERWSfgI06YU,125
+cloud_submit/envs/aws/remote_environment_handler.py,sha256=idO2Ug3MYJbxN8Sv_g6_jW0GkBbvWA8Oq3cLRJlVt7I,14693
+cloud_submit/envs/aws/remote_execution_handler.py,sha256=S29bTVVgbPIieUt-RDCpbY4Hd6G9ZrRze2kdXUGdcnw,2903
+cloud_submit/envs/aws/s3_tools.py,sha256=a9ooG3tk6LNuXLT73dFZtGJAkYXjbPK76R7JFek7dBw,1316
+cloud_submit/envs/local/environment_handler.py,sha256=m15bnJiU8YM-vWJQbJui6mgjh2oCeQLZXFKV3HVcINY,3891
+cloud_submit/envs/local/execution_handler.py,sha256=hpJJFjYYw3u2SPK53yBd_k6AVGOiv4DyERWSfgI06YU,125
+cloud_submit/execution/base_execution_handler.py,sha256=YgfjbKxgigoha3cBJCGbtXnoVnZrr-QLqg_o2BgVRYc,1332
+cloud_submit/execution/config.py,sha256=JDNzsuj5GjbRFqS6ibWhfE29UQ4089iZC7QgvMTf6qE,6763
+cloud_submit/execution/execute.py,sha256=pPTSZ0bj67nZt_-81p-gpzi-b4S5WuHwc22hUy1COgs,3822
+cloud_submit/execution/utils.py,sha256=7SMTIWHqyGoM0pSjqAEOXuYnuLmpzyCpFES3DQw7o8s,2646
+cloud_submit-0.1.dist-info/METADATA,sha256=L2l8Bh4Y0Gmpcttdd82X9U12Zx2bZjUD9CIfrC7pOAU,416
+cloud_submit-0.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+cloud_submit-0.1.dist-info/entry_points.txt,sha256=O20VZUbR139AENr5zt_wUFSbAoiPj6klDEpEXruCrQE,47
+cloud_submit-0.1.dist-info/licenses/LICENSE,sha256=7EI8xVBu6h_7_JlVw-yPhhOZlpY9hP8wal7kHtqKT_E,1074
+cloud_submit-0.1.dist-info/RECORD,,

cloud_submit-0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cloud_submit-0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+csub = cloud_submit.cli:main

cloud_submit-0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.