liblaf-cherries 0.0.0__py3-none-any.whl

liblaf/cherries/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/cherries/__init__.pyi

@@ -0,0 +1,23 @@
+from . import git, integration, plugin, utils
+from ._start import current_run, end, set_current_run, start
+from .git import entrypoint
+from .integration import Run, RunNeptune
+from .plugin import Plugin, PluginGit, PluginLogging, default_plugins
+
+__all__ = [
+    "Plugin",
+    "PluginGit",
+    "PluginLogging",
+    "Run",
+    "RunNeptune",
+    "current_run",
+    "default_plugins",
+    "end",
+    "entrypoint",
+    "git",
+    "integration",
+    "plugin",
+    "set_current_run",
+    "start",
+    "utils",
+]

liblaf/cherries/_start.py

@@ -0,0 +1,48 @@
+from collections.abc import Sequence
+
+from liblaf import cherries
+
+_current_run: cherries.Run | None = None
+
+
+def current_run() -> cherries.Run | None:
+    return _current_run
+
+
+def set_current_run(run: cherries.Run) -> None:
+    global _current_run  # noqa: PLW0603
+    _current_run = run
+
+
+def start(
+    backend: type[cherries.Run],
+    plugins: Sequence[cherries.Plugin] = [],
+    *,
+    enabled: bool = True,
+) -> cherries.Run | None:
+    if not enabled:
+        return None
+    plugins = sorted(plugins, key=lambda plugin: plugin.priority)
+    for plugin in plugins:
+        if plugin.enabled:
+            plugin.pre_start()
+    run: cherries.Run = backend()
+    run.plugins = plugins
+    set_current_run(run)
+    for plugin in plugins:
+        if plugin.enabled:
+            plugin.post_start(run)
+    return run
+
+
+def end(run: cherries.Run | None = None) -> None:
+    run = run or current_run()
+    if run is None:
+        return
+    for plugin in reversed(run.plugins):
+        if plugin.enabled:
+            plugin.pre_end(run)
+    run.end()
+    for plugin in reversed(run.plugins):
+        if plugin.enabled:
+            plugin.post_end(run)

liblaf/cherries/git/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/cherries/git/__init__.pyi

@@ -0,0 +1,17 @@
+from . import github
+from ._commit import DEFAULT_COMMIT_MESSAGE, commit
+from ._entrypoint import entrypoint
+from ._repo import github_user_repo, repo, root
+from .github import permalink, user_repo
+
+__all__ = [
+    "DEFAULT_COMMIT_MESSAGE",
+    "commit",
+    "entrypoint",
+    "github",
+    "github_user_repo",
+    "permalink",
+    "repo",
+    "root",
+    "user_repo",
+]

liblaf/cherries/git/_commit.py

@@ -0,0 +1,17 @@
+import subprocess as sp
+
+import git
+
+DEFAULT_COMMIT_MESSAGE: str = """chore(exp): auto commit"""
+
+
+def commit(message: str = DEFAULT_COMMIT_MESSAGE, *, dry_run: bool = False) -> bool:
+    repo = git.Repo(search_parent_directories=True)
+    if not repo.is_dirty(untracked_files=True):
+        return False
+    repo.git.add(all=True, dry_run=dry_run)
+    sp.run(["git", "status"], check=False)
+    if dry_run:
+        return False
+    repo.git.commit(message=message)
+    return True

liblaf/cherries/git/_entrypoint.py

@@ -0,0 +1,12 @@
+import sys
+from pathlib import Path
+
+from . import root as git_root
+
+
+def entrypoint() -> Path:
+    fpath: Path = Path(sys.argv[0]).absolute()
+    root: Path = git_root()
+    if fpath.is_relative_to(root):
+        return fpath.relative_to(root)
+    return fpath

liblaf/cherries/git/_repo.py

@@ -0,0 +1,33 @@
+import re
+from pathlib import Path
+
+import git
+
+GITHUB_URL_PATTERNS: list[str] = [
+    r"https://github\.com/(?P<user>[^/]+)/(?P<repo>[^/]+)(?:\.git)?"
+]
+
+
+def repo(*, search_parent_directories: bool = True) -> git.Repo:
+    return git.Repo(search_parent_directories=search_parent_directories)
+
+
+def root() -> Path:
+    repo = git.Repo(search_parent_directories=True)
+    return Path(repo.working_dir)
+
+
+def github_user_repo(
+    repo: git.Repo | None = None,
+) -> tuple[str, str] | tuple[None, None]:
+    if repo is None:
+        repo = git.Repo(search_parent_directories=True)
+    remote: git.Remote = repo.remote()
+    for pattern in GITHUB_URL_PATTERNS:
+        match: re.Match[str] | None = re.match(pattern, remote.url)
+        if not match:
+            continue
+        user: str = match.group("user")
+        repo_name: str = match.group("repo")
+        return user, repo_name
+    return None, None

