structured-tutorials 0.1.0__py3-none-any.whl

structured_tutorials/sphinx/utils.py

@@ -0,0 +1,202 @@
+# Copyright (c) 2025 Mathias Ertl
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""Utility functions for the sphinx extension."""
+
+import os
+import shlex
+from copy import deepcopy
+from importlib import resources
+from pathlib import Path
+
+from jinja2 import Environment
+from sphinx.application import Sphinx
+from sphinx.config import Config
+from sphinx.errors import ConfigError, ExtensionError
+
+from structured_tutorials import templates
+from structured_tutorials.errors import DestinationIsADirectoryError
+from structured_tutorials.models import (
+    AlternativeModel,
+    CommandsPartModel,
+    FilePartModel,
+    PromptModel,
+    TutorialModel,
+)
+from structured_tutorials.textwrap import wrap_command_filter
+
+TEMPLATE_DIR = resources.files(templates)
+
+
+def validate_configuration(app: Sphinx, config: Config) -> None:
+    """Validate configuration directives, so that we can rely on values later."""
+    root = config.tutorial_root
+    if not isinstance(root, Path):
+        raise ConfigError(f"{root}: Must be of type Path.")
+    if not root.is_absolute():
+        raise ConfigError(f"{root}: Path must be absolute.")
+
+
+def get_tutorial_path(tutorial_root: Path, arg: str) -> Path:
+    """Get the full tutorial path and verify existence."""
+    tutorial_path = Path(arg)
+    if tutorial_path.is_absolute():
+        raise ExtensionError(f"{tutorial_path}: Path must not be absolute.")
+
+    absolute_path = tutorial_root / tutorial_path
+    if not absolute_path.exists():
+        raise ExtensionError(f"{absolute_path}: File not found.")
+    return absolute_path
+
+
+class TutorialWrapper:
+    """Wrapper class for rendering a tutorial.
+
+    This class exists mainly to wrap the main logic into a separate class that is more easily testable.
+    """
+
+    def __init__(self, tutorial: TutorialModel, command_text_width: int = 75) -> None:
+        self.tutorial = tutorial
+        self.next_part = 0
+        self.env = Environment(keep_trailing_newline=True)
+        self.env.filters["wrap_command"] = wrap_command_filter
+        self.context = deepcopy(tutorial.configuration.context)
+        self.context.update(deepcopy(tutorial.configuration.doc.context))
+
+        # settings from sphinx:
+        self.command_text_width = command_text_width
+
+    @classmethod
+    def from_file(cls, path: Path, command_text_width: int = 75) -> "TutorialWrapper":
+        """Factory method for creating a TutorialWrapper from a file."""
+        tutorial = TutorialModel.from_file(path)
+        return cls(tutorial)
+
+    def render(self, template: str) -> str:
+        return self.env.from_string(template).render(self.context)
+
+    def render_code_block(self, part: CommandsPartModel) -> str:
+        """Render a CommandsPartModel as a code-block."""
+        commands = []
+        for command_config in part.commands:
+            # Render the prompt
+            prompt = self.env.from_string(self.context["prompt_template"]).render(self.context)
+
+            # Render the command
+            if isinstance(command_config.command, str):
+                command = self.render(command_config.command)
+            else:
+                command = shlex.join(self.render(token) for token in command_config.command)
+
+            # Render output
+            output_template = command_config.doc.output.rstrip("\n")
+            output = self.env.from_string(output_template).render(self.context)
+
+            # Finally, render the command
+            command_template = """{{ command|wrap_command(prompt, text_width) }}{% if output %}
+{{ output }}{% endif %}"""
+            command_context = {
+                "prompt": prompt,
+                "command": command,
+                "output": output,
+                "text_width": self.command_text_width,
+            }
+            rendered_command = self.env.from_string(command_template).render(command_context)
+            commands.append(rendered_command)
+
+            # Update the context from update_context
+            self.context.update(command_config.doc.update_context)
+
+        template = """.. code-block:: console
+
+{% for cmd in commands %}{{ cmd|indent(4, first=True) }}
+{% endfor %}"""
+        return self.env.from_string(template).render({"commands": commands})
+
+    def render_file(self, part: FilePartModel) -> str:
+        content = part.contents
+        if content is None:
+            assert part.source is not None  # assured by model validation
+            with open(self.tutorial.tutorial_root / part.source) as stream:
+                content = stream.read()
+
+        # Only render template if it is configured to be a template.
+        if part.template:
+            content = self.render(content)
+
+        # Render the caption (default is the filename)
+        if part.doc.caption:
+            caption = self.render(part.doc.caption)
+        elif part.doc.caption is not False:
+            caption = self.render(str(part.destination))
+            if caption.endswith(os.path.sep):
+                # Model validation already validates that the destination does not look like a directory, if
+                # no source is set, but this could be tricked if the destination is a template.
+                if not part.source:
+                    raise DestinationIsADirectoryError(
+                        f"{caption}: Destination is directory, but no source given to derive filename."
+                    )
+                caption = os.path.join(caption, part.source.name)
+        else:
+            caption = ""
+
+        if part.doc.ignore_spelling:
+            caption = f":spelling:ignore:`{caption}`"
+
+        # Read template from resources
+        template_str = TEMPLATE_DIR.joinpath("file_part.rst.template").read_text("utf-8")
+
+        # Render template
+        template = self.env.from_string(template_str)
+        value = template.render({"part": part, "content": content, "caption": caption})
+        return value
+
+    def render_alternatives(self, part: AlternativeModel) -> str:
+        tabs = []
+        for key, alternate_part in part.alternatives.items():
+            key = self.tutorial.configuration.doc.alternative_names.get(key, key)
+
+            if isinstance(alternate_part, CommandsPartModel):
+                tabs.append((key, self.render_code_block(alternate_part).strip()))
+            elif isinstance(alternate_part, FilePartModel):
+                tabs.append((key, self.render_file(alternate_part).strip()))
+            else:  # pragma: no cover
+                raise ExtensionError("Alternative found unknown part type.")
+
+        # Read template from resources
+        template_str = TEMPLATE_DIR.joinpath("alternative_part.rst.template").read_text("utf-8")
+
+        # Render template
+        template = self.env.from_string(template_str)
+        value = template.render({"part": part, "tabs": tabs})
+        return value.strip()
+
+    def render_part(self, part_id: str | None = None) -> str:
+        """Render the given part of the tutorial."""
+        # Find the next part that is not skipped
+        for part in self.tutorial.parts[self.next_part :]:
+            self.next_part += 1
+
+            # Ignore prompt models when rendering tutorials.
+            if isinstance(part, PromptModel):
+                continue
+
+            # If the part is not configured to be skipped for docs, use it.
+            if not part.doc.skip:
+                if part_id is not None and part.id != part_id:
+                    raise ExtensionError(f"{part_id}: Part is not the next part (next one is {part.id}).")
+                break
+        else:
+            raise ExtensionError("No more parts left in tutorial.")
+
+        if isinstance(part, CommandsPartModel):
+            text = self.render_code_block(part)
+        elif isinstance(part, FilePartModel):
+            text = self.render_file(part)
+        elif isinstance(part, AlternativeModel):
+            text = self.render_alternatives(part)
+        else:  # pragma: no cover
+            raise ExtensionError(f"{part}: Unsupported part type.")
+
+        self.context.update(part.doc.update_context)
+        return text

structured_tutorials/templates/alternative_part.rst.template

@@ -0,0 +1,5 @@
+{% for title, contents in tabs %}
+.. tab:: {{ title }}
+
+    {{ contents|indent() }}
+{% endfor %}

structured_tutorials/templates/file_part.rst.template

@@ -0,0 +1,8 @@
+.. code-block::{% if part.doc.language %} {{ part.doc.language }}{% endif %}{% if caption %}
+    :caption: {{ caption }}{% endif %}{% if part.doc.linenos or part.doc.lineno_start %}
+    :linenos:{% endif %}{% if part.doc.lineno_start %}
+    :lineno-start: {{ part.doc.lineno_start }}{% endif %}{% if part.doc.emphasize_lines %}
+    :emphasize-lines: {{ part.doc.emphasize_lines }}{% endif %}{% if part.doc.name %}
+    :name: {{ part.doc.name }}{% endif %}
+
+    {{ content|indent() }}

structured_tutorials/textwrap.py

@@ -0,0 +1,96 @@
+# Copyright (c) 2025 Mathias Ertl
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""Module for wrapping text width."""
+
+import re
+import textwrap
+from collections.abc import Iterator
+from typing import Any
+
+
+class CommandLineTextWrapper(textwrap.TextWrapper):
+    """Subclass of TextWrapper that "unsplits" a short option and its (supposed) value.
+
+    This makes sure that a command with many options will not break between short options and their value,
+    e.g. for ``docker run -e FOO=foo -e BAR=bar ...``, the text wrapper will never insert a line split between
+    ``-e`` and its respective option value.
+
+    Note that the class of course does not know the semantics of the command it renders. A short option
+    followed by a value is always considered a reason not to break. For example, for ``docker run ... -d
+    image``, the wrapper will never split between ``-d`` and ``image``, despite the latter being unrelated to
+    the former.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.subsequent_indent = ">    "
+        self.break_on_hyphens = False
+        self.break_long_words = False
+        self.replace_whitespace = False
+
+    def _unsplit_optargs(self, chunks: list[str]) -> Iterator[str]:
+        unsplit: list[str] = []
+        for chunk in chunks:
+            if re.match("-[a-z]$", chunk):  # chunk appears to be an option
+                if unsplit:  # previous option was also an optarg, so yield what was there
+                    yield from unsplit
+                unsplit = [chunk]
+            elif chunk == " ":
+                if unsplit:  # this is the whitespace after an option
+                    unsplit.append(chunk)
+                else:  # a whitespace not preceded by an option
+                    yield chunk
+
+            # The unsplit buffer has two values (short option and space) and this chunk looks like its
+            # value, so yield the buffer and this value as split
+            elif len(unsplit) == 2 and re.match("[a-zA-Z0-9`]", chunk):
+                # unsplit option, whitespace and option value
+                unsplit.append(chunk)
+                yield "".join(unsplit)
+                unsplit = []
+
+            # There is something in the unsplit buffer, but this chunk does not look like a value (maybe
+            # it's a long option?), so we yield tokens from the buffer and then this chunk.
+            elif unsplit:
+                yield from unsplit
+                unsplit = []
+                yield chunk
+            else:
+                yield chunk
+
+        # yield any remaining chunks
+        yield from unsplit
+
+    def _split(self, text: str) -> list[str]:
+        chunks = super()._split(text)
+        chunks = list(self._unsplit_optargs(chunks))
+        return chunks
+
+
+def wrap_command_filter(command: str, prompt: str, text_width: int) -> str:
+    """Filter to wrap a command based on the given text width."""
+    lines = []
+    split_command_lines = tuple(enumerate(command.split("\\\n"), start=1))
+
+    # Split paragraphs based on backslash-newline and wrap them separately
+    for line_no, command_line in split_command_lines:
+        final_line = line_no == len(split_command_lines)
+
+        # Strip any remaining newline, they are treated as a single space
+        command_line = re.sub(r"\s*\n\s*", " ", command_line).strip()
+        if not command_line:
+            continue
+
+        wrapper = CommandLineTextWrapper(width=text_width)
+        if line_no == 1:
+            wrapper.initial_indent = prompt
+        else:
+            wrapper.initial_indent = wrapper.subsequent_indent
+
+        wrapped_command_lines = wrapper.wrap(command_line)
+        lines += [
+            f"{line} \\" if (i != len(wrapped_command_lines) or not final_line) else line
+            for i, line in enumerate(wrapped_command_lines, 1)
+        ]
+    return "\n".join(lines)

structured_tutorials/typing.py

@@ -0,0 +1,15 @@
+# Copyright (c) 2025 Mathias Ertl
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""Module that re-exports some type hints."""
+
+try:
+    from typing import Self
+except ImportError:  # pragma: no cover
+    # Note: only for py3.10
+    from typing_extensions import Self
+
+
+__all__ = [
+    "Self",
+]

