shellsafe 0.1.0__py3-none-any.whl

shellsafe/__init__.py

@@ -0,0 +1,18 @@
+"""shellsafe: safe shell commands via Python 3.14 template strings.
+
+Public surface (stable names, additive only through 1.0):
+run, capture, shx, RAW, CaptureResult.
+"""
+
+from ._version import __version__
+from .execute import CaptureResult, capture, run, shx
+from .raw import RAW
+
+__all__ = [
+    "RAW",
+    "CaptureResult",
+    "__version__",
+    "capture",
+    "run",
+    "shx",
+]

shellsafe/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

shellsafe/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

shellsafe/audit/__init__.py

@@ -0,0 +1,10 @@
+"""Offline AST audit for dangerous command construction. Ships with v0.3.0."""
+
+from __future__ import annotations
+
+from ..errors import ShellSafeError
+
+
+def scan(paths: list[str]) -> list[dict[str, object]]:
+    """Scan paths for AU001-AU004 findings. Arrives in shellsafe 0.3."""
+    raise ShellSafeError("audit arrives in shellsafe 0.3")

shellsafe/cli.py

@@ -0,0 +1,44 @@
+"""CLI wiring: audit, demo, version. Business logic lives in the stages."""
+
+from __future__ import annotations
+
+import argparse
+import platform
+import sys
+
+from . import exitcodes
+from ._version import __version__
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="shellsafe")
+    parser.add_argument("-V", "--version", action="store_true")
+    sub = parser.add_subparsers(dest="command")
+
+    sub.add_parser("audit", help="scan code for dangerous command construction (v0.3)")
+    sub.add_parser("version", help="detailed version and capability matrix")
+    return parser
+
+
+def _print_version_matrix() -> None:
+    py = platform.python_version()
+    print(f"shellsafe {__version__} · python {py} · {sys.platform}")
+    print("argv-mode: available")
+    print("shell-mode: arriving in 0.2")
+    print("audit: arriving in 0.3")
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _build_parser().parse_args(argv)
+
+    if args.version:
+        print(f"shellsafe {__version__}")
+        return exitcodes.OK
+    if args.command == "version":
+        _print_version_matrix()
+        return exitcodes.OK
+    if args.command == "audit":
+        print("audit arrives in shellsafe 0.3", file=sys.stderr)
+        return exitcodes.USAGE
+    _build_parser().print_help()
+    return exitcodes.OK

shellsafe/errors.py

@@ -0,0 +1,36 @@
+"""Exception hierarchy for shellsafe.
+
+Every error raised publicly inherits from ShellSafeError so callers can catch
+broadly. Messages are lowercase, state got and expected, and include the fix.
+"""
+
+
+class ShellSafeError(Exception):
+    """Base class for every error shellsafe raises."""
+
+
+class ShellSafeTypeError(ShellSafeError):
+    """A template or interpolated value has an unsupported type."""
+
+
+class UnsupportedPlatformError(ShellSafeError):
+    """The requested shell route cannot be made safe on this platform.
+
+    Interpolated shell routes are refused on Windows by policy; restructure the
+    command as argv mode (no pipes or redirections) instead.
+    """
+
+
+class ArgvOnlyError(ShellSafeError):
+    """shx() was called with a template that needs no shell at all.
+
+    Use run() for plain commands; shx() exists for pipes and redirections.
+    """
+
+
+class RawUsageError(ShellSafeError):
+    """RAW() was used incorrectly.
+
+    RAW takes exactly one argument: a list of strings in argv mode or a string
+    in shell mode. RAW values are never nested and never modified.
+    """

shellsafe/execute.py