liblaf/cherries/git/github/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/cherries/git/github/__init__.pyi

@@ -0,0 +1,4 @@
+from ._link import permalink
+from ._repo import user_repo
+
+__all__ = ["permalink", "user_repo"]

liblaf/cherries/git/github/_link.py

@@ -0,0 +1,25 @@
+import os
+from pathlib import Path
+
+import git
+
+from . import user_repo
+
+
+def permalink(
+    repo: git.Repo | None = None, filepath: str | os.PathLike[str] | None = None
+) -> str | None:
+    if repo is None:
+        repo = git.Repo(search_parent_directories=True)
+    user: str | None
+    repo_str: str | None
+    user, repo_str = user_repo(repo)
+    if not (user and repo):
+        return None
+    sha: str = repo.head.commit.hexsha
+    link: str = f"https://github.com/{user}/{repo_str}/tree/{sha}"
+    if filepath:
+        filepath = Path(filepath).absolute()
+        if not filepath.is_relative_to(repo.working_dir):
+            return None
+        link += f"/{Path(filepath).as_posix()}"

liblaf/cherries/git/github/_repo.py

@@ -0,0 +1,23 @@
+import re
+
+import git
+
+GITHUB_URL_PATTERNS: list[str] = [
+    r"https://github\.com/(?P<user>[^/]+)/(?P<repo>[^/]+)(?:\.git)?"
+]
+
+
+def user_repo(
+    repo: git.Repo | None = None,
+) -> tuple[str, str] | tuple[None, None]:
+    if repo is None:
+        repo = git.Repo(search_parent_directories=True)
+    remote: git.Remote = repo.remote()
+    for pattern in GITHUB_URL_PATTERNS:
+        match: re.Match[str] | None = re.match(pattern, remote.url)
+        if not match:
+            continue
+        user: str = match.group("user")
+        repo_name: str = match.group("repo")
+        return user, repo_name
+    return None, None

liblaf/cherries/integration/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/cherries/integration/__init__.pyi

@@ -0,0 +1,4 @@
+from ._abc import Run, current_run, set_current_run
+from ._neptune import RunNeptune
+
+__all__ = ["Run", "RunNeptune", "current_run", "set_current_run"]