structured_tutorials/utils.py

@@ -0,0 +1,78 @@
+# Copyright (c) 2025 Mathias Ertl
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""Utility functions."""
+
+import logging
+import os
+import random
+import string
+import subprocess
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+
+from structured_tutorials.errors import PromptNotConfirmedError
+from structured_tutorials.runners.base import RunnerBase
+
+log = logging.getLogger(__name__)
+
+
+@contextmanager
+def chdir(dest: str | Path) -> Iterator[Path]:
+    """Context manager to temporarily switch to a different directory."""
+    cwd = Path.cwd()
+    try:
+        os.chdir(dest)
+        yield cwd
+    finally:
+        os.chdir(cwd)
+
+
+@contextmanager
+def cleanup(runner: RunnerBase) -> Iterator[None]:
+    """Context manager to always run cleanup commands."""
+    try:
+        yield
+    except Exception as ex:
+        # Prompt the user to inspect the state if running in interactive mode AND the error is not already a
+        # prompt confirmation prompt (in which case we assume the user already inspected the state).
+        if not isinstance(ex, PromptNotConfirmedError):
+            log.exception(ex)
+
+        if runner.interactive and not isinstance(ex, PromptNotConfirmedError):
+            input(f"""An error occurred while running the tutorial.
+Current working directory is {os.getcwd()}
+
+Press Enter to continue... """)
+        raise
+    finally:
+        if runner.cleanup:
+            log.info("Running cleanup commands.")
+
+        for command_config in runner.cleanup:
+            runner.run_shell_command(command_config.command, command_config.show_output)
+
+
+def git_export(destination: str | Path, ref: str = "HEAD") -> Path:
+    """Export the git repository to `django-ca-{ref}/` in the given destination directory.
+
+    `ref` may be any valid git reference, usually a git tag.
+    """
+    # Add a random suffix to the export destination to improve build isolation (e.g. Docker Compose will use
+    # that directory name as a name for Docker images/containers).
+    random_suffix = "".join(random.choice(string.ascii_lowercase) for i in range(12))
+    destination = Path(destination) / f"git-export-{ref}-{random_suffix}"
+
+    if not destination.exists():  # pragma: no cover  # created by caller
+        destination.mkdir(parents=True)
+
+    with subprocess.Popen(["git", "archive", ref], stdout=subprocess.PIPE) as git_archive_cmd:
+        with subprocess.Popen(["tar", "-x", "-C", str(destination)], stdin=git_archive_cmd.stdout) as tar:
+            # TYPEHINT NOTE: stdout is not None b/c of stdout=subprocess.PIPE
+            stdout = git_archive_cmd.stdout
+            assert stdout is not None, "stdout not captured."
+            stdout.close()
+            tar.communicate()
+
+    return destination

structured_tutorials-0.1.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: structured-tutorials
+Version: 0.1.0
+Summary: Add your description here
+Project-URL: Homepage, https://structured-tutorials.readthedocs.io/
+Project-URL: Documentation, https://structured-tutorials.readthedocs.io/
+Project-URL: Source, https://github.com/mathiasertl/structured-tutorials
+Project-URL: Issues, https://github.com/mathiasertl/structured-tutorials/issues
+Project-URL: Changelog, https://structured-tutorials.readthedocs.io/en/latest/changelog.html
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Sphinx :: Extension
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Documentation :: Sphinx
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: pydantic>=2.11.4
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: sphinx-inline-tabs>=2025
+Requires-Dist: sphinx>=8.2.0; python_version >= '3.11'
+Requires-Dist: sphinx~=8.1.0; python_version < '3.11'
+Requires-Dist: termcolor>=3.2.0
+Requires-Dist: typing-extensions>=4.6.0; python_version < '3.11'
+Description-Content-Type: text/markdown
+
+# structured-tutorials
+
+![image](https://github.com/mathiasertl/structured-tutorials/workflows/Tests/badge.svg)
+![image](https://img.shields.io/pypi/v/structured-tutorials.svg)
+![image](https://img.shields.io/pypi/dm/structured-tutorials.svg)
+![image](https://img.shields.io/pypi/pyversions/structured-tutorials.svg)
+![image](https://img.shields.io/github/license/mathiasertl/structured-tutorials)
+
+`structured-tutorials` allows you to write tutorials that can be rendered as documentation and run on your
+system to verify correctness.
+
+With `structured-tutorials` you to specify steps in a configuration file. A Sphinx plugin allows you to
+render those commands in your project documentation. A command-line tool can load the configuration file and
+run it on your local system.
+
+Please see the [official documentation](https://structured-tutorials.readthedocs.io/) for more detailed
+information.
+
+## Installation / Setup
+
+Install `structured-tutorials`:
+
+```
+pip install structured-tutorials
+```
+
+and configure Sphinx:
+
+```python
+extensions = [
+    # ... other extensions
+    "structured_tutorials.sphinx",
+]
+
+# Optional: Root directory for tutorials
+#tutorial_root = DOC_ROOT / "tutorials"
+```
+
+## Your first (trivial) tutorial
+
+To create your first tutorial, create it in `docs/tutorial.yaml` (or elsewhere, if you configured
+`tutorial_root` in `conf.py`):
+
+```yaml
+parts:
+  - commands:
+      - command: structured-tutorial --help
+        doc:
+          output: |
+            usage: structured-tutorial [-h] path
+            ...
+```
+
+### Run the tutorial
+
+Run the tutorial with:
+
+```
+$ structured-tutorial docs/tutorials/quickstart/tutorial.yaml
+usage: structured-tutorial [-h] path
+...
+```
+
+### Render tutorial in Sphinx:
+
+Configure the tutorial that is being displayed - this will not show any output:
+
+```
+.. structured-tutorial:: quickstart/tutorial.yaml
+
+.. structured-tutorial-part::
+```
+
+## TODO
+* Run in vagrant
+
+# License
+
+This project is licensed under the MIT License. See LICENSE file for details.

structured_tutorials-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+structured_tutorials/__init__.py,sha256=W_mhMEZJOxXZYfkORGSmrZNomLjVzxn8gY3H_UCs8X8,299
+structured_tutorials/cli.py,sha256=Q_zvOphVtYujXZHtvYbHqJYWreZlpMgdYJabhkw7de8,2699
+structured_tutorials/errors.py,sha256=heVW-K4eN0cdsxKdk1S1RAZCAb5eqUt9Og0Qoh0bLhM,1172
+structured_tutorials/output.py,sha256=WxANwwxgquyS-x7398x5s0L-PCqHSAWNdFD5XbpG0ng,4356
+structured_tutorials/textwrap.py,sha256=2E64R_caU7BpoxejleHuL2FZxxXP2sbNeSeWu0VWmdg,3929
+structured_tutorials/typing.py,sha256=2iJCysQCUe9VYOS7xLY6rDii08aelFdu54qbNvCUTDE,314
+structured_tutorials/utils.py,sha256=RXy7AM-GRoecDolvg3oKUFl7WSgyneh4G6T5kjfcDpA,2786
+structured_tutorials/models/__init__.py,sha256=DYx6o75z_IS7Pd4TaFBfQzPz5pYtR0FUXklmIz1uADs,421
+structured_tutorials/models/base.py,sha256=B1vCbGYZqPitUciRPk_0sngId3nsgqOa1nJQKP0QiMM,3107
+structured_tutorials/models/parts.py,sha256=irRm2QZi8QH-HHSgWZNAbDFqsPKZM2cBNSE6caHPpMk,8605
+structured_tutorials/models/tests.py,sha256=CM680fZA8epEpGnsX2IMMvimgfl0Xb1-J5jj64Y4SaQ,1370
+structured_tutorials/models/tutorial.py,sha256=W2kBM_tWAV5IbdsGmuGvHrFVFKualc7AeEdTtqEkR3M,5787
+structured_tutorials/models/validators.py,sha256=M6bufqPHqQ6naBupsTly3DjzUqVhZZcVxreOpy14JlA,374
+structured_tutorials/runners/__init__.py,sha256=P8cPEhJfQvGG6v0exX7eSFWB6eJApUDpGtAJUhA6E0I,98
+structured_tutorials/runners/base.py,sha256=qz29GoBIc1VBvOhz7WfZqDzG4Sy2dY2TssdSQSwJCh4,4127
+structured_tutorials/runners/local.py,sha256=OGsqnVSBELdIDuw3rRhIsgPKw8qVxZ9Vk-UJ8I0Wbi0,10429
+structured_tutorials/sphinx/__init__.py,sha256=dDGX0z9OpaW_vwVD8c2ZZoB_zEchkAXw09xa_8jMmLk,1276
+structured_tutorials/sphinx/directives.py,sha256=1-d-n4rPsoKQh3cCdAQp6oY_qWFcTU-u9prSXfpZ6Sw,2604
+structured_tutorials/sphinx/utils.py,sha256=EAsia_0PI8gd-Wjmpy7Ja4BDMhMzMT42nmXq33qYu_U,8062
+structured_tutorials/templates/alternative_part.rst.template,sha256=wSkxUIjcfUuJFAuPpIxZ0wF6aQAdHyjdtD6AV1uyZ4A,96
+structured_tutorials/templates/file_part.rst.template,sha256=oLlYvZmagZMf4QRTxqVe-S0DT0mTVgAj44yV28gUu6Y,483
+structured_tutorials-0.1.0.dist-info/METADATA,sha256=ek0p1BnHQltFrQlOUteSp7WAiyD9zwS0uvA_OOhDrzs,3540
+structured_tutorials-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+structured_tutorials-0.1.0.dist-info/entry_points.txt,sha256=dTFaZHOXee91dHdOrGmaPyvfjQRL62LavX126kDe0nM,70
+structured_tutorials-0.1.0.dist-info/licenses/LICENSE,sha256=pcQmDRzVlV59FDIRkNrBg8jbk2Fl0rUvJGsogBF8lP0,1068
+structured_tutorials-0.1.0.dist-info/RECORD,,

structured_tutorials-0.1.0.dist-info/WHEEL

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

structured_tutorials-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+structured-tutorial = structured_tutorials.cli:main

structured_tutorials-0.1.0.dist-info/licenses/LICENSE

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