@@ -0,0 +1,117 @@
+"""Subprocess wrappers over rendered ExecutionPlans."""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from typing import Any, cast
+
+from .errors import ArgvOnlyError, ShellSafeError
+from .raw import Raw  # noqa: F401  (re-exported through the package root)
+from .render import ExecutionPlan
+
+_SHELL_MODE_PENDS = (
+    "shell-mode execution arrives in shellsafe 0.2; "
+    "this release covers argv-mode commands"
+)
+
+_ALLOWED_KWARGS = frozenset(
+    {
+        "check",
+        "timeout",
+        "env",
+        "cwd",
+        "capture_output",
+        "input",
+        "stdin",
+        "stdout",
+        "stderr",
+        "start_new_session",
+        "text",
+        "encoding",
+    }
+)
+
+
+def _validate_kwargs(kwargs: dict[str, object]) -> None:
+    if "shell" in kwargs:
+        raise ShellSafeError(
+            "shellsafe never passes shell=True; use shx() on posix for pipes and "
+            "redirections"
+        )
+    unknown = set(kwargs) - _ALLOWED_KWARGS
+    if unknown:
+        valid = ", ".join(sorted(_ALLOWED_KWARGS))
+        raise ShellSafeError(
+            f"unsupported keyword(s) {sorted(unknown)}; valid keywords: {valid}"
+        )
+
+
+def plan(template: object) -> ExecutionPlan:
+    """Render a t-string into an inspectable ExecutionPlan without executing."""
+    from .render import plan as render_plan
+
+    return render_plan(template)
+
+
+def run(template: object, /, **kwargs: object) -> subprocess.CompletedProcess[str]:
+    """Render the template and execute it.
+
+    Interpolated values always arrive as single argv elements. Keyword arguments
+    pass through to subprocess.run with one exception: shell is rejected by
+    design.
+    """
+    _validate_kwargs(kwargs)
+    rendered = plan(template)
+    if rendered.mode == "shell":
+        raise ShellSafeError(_SHELL_MODE_PENDS)
+    assert rendered.argv is not None
+    # passthrough boundary: values are caller-owned subprocess kwargs
+    typed_kwargs = cast(
+        "dict[str, Any]",
+        {k: v for k, v in kwargs.items() if k in _ALLOWED_KWARGS},
+    )
+    result = subprocess.run(rendered.argv, **typed_kwargs)
+    return cast("subprocess.CompletedProcess[str]", result)
+
+
+@dataclass(frozen=True, slots=True)
+class CaptureResult:
+    """Text-captured execution result plus the plan that produced it."""
+
+    stdout: str
+    stderr: str
+    returncode: int
+    plan: ExecutionPlan
+
+
+def capture(template: object, /, **kwargs: object) -> CaptureResult:
+    """Run with captured utf-8 stdout/stderr and return a CaptureResult."""
+    kwargs["capture_output"] = True
+    kwargs["text"] = True
+    kwargs["encoding"] = "utf-8"
+    completed = run(template, **kwargs)
+    assert isinstance(completed.stdout, str)
+    assert isinstance(completed.stderr, str)
+    return CaptureResult(
+        stdout=completed.stdout,
+        stderr=completed.stderr,
+        returncode=completed.returncode,
+        plan=plan(template),
+    )
+
+
+def shx(template: object, /, **kwargs: object) -> object:
+    """Shell-route alias for templates that need pipes or redirections.
+
+    Raises ArgvOnlyError when the template needs no shell at all, so a missing
+    pipe is never silently ignored. Full shell execution ships in shellsafe 0.2;
+    rendering and inspection work today via shellsafe.plan().
+    """
+    _validate_kwargs(kwargs)
+    rendered = plan(template)
+    if rendered.mode != "shell":
+        raise ArgvOnlyError(
+            "template contains no shell metacharacters; use run() instead"
+        )
+    raise ShellSafeError(_SHELL_MODE_PENDS)

shellsafe/exitcodes.py

@@ -0,0 +1,6 @@
+"""Process exit codes for the shellsafe CLI. Part of the public contract."""
+
+OK = 0
+FINDINGS = 1
+USAGE = 2
+INTERNAL = 3

shellsafe/platforms.py

@@ -0,0 +1,35 @@
+"""Platform policy tables and helpers. This module IS the security policy."""
+
+from __future__ import annotations
+
+import sys
+
+# Static template text containing any of these routes the command to shell mode.
+# Whitespace is not here: it splits words in argv mode.
+METACHARACTERS: frozenset[str] = frozenset("|&;()<>$`\"'*?!#\\\n\r\t")
+
+IS_WINDOWS = sys.platform.startswith("win")
+
+
+def route_for(static_text: str) -> str:
+    """Return "argv" or "shell" for the given static template text.
+
+    Raises UnsupportedPlatformError when shell features are requested on Windows;
+    cmd.exe quoting cannot be made injection-safe, so the refusal is the feature.
+    """
+    has_meta = any(ch in METACHARACTERS for ch in static_text)
+    if not has_meta:
+        return "argv"
+    if IS_WINDOWS:
+        raise _windows_error()
+    return "shell"
+
+
+def _windows_error() -> Exception:
+    from .errors import UnsupportedPlatformError
+
+    return UnsupportedPlatformError(
+        "shell metacharacters in a shellsafe template require posix sh; "
+        "windows cmd.exe quoting cannot be made injection-safe. "
+        "restructure without pipes/redirections, or run under wsl."
+    )