liblaf/cherries/integration/_abc.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import datetime
+import functools
+import os
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Generic, TypeVar
+
+from loguru import logger
+
+from liblaf import cherries
+
+_T = TypeVar("_T")
+
+
+class Run(Generic[_T]):
+    enabled: bool = True
+    plugins: list[cherries.Plugin]
+    _backend: _T
+
+    def __init__(
+        self,
+        plugins: Sequence[cherries.Plugin] | None = None,
+        *,
+        enabled: bool = True,
+    ) -> None:
+        if plugins is None:
+            plugins = cherries.default_plugins()
+        self.plugins = sorted(plugins, key=lambda plugin: plugin.priority)
+        self.enabled = enabled
+        set_current_run(self)
+        if self.enabled:
+            self.start()
+
+    @property
+    def backend(self) -> str:
+        return "dummy"
+
+    @property
+    def id(self) -> str:
+        raise NotImplementedError
+
+    @functools.cached_property
+    def creation_time(self) -> datetime.datetime:
+        return datetime.datetime.now().astimezone()
+
+    @functools.cached_property
+    def entrypoint(self) -> Path:
+        return Path(sys.argv[0]).absolute()
+
+    @property
+    def name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def url(self) -> str:
+        raise NotImplementedError
+
+    def start(self) -> None:
+        for plugin in self.plugins:
+            plugin.pre_start()
+        self._backend = self._start()
+        for plugin in self.plugins:
+            plugin.post_start(self)
+        self.log_other("cherries/creation_time", self.creation_time)
+
+    def end(self) -> None:
+        for plugin in reversed(self.plugins):
+            plugin.pre_end(self)
+        self._end()
+        for plugin in reversed(self.plugins):
+            plugin.post_end(self)
+
+    def log_metric(
+        self,
+        key: str,
+        value: float,
+        *,
+        step: float | None = None,
+        timestamp: float | None = None,
+        **kwargs,
+    ) -> None:
+        logger.opt(depth=1).debug("{}: {}", key, value)
+        if self.enabled:
+            self._log_metric(key, value, step=step, timestamp=timestamp, **kwargs)
+
+    def log_other(
+        self,
+        key: str,
+        value: bool | float | str | datetime.datetime,
+        **kwargs,
+    ) -> None:
+        logger.opt(depth=1).info("{}: {}", key, value)
+        if self.enabled:
+            self._log_other(key, value, **kwargs)
+
+    def upload_file(self, key: str, path: str | os.PathLike[str], **kwargs) -> None:
+        path = Path(path)
+        logger.opt(depth=1).info("Uploading file: {}", path)
+        if self.enabled:
+            self._upload_file(key, path, **kwargs)
+
+    def _start(self) -> _T: ...
+    def _end(self) -> None: ...
+    def _log_metric(
+        self,
+        key: str,
+        value: float,
+        *,
+        step: float | None = None,
+        timestamp: float | None = None,
+        **kwargs,
+    ) -> None: ...
+    def _log_other(
+        self, key: str, value: bool | float | str | datetime.datetime, **kwargs
+    ) -> None: ...
+    def _upload_file(self, key: str, path: Path, **kwargs) -> None: ...
+
+
+_current_run: Run | None = None
+
+
+def current_run() -> Run:
+    global _current_run  # noqa: PLW0603
+    if _current_run is None:
+        _current_run = Run()
+    return _current_run
+
+
+def set_current_run(run: Run) -> None:
+    global _current_run  # noqa: PLW0603
+    _current_run = run

liblaf/cherries/integration/_neptune.py

@@ -0,0 +1,53 @@
+import datetime
+from pathlib import Path
+
+import neptune
+import neptune.common.exceptions
+
+from liblaf import cherries
+
+
+class RunNeptune(cherries.Run[neptune.Run]):
+    @property
+    def backend(self) -> str:
+        return "neptune"
+
+    @property
+    def id(self) -> str:
+        return self._backend["sys/id"].fetch()
+
+    @property
+    def name(self) -> str:
+        return self._backend["sys/name"].fetch()
+
+    @property
+    def url(self) -> str:
+        return self._backend.get_url()
+
+    def _start(self) -> neptune.Run:
+        return neptune.init_run()
+
+    def _end(self) -> None:
+        return self._backend.stop()
+
+    def _log_metric(
+        self,
+        key: str,
+        value: float,
+        *,
+        step: float | None = None,
+        timestamp: float | None = None,
+        **kwargs,  # noqa: ARG002
+    ) -> None:
+        self._backend[key].append(value, step=step, timestamp=timestamp)
+
+    def _log_other(
+        self,
+        key: str,
+        value: bool | float | str | datetime.datetime,
+        **kwargs,  # noqa: ARG002
+    ) -> None:
+        self._backend[key] = value
+
+    def _upload_file(self, key: str, path: Path, **kwargs) -> None:
+        return self._backend[key].upload(path, **kwargs)

liblaf/cherries/plugin/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/cherries/plugin/__init__.pyi

@@ -0,0 +1,6 @@
+from ._abc import Plugin
+from ._default import default_plugins
+from ._git import PluginGit
+from ._logging import PluginLogging
+
+__all__ = ["Plugin", "PluginGit", "PluginLogging", "default_plugins"]

liblaf/cherries/plugin/_abc.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import pydantic_settings as ps
+
+from liblaf import cherries
+
+
+class Plugin(ps.BaseSettings):
+    enabled: bool = True
+    priority: float = 0.0
+
+    def pre_start(self) -> None:
+        if self.enabled:
+            self._pre_start()
+
+    def post_start(self, run: cherries.Run) -> None:
+        if self.enabled:
+            self._post_start(run)
+
+    def pre_end(self, run: cherries.Run) -> None:
+        if self.enabled:
+            self._pre_end(run)
+
+    def post_end(self, run: cherries.Run) -> None:
+        if self.enabled:
+            self._post_end(run)
+
+    def _pre_start(self) -> None: ...
+    def _post_start(self, run: cherries.Run) -> None: ...
+    def _pre_end(self, run: cherries.Run) -> None: ...
+    def _post_end(self, run: cherries.Run) -> None: ...