shellsafe/raw.py

@@ -0,0 +1,30 @@
+"""RAW marker: the single explicit trust boundary."""
+
+from __future__ import annotations
+
+from .errors import RawUsageError
+
+
+class Raw:
+    """Wraps pre-trusted content that rendering must not modify.
+
+    In argv mode the wrapped value must be a list of strings and is spliced
+    into the argv positionally. In POSIX shell mode a str value is inserted
+    verbatim into the shell line. Nothing else is accepted, nesting is refused,
+    and every use site is greppable.
+    """
+
+    __slots__ = ("value",)
+
+    def __init__(self, value: list[str] | str) -> None:
+        if isinstance(value, Raw):
+            raise RawUsageError("raw cannot wrap another raw")
+        self.value = value
+
+    def __repr__(self) -> str:
+        return f"<RAW {self.value!r}>"
+
+
+def RAW(value: list[str] | str) -> Raw:
+    """Mark content as pre-trusted. See Raw for mode-specific rules."""
+    return Raw(value)

shellsafe/render.py

@@ -0,0 +1,192 @@
+"""Template rendering: t-string in, ExecutionPlan out. Pure and deterministic.
+
+Security invariants (property-tested, see docs/07_rendering_engine_spec.md):
+- INV-1: every interpolation contributes exactly one argv element equal to its
+  resolved string.
+- INV-2: the executable comes from static template text only.
+- INV-3: element count equals static words plus interpolations plus RAW splices.
+"""
+
+from __future__ import annotations
+
+import shlex
+from dataclasses import dataclass
+from string.templatelib import Interpolation, Template
+
+from .errors import RawUsageError, ShellSafeTypeError
+from .platforms import route_for
+from .raw import Raw
+
+_NUL = "\x00"
+
+# Static-text characters that require shell semantics (pipes, redirection,
+# substitution, globs, comments). Whitespace is absent here: it splits words
+# in argv mode rather than forcing a shell.
+METACHARACTERS: frozenset[str] = frozenset("|&;()<>$`\"'*?!#\n\r\t\\")
+
+
+@dataclass(frozen=True, slots=True)
+class ExecutionPlan:
+    """The exact thing that will execute. Inspect via repr before running."""
+
+    mode: str  # "argv" or "shell"
+    argv: tuple[str, ...] | None = None
+    shell_line: str | None = None
+
+    def __repr__(self) -> str:
+        if self.mode == "argv":
+            assert self.argv is not None
+            body = ",".join(repr(a) for a in self.argv)
+            return f"argv: [{body}]"
+        assert self.shell_line is not None
+        return f"shell: {self.shell_line}"
+
+
+Segment = str | Interpolation[str] | Raw
+
+
+def _walk(
+    template: Template, seen: frozenset[int]
+) -> list[Segment]:
+    """Flatten a template into an ordered list of static text and interpolations.
+
+    Nested templates (a t-string interpolated inside a t-string) splice their
+    segments at the interpolation position. Cycle-guarded via object ids.
+    """
+    parts: list[Segment] = []
+    for element in template:
+        if isinstance(element, str):
+            parts.append(element)
+        elif isinstance(element, Interpolation):
+            if isinstance(element.value, Raw):
+                parts.append(Raw(element.value.value))
+            elif isinstance(element.value, Template):
+                if id(element.value) in seen:
+                    raise ShellSafeTypeError("template references itself")
+                parts.extend(_walk(element.value, seen | {id(element.value)}))
+            else:
+                parts.append(element)
+        else:
+            raise ShellSafeTypeError(
+                f"unexpected template element {type(element).__name__}"
+            )
+    return parts
+
+
+def _resolve(interpolation: Interpolation[str]) -> str:
+    """Resolve one interpolation exactly as an f-string would."""
+    value = interpolation.value
+    if isinstance(value, (bytes, bytearray)):
+        raise ShellSafeTypeError(
+            "bytes interpolation is ambiguous; decode it explicitly first"
+        )
+    conversion = interpolation.conversion
+    format_spec = interpolation.format_spec
+
+    converted: object
+    if conversion is None:
+        converted = value
+    elif conversion == "r":
+        converted = repr(value)
+    elif conversion == "s":
+        converted = str(value)
+    elif conversion == "a":
+        converted = ascii(value)
+    else:
+        raise ShellSafeTypeError(
+            f"unsupported conversion {conversion!r}; expected 'r', 's', 'a', or None"
+        )
+
+    if format_spec:
+        return format(converted, format_spec)
+    if conversion is None:
+        return str(converted)
+    assert isinstance(converted, str)
+    return converted
+
+
+def _reject_nul(resolved: str) -> None:
+    if _NUL in resolved:
+        raise ShellSafeTypeError(
+            "interpolated value contains a NUL byte after formatting; "
+            "executables cannot receive NUL bytes"
+        )
+
+
+def plan(template: object) -> ExecutionPlan:
+    """Render a t-string into an inspectable ExecutionPlan."""
+    if not isinstance(template, Template):
+        raise ShellSafeTypeError(
+            f"expected a t-string template, got {type(template).__name__}"
+        )
+
+    parts = _walk(template, frozenset({id(template)}))
+    route = route_for("".join(p for p in parts if isinstance(p, str)))
+
+    if route == "argv":
+        return _render_argv(parts)
+    return _render_shell(parts)
+
+
+def _render_argv(parts: list[Segment]) -> ExecutionPlan:
+    argv: list[str] = []
+    origins: list[str] = []
+
+    for part in parts:
+        if isinstance(part, str):
+            for word in part.split():
+                argv.append(word)
+                origins.append("static")
+        elif isinstance(part, Raw):
+            raw_value = part.value
+            if not isinstance(raw_value, list):
+                raise RawUsageError(
+                    "RAW str values are only valid in shell mode; "
+                    "in argv mode pass RAW(['one', 'argv', 'element'])"
+                )
+            for element in raw_value:
+                if not isinstance(element, str):
+                    raise RawUsageError(
+                        "RAW lists in argv mode contain strings only; got "
+                        f"{type(element).__name__}"
+                    )
+                _reject_nul(element)
+                argv.append(element)
+                origins.append("raw")
+        else:
+            resolved = _resolve(part)
+            _reject_nul(resolved)
+            argv.append(resolved)
+            origins.append("interpolation")
+
+    if not argv:
+        raise ShellSafeTypeError("empty command")
+
+    if origins[0] != "static":
+        raise ShellSafeTypeError(
+            "the executable must come from static template text; "
+            "interpolate arguments instead of commands"
+        )
+
+    return ExecutionPlan(mode="argv", argv=tuple(argv))
+
+
+def _render_shell(parts: list[Segment]) -> ExecutionPlan:
+    line_parts: list[str] = []
+    for part in parts:
+        if isinstance(part, str):
+            line_parts.append(part)
+        elif isinstance(part, Raw):
+            raw_value = part.value
+            if not isinstance(raw_value, str):
+                raise RawUsageError(
+                    "RAW list values are only valid in argv mode; "
+                    "in shell mode pass a single string"
+                )
+            _reject_nul(raw_value)
+            line_parts.append(raw_value)
+        else:
+            resolved = _resolve(part)
+            _reject_nul(resolved)
+            line_parts.append(shlex.quote(resolved))
+    return ExecutionPlan(mode="shell", shell_line="".join(line_parts))

shellsafe/reporters.py

@@ -0,0 +1 @@
+"""Finding reporters: terminal and json. Arrives in shellsafe 0.3."""

shellsafe-0.1.0.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.5
+Name: shellsafe
+Version: 0.1.0
+Summary: Safe shell commands via Python 3.14 template strings. Injection-proof by construction.
+Project-URL: Repository, https://github.com/rahulXs/shellsafe
+Project-URL: Issues, https://github.com/rahulXs/shellsafe/issues
+Project-URL: Changelog, https://github.com/rahulXs/shellsafe/blob/main/CHANGELOG.md
+Author-email: Rahul Sharma <rahulxsh@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: automation,command-injection,injection,pep750,security,shell,subprocess,t-strings,template-strings
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# shellsafe
+
+> Safe shell commands via Python 3.14 template strings. Injection-proof by
+> construction.
+
+```python
+from shellsafe import run
+
+message = get_user_input()          # "fix; rm -rf ~"
+run(t"git commit -m {message}")
+# argv: ["git", "commit", "-m", "fix; rm -rf ~"]
+# one command; the scary text is just an argument
+```
+
+## Why
+
+The dominant pattern in scripts and automation is still this:
+
+```python
+subprocess.run(f"git commit -m {message}", shell=True)   # injection waiting to happen
+```
+
+Python 3.14 template strings (`t"..."`) separate static text from interpolated
+values. shellsafe turns that structure into argv lists where interpolated values
+are always data, never commands. When you genuinely need pipes, shell mode quotes
+every value with POSIX rules first.
+
+## Install
+
+```bash
+pip install shellsafe
+```
+
+Requires Python 3.14+ (template strings).
+
+## Usage
+
+Run a command. Interpolated values are always single arguments:
+
+```python
+from shellsafe import run
+
+run(t"mkdir {path}")
+run(t"docker build -t {tag} .", check=True, timeout=300)
+```
+
+Capture output as text:
+
+```python
+from shellsafe import capture
+
+res = capture(t"grep {pattern} {file}")
+print(res.stdout, res.returncode)
+```
+
+Pipes and redirections on POSIX (values are quoted with `shlex.quote` first):
+
+```python
+from shellsafe import shx
+
+shx(t"cat {file} | wc -l")
+```
+
+Inspect exactly what will execute:
+
+```python
+from shellsafe import plan  # lower-level: render without running
+
+print(plan(t"git commit -m {message}"))
+# argv: ["git","commit","-m","fix; rm -rf ~"]
+```
+
+## What it refuses
+
+| Case | Behavior |
+|---|---|
+| Interpolation as the executable | error: the command comes from static text only |
+| Shell route on Windows | error: cmd.exe quoting cannot be made injection-safe; use argv mode |
+| RAW misuse | error: one argument, verbatim, nesting refused |
+
+`RAW("...")` / `RAW(["a", "b"])` is the single explicit trust boundary for
+pre-quoted content. Every use site is greppable.
+
+## Limits
+
+- Windows: interpolated shell routes are refused rather than approximated;
+  argv-mode commands work fully.
+- Bytes interpolations are rejected: decode explicitly first.
+- Runtime behavior after import is your test suite's job, same trust model as
+  calling subprocess yourself.
+
+## Contributing
+
+Issues and PRs welcome. Security reports go privately to the maintainer, never
+through public issues.
+
+## Requirements
+
+- CPython >= 3.14 (uses template strings from PEP 750)
+- Linux, macOS, Windows (Windows supports argv mode; POSIX-only shell mode)
+
+## License
+
+MIT