liblaf/cherries/plugin/_default.py

@@ -0,0 +1,5 @@
+from liblaf import cherries
+
+
+def default_plugins() -> list[cherries.Plugin]:
+    return [cherries.plugin.PluginLogging(), cherries.plugin.PluginGit()]

liblaf/cherries/plugin/_git.py

@@ -0,0 +1,23 @@
+import git
+import pydantic_settings as ps
+
+from liblaf import cherries
+
+
+class PluginGit(cherries.Plugin):
+    model_config = ps.SettingsConfigDict(env_prefix="LIBLAF_CHERRIES_GIT_")
+    auto_commit: bool = True
+    auto_commit_message: str = cherries.git.DEFAULT_COMMIT_MESSAGE
+
+    def _pre_start(self) -> None:
+        if self.auto_commit:
+            cherries.git.commit(self.auto_commit_message)
+
+    def _post_start(self, run: cherries.Run) -> None:
+        r = git.Repo(search_parent_directories=True)
+        sha: str = r.head.commit.hexsha
+        run.log_other("cherries/git/sha", sha)
+        if browse := cherries.git.permalink(repo=r):
+            run.log_other("cherries/git/browse", browse)
+        if entrypoint := cherries.git.permalink(repo=r, filepath=run.entrypoint):
+            run.log_other("cherries/git/entrypoint", entrypoint)

liblaf/cherries/plugin/_logging.py

@@ -0,0 +1,20 @@
+import pydantic_settings as ps
+from loguru import logger
+
+# make pyright happy
+import liblaf.grapes as grapes  # noqa: PLR0402
+from liblaf import cherries
+
+
+class PluginLogging(cherries.Plugin):
+    model_config = ps.SettingsConfigDict(env_prefix="LIBLAF_CHERRIES_LOGGING_")
+
+    def _pre_start(self) -> None:
+        grapes.init_logging()
+        logger.add("run.log", enqueue=True, mode="w")
+        logger.add("run.log.jsonl", serialize=True, enqueue=True, mode="w")
+
+    def _pre_end(self, run: cherries.Run) -> None:
+        logger.complete()
+        run.upload_file("cherries/logging/run.log", "run.log")
+        run.upload_file("cherries/logging/run.log.jsonl", "run.log.jsonl")

liblaf/cherries/plugin/_restic.py

@@ -0,0 +1,45 @@
+import os
+import subprocess as sp
+from pathlib import Path
+
+import pydantic
+import pydantic_settings as ps
+from loguru import logger
+
+from liblaf import cherries
+
+
+def default_config() -> Path:
+    git_root: Path = cherries.git.root()
+    for path in [
+        git_root / ".config" / "resticprofile.toml",
+        git_root / "resticprofile.toml",
+    ]:
+        if path.exists():
+            return path
+    return git_root / ".config" / "resticprofile.toml"
+
+
+class PluginRestic(cherries.Plugin):
+    model_config = ps.SettingsConfigDict(env_prefix="LIBLAF_CHERRIES_RESTIC_")
+    config: Path = pydantic.Field(default_factory=default_config)
+    name: str | None = None
+    dry_run: bool = False
+
+    def _pre_end(self, run: cherries.Run) -> None:
+        if not self.config.exists():
+            logger.warning("configuration file '{}' was not found", self.config)
+            return
+        args: list[str | os.PathLike[str]] = [
+            "resticprofile",
+            "--config",
+            self.config,
+            "backup",
+        ]
+        if self.name:
+            args += ["--name", self.name]
+        if self.dry_run:
+            args.append("--dry-run")
+        args += ["--time", run.creation_time.strftime("%Y-%m-%d %H:%M:%S")]
+        proc: sp.CompletedProcess[bytes] = sp.run(args, check=False)
+        run.log_other("cherries/restic/returncode", proc.returncode)