shellsafe-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+shellsafe/__init__.py,sha256=nTpsWvya8AVgO1OoY2CKfGjllbeUJvAJYkKKPFqJxdk,383
+shellsafe/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+shellsafe/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+shellsafe/cli.py,sha256=TVjCrcPuS01JLd5DBAnDrovnlVDJYwjFyGBU0r5I_dY,1337
+shellsafe/errors.py,sha256=chDBp9q221IneE2El1jOwKNYi4c55fovvhJkDTjDYps,1092
+shellsafe/execute.py,sha256=RFzzsbz-7Jp94gJbEq2gPUyAZdxRByX9EVkinYH2oe8,3561
+shellsafe/exitcodes.py,sha256=XtYF6a0AWUu13UI0SMij8fh3MnrDTTkWboiN3hPyIF0,121
+shellsafe/platforms.py,sha256=s-tM-R3HARXSdhwgaUgE6Mn-Hc0FxzvKcoVc6e6Ny9U,1176
+shellsafe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shellsafe/raw.py,sha256=qgx-AW7N1owB65u8lR3thMncAXZqnLvmMQyinEcb3nY,898
+shellsafe/render.py,sha256=yy29C6_NPtKF6nbywbbxWimcD5h2yYPKGnnG6QUiZdE,6528
+shellsafe/reporters.py,sha256=iHjEoqrwG665eOon9Yy6QK19mIwou42BkmZYrl2xc2M,70
+shellsafe/audit/__init__.py,sha256=NLJA1Fg7zRqno4HSoyNOWHHJmxVOZgxvnF31PYuiOUc,341
+shellsafe/audit/rules.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shellsafe-0.1.0.dist-info/METADATA,sha256=tiaMAuC2Iyp9CINJ8CBUa4-uIvlmbsQDVJE9qqju84A,3543
+shellsafe-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+shellsafe-0.1.0.dist-info/entry_points.txt,sha256=DmSHwYR25TXX7V-tOAz-WN3o8XRA5wb6tguDBaQq9Z0,49
+shellsafe-0.1.0.dist-info/licenses/LICENSE,sha256=IP9ZsQ9Wh-8yPf3q3yVB83H9MqyWinWhSgU5bTQb_ko,1079
+shellsafe-0.1.0.dist-info/RECORD,,

shellsafe-0.1.0.dist-info/WHEEL

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

shellsafe-0.1.0.dist-info/entry_points.txt

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

shellsafe-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rahul Sharma (rahulXs)
+
+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.