liblaf/cherries/utils/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf_cherries-0.0.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: liblaf-cherries
+Version: 0.0.0
+Summary: Add your description here
+Project-URL: Changelog, https://github.com/liblaf/cherries/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/liblaf/cherries
+Project-URL: Issue Tracker, https://github.com/liblaf/cherries/issues
+Project-URL: Release Notes, https://github.com/liblaf/cherries/releases
+Project-URL: Source Code, https://github.com/liblaf/cherries
+Author-email: liblaf <30631553+liblaf@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: gitpython<4,>=3.1.44
+Requires-Dist: lazy-loader<0.5,>=0.4
+Requires-Dist: liblaf-grapes<0.0.1,>=0.0.0
+Requires-Dist: loguru<0.8,>=0.7.3
+Requires-Dist: neptune<2,>=1.13.0
+Requires-Dist: pydantic-settings<3,>=2.7.1
+Requires-Dist: pydantic<3,>=2.10.5
+Description-Content-Type: text/markdown
+
+# 🍒 Cherries

liblaf_cherries-0.0.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+liblaf/cherries/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/__init__.pyi,sha256=Qt8P1Fgtt2bC-5KnSjF0ruTKAtT9p4dGmnEfCbsdeR0,506
+liblaf/cherries/_start.py,sha256=VF2TyYcX6jWPxLA4wtLoNLIjMRhwXt3XQlR7xwnTdGI,1153
+liblaf/cherries/git/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/git/__init__.pyi,sha256=p52L1d1kuiwyc9tBz648Bm76C9DJLbgleE8EKRJM4Lg,371
+liblaf/cherries/git/_commit.py,sha256=jnAtCKljNnzhXK90cj3adAYkPvcnLnOrHWA8YWhtZF4,482
+liblaf/cherries/git/_entrypoint.py,sha256=My_TmLqpGX4NJV4qjQvmHtnwhxX_B2ilfuYvpj2ftaM,262
+liblaf/cherries/git/_repo.py,sha256=bE8apxawGie8KuEjQCDAVRSGTP7Qt6jDDtoXMhfWy4w,907
+liblaf/cherries/git/github/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/git/github/__init__.pyi,sha256=jspOamBde7EtGOqsIzWg75jFToVHRhG4hfiEw1MDz80,96
+liblaf/cherries/git/github/_link.py,sha256=f_AcdKMhukUZ2fgBtC0usBrwnpAHaLYo9EhkZYesZuQ,693
+liblaf/cherries/git/github/_repo.py,sha256=I3vjgonI_SPrytf68qzLAej880Zn7cPryaK4PPoVZpU,627
+liblaf/cherries/integration/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/integration/__init__.pyi,sha256=jSy9QJwmUTygGUNeOdkP5sk_thCJfXwYH9TMKJHfvhI,152
+liblaf/cherries/integration/_abc.py,sha256=se7Jf89HHs4Ssf1W7F_RTJDcPLIYkOJftmmVFRpytZA,3418
+liblaf/cherries/integration/_neptune.py,sha256=zpV5MN7_0Cqb-_t0vX2rXlHs-j5hDgH7FdwUczDo0Qc,1232
+liblaf/cherries/plugin/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/plugin/__init__.pyi,sha256=oDd9fUqu2YRb2EP-15j6YgHT40MH22O_jJbt9goPb3s,198
+liblaf/cherries/plugin/_abc.py,sha256=2ILWpFNLz7dCo-YL_UNzg3BaWoYyTuFOv98xBZZvyZE,806
+liblaf/cherries/plugin/_default.py,sha256=VrFEW2AQqsBNALPNzLBlStRk_2XcyMu1XwzhjRGNr8Q,152
+liblaf/cherries/plugin/_git.py,sha256=_t9lEAQOzEHV2qwzHwirdYg1t1br11Lp3hO4ArjVrXI,853
+liblaf/cherries/plugin/_logging.py,sha256=AGE9HZsRm-Z8hQn0HBSuu77PulF-_EN_Y29QvSMC4Bk,686
+liblaf/cherries/plugin/_restic.py,sha256=qW48Q043xZTB3xces9EJn-sFF4whnSlgVAjq2FnUoC4,1383
+liblaf/cherries/utils/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/utils/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+liblaf_cherries-0.0.0.dist-info/METADATA,sha256=DVW58aVJrIPxiuHFMWXUD73Ncyq0_6cJjy_TMR1Pwo8,890
+liblaf_cherries-0.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+liblaf_cherries-0.0.0.dist-info/licenses/LICENSE,sha256=Ph4NzyU3lGVDeYv-mf8aRmImH8v9rVL9F362FV4G6Ow,1063
+liblaf_cherries-0.0.0.dist-info/RECORD,,

liblaf_cherries-0.0.0.dist-info/WHEEL

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

liblaf_cherries-0.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 liblaf
+
+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.