pg-maker 0.1.0__py3-none-any.whl

pg_maker/validation/packages.py

@@ -0,0 +1,309 @@
+"""Run installed-product checks in fresh, network-isolated test environments."""
+
+import shutil
+import sys
+from dataclasses import asdict
+
+from pg_maker.config import resource_path
+from pg_maker.errors import CancelledError, CommandError, PreconditionError
+from pg_maker.models import CleanupPolicy, CommandSpec, EnvironmentSpec
+from pg_maker.packaging.deb import inspect_deb
+from pg_maker.packaging.service import settings
+from pg_maker.planning.runtime_repository import verify_repository
+from pg_maker.runners.docker import DockerRunner
+from pg_maker.storage import content_hash, ensure_directory, file_hash, read_json, write_json
+from pg_maker.yamlio import load_yaml
+
+INSTALL_CAPABILITIES = ("CHOWN", "DAC_OVERRIDE", "FOWNER", "FSETID", "SETUID", "SETGID", "KILL")
+SERVER_CHECKS = {
+    "missing-internal-dependency-rejected",
+    "installed-inventory-and-loader",
+    "install-does-not-initdb",
+    "empty-pgdata-start-rejected",
+    "service-start-status-reload",
+    "socket-and-tcp",
+    "compiled-socket-default",
+    "installed-server-version",
+    "restart-preserves-data",
+    "dump-restore",
+    "crash-recovery",
+    "checksums",
+    "invalid-config-permissions-port-socket-rejected",
+    "reinstall-preserves-config-data",
+    "config-and-file-logs-in-pgdata",
+    "remove-preserves-data",
+    "install-after-remove",
+    "purge-preserves-data",
+}
+
+
+def runtime_repository(branch):
+    image = next(
+        i
+        for i in branch.request.lock["spec"]["environments"]["spec"]["images"]
+        if i["id"] == branch.variant["target"] + ".build"
+    )
+    repository = image.get("runtime_repository")
+    if not repository or repository["repository_hash"] != content_hash(repository["files"]):
+        raise PreconditionError(
+            "prepared build image has no pinned runtime repository; run env prepare"
+        )
+    destination = branch.output / "runtime-repository"
+    if not destination.exists():
+        branch.prepare()
+        branch.runner._control(
+            ["cp", branch.handle.container_id + ":" + repository["path"], str(destination)]
+        )
+    # APT's empty scratch entries are not part of its package inventory.
+    for name in ("partial", "lock"):
+        path = destination / name
+        if path.is_symlink():
+            raise PreconditionError("runtime repository contains a symlink")
+        if path.is_dir() and not any(path.iterdir()):
+            path.rmdir()
+        elif path.is_file() and not path.stat().st_size:
+            path.unlink()
+    verify_repository(destination, repository)
+    write_json(branch.output / "runtime-repository.json", repository)
+    return destination
+
+
+def validate_packages(branch, *, run_database=True):
+    repository = runtime_repository(branch)
+    package_list = read_json(branch.output / "packages.json")
+    for package in package_list:
+        if file_hash(branch.output / package["path"]) != package["sha256"]:
+            raise PreconditionError("package changed before installation")
+    tree = read_json(branch.output / "install-tree.json")
+    previous = next(
+        (
+            r
+            for r in branch.config.get("previous_releases", [])
+            if r["variant"] == branch.variant["id"] and branch.branch == "candidate"
+        ),
+        None,
+    )
+    previous_packages = []
+    if previous:
+        for item in previous["packages"]:
+            path = branch.inputs.blob(item["sha256"])
+            metadata = inspect_deb(path)["control"]
+            current = next(p for p in package_list if p["role"] == item["role"])
+            if (
+                metadata.get("Package") != current["name"]
+                or metadata.get("Architecture") != current["native_arch"]
+            ):
+                raise PreconditionError("previous package identity differs from the upgrade target")
+            previous_packages.append(
+                {**item, "version": metadata["Version"], "filename": item["role"] + ".deb"}
+            )
+    branch.release()
+    acceptance, seen = [], set()
+    for change in branch.feature["spec"]["changes"]:
+        for test in change["spec"]["acceptance"]:
+            if branch.branch not in test["expectations"]:
+                continue
+            if test["id"] in seen:
+                continue
+            seen.add(test["id"])
+            blob = branch.inputs.blob(test["script"]["sha256"])
+            item = dict(test)
+            if test["kind"] == "command":
+                document = load_yaml(blob)
+                if set(document) != {"argv"} or not isinstance(document["argv"], list):
+                    raise PreconditionError("invalid command acceptance script")
+                item["argv"] = document["argv"]
+            else:
+                item["sql"] = blob.read_text()
+            acceptance.append(item)
+    outcomes = []
+    scenarios = [
+        ("libpq", ("libpq",)),
+        ("client", ("libpq", "client")),
+        ("server", ("libpq", "client", "server")),
+    ]
+    documentation = branch.config.get("documentation", {}).get("enabled", False)
+    if documentation:
+        scenarios[-1] = ("server", ("libpq", "client", "server", "docs"))
+        scenarios.append(("docs", ("docs",)))
+    if previous and run_database:
+        scenarios.append(("upgrade", ("libpq", "client", "server")))
+    for label, roles in scenarios:
+        branch.context.check()
+        workspace = (
+            branch.context.directory
+            / "validation"
+            / branch.id
+            / str(branch.context.state["attempt"])
+            / label
+        )
+        ensure_directory(workspace)
+        runner = DockerRunner(
+            branch.context.directory,
+            operation_id=branch.context.directory.name,
+            owner_token=branch.context.state["owner_token"],
+            cancelled=branch.context.token.requested,
+            on_process=branch.context.on_process,
+            attempt=branch.context.state["attempt"],
+            workspace=workspace,
+        )
+        source = workspace / "source"
+        ensure_directory(source)
+        shutil.copytree(branch.output / "packages", source / "packages")
+        verify_repository(repository, read_json(branch.output / "runtime-repository.json"))
+        shutil.copytree(repository, source / "repository", symlinks=True)
+        if label == "upgrade":
+            ensure_directory(source / "previous")
+            for item in previous_packages:
+                shutil.copyfile(
+                    branch.inputs.blob(item["sha256"]), source / "previous" / item["filename"]
+                )
+        for name in ("systemctl.py", "installed.py"):
+            shutil.copyfile(resource_path("validation", name), source / name)
+        if documentation:
+            shutil.copytree(
+                resource_path(),
+                source / "doc-tools/pg_maker",
+                ignore=shutil.ignore_patterns("__pycache__", "*.pyc"),
+            )
+        config = {
+            "service": settings(branch.config, branch.variant),
+            "roles": roles,
+            "packages": package_list,
+            "inventory": tree["entries"],
+            "branch": branch.branch,
+            "postgresql_version": branch.config["postgresql"]["version"],
+            "components": [
+                {"id": c["metadata"]["id"], **c["spec"]}
+                for c in branch.feature["spec"]["components"]
+            ],
+            "acceptance": acceptance,
+            "run_database": run_database,
+            "previous_declared": previous is not None,
+            "previous": {**previous, "packages": previous_packages} if label == "upgrade" else None,
+            "documentation": read_json(branch.output / "installed-docs.json")
+            if documentation
+            else None,
+            "documentation_root": branch.variant["identity"]["paths"]["documentation_directory"],
+            "documentation_branding": branch.config["documentation"]["branding"],
+        }
+        write_json(source / "config.json", config)
+        environment = EnvironmentSpec(
+            branch.step["image_id"], "0:0", branch.id + ".packages." + label
+        )
+        handle = runner.intended_handle(environment)
+
+        def record(handle):
+            branch.context.event(
+                "environment_recorded",
+                resources=[
+                    {
+                        "kind": "docker",
+                        "name": handle.name,
+                        "labels": handle.labels,
+                        "container_id": handle.container_id,
+                        "environment": asdict(handle.environment),
+                    }
+                ],
+            )
+
+        record(handle)
+        try:
+            handle = runner.prepare(
+                environment,
+                memory_bytes=branch.step["resources"]["memory_bytes"],
+                cpu_jobs=branch.step["resources"]["cpu_jobs"],
+                capabilities=INSTALL_CAPABILITIES,
+            )
+            record(handle)
+            command = CommandSpec(
+                branch.id + ".packages." + label,
+                (
+                    "python3",
+                    "/work/source/installed.py",
+                    "/work/source/config.json",
+                    "/tmp/pg-maker-results",
+                ),
+                cwd="/",
+                timeout_seconds=branch.step["timeout_seconds"],
+            )
+            result = runner.execute(handle, command)
+            output = branch.output / "package-tests" / label
+            ensure_directory(output.parent)
+            copied = runner._control(
+                ["cp", handle.container_id + ":/tmp/pg-maker-results", str(output)],
+                check=False,
+            )
+            if result.cancelled:
+                raise CancelledError("package validation cancelled")
+            if (
+                not result.succeeded
+                or not copied.succeeded
+                or not (output / "result.json").is_file()
+            ):
+                raise CommandError(
+                    "installed package checks failed",
+                    details={
+                        "set": label,
+                        "stderr": result.stderr_tail,
+                        "timed_out": result.timed_out,
+                    },
+                )
+            report = read_json(output / "result.json")
+            required = (
+                {"previous-release-upgrade"}
+                if label == "upgrade"
+                else SERVER_CHECKS
+                if label == "server" and run_database
+                else {
+                    "installed-inventory-and-loader",
+                    "install-does-not-initdb",
+                    "empty-pgdata-start-rejected",
+                    "remove-preserves-empty-pgdata",
+                }
+                if label == "server"
+                else {
+                    "installed-inventory-and-loader",
+                    "no-cluster-or-service",
+                    "standalone-remove",
+                }
+            )
+            passed = {c["id"] for c in report["checks"] if c["status"] == "passed"}
+            if documentation and label != "upgrade":
+                required = required | {"installed-documentation"}
+            if not report["passed"] or not required <= passed:
+                raise CommandError("installed check evidence is incomplete")
+            if (
+                label == "server"
+                and run_database
+                and not {"acceptance:" + t["id"] for t in acceptance} <= passed
+            ):
+                raise CommandError("installed acceptance evidence is incomplete")
+            outcomes.append(
+                {
+                    "set": label,
+                    "passed": True,
+                    "checks": sorted(passed),
+                    "path": "package-tests/" + label + "/result.json",
+                    "sha256": file_hash(output / "result.json"),
+                }
+            )
+        finally:
+            original_error = sys.exc_info()[1]
+            try:
+                runner.release(handle, CleanupPolicy.REMOVE)
+                branch.context.event("environment_released", resources=[])
+            except Exception:
+                if original_error is None:
+                    raise
+                # Keep the exact refs for cancel/resume without hiding the original test error.
+                branch.context.event("environment_cleanup_failed")
+    result = {
+        "passed": True,
+        "sets": outcomes,
+        "run_database": run_database,
+        "service_manager": "emulated",
+    }
+    write_json(branch.output / "package-tests.json", result)
+    branch.report["package_tests"] = result
+    return result

pg_maker/validation/systemctl.py

@@ -0,0 +1,185 @@
+#!/usr/bin/python3
+"""Strict test-only systemctl subset for pg_maker's generated units.
+
+This is an independent, small harness, not the legacy EUPL systemctl implementation.
+It never claims native systemd/cgroup behavior and rejects unsupported directives.
+"""
+
+from __future__ import annotations
+
+import configparser
+import os
+import pwd
+import shlex
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+SUPPORTED = {
+    "Unit": {"Description", "After"},
+    "Service": {
+        "Type",
+        "User",
+        "Group",
+        "WorkingDirectory",
+        "Environment",
+        "PIDFile",
+        "ExecStartPre",
+        "ExecStart",
+        "ExecStop",
+        "ExecReload",
+        "TimeoutStartSec",
+        "TimeoutStopSec",
+    },
+    "Install": {"WantedBy"},
+}
+
+
+def load_unit(name):
+    if "/" in name or not name.endswith(".service"):
+        raise ValueError("an explicit service name is required")
+    path = Path("/usr/lib/systemd/system") / name
+    parser = configparser.ConfigParser(interpolation=None, strict=True)
+    parser.optionxform = str
+    with path.open() as stream:
+        parser.read_file(stream)
+    for section in parser.sections():
+        if section not in SUPPORTED or set(parser[section]) - SUPPORTED[section]:
+            raise ValueError("unsupported unit directive")
+    service = dict(parser["Service"])
+    if service["Type"] != "forking":
+        raise ValueError("only forking units are supported")
+    if parser["Install"]["WantedBy"] != "multi-user.target":
+        raise ValueError("unsupported install target")
+    if any("%" in value for section in parser.sections() for value in parser[section].values()):
+        raise ValueError("unit specifiers are unsupported by this harness")
+    return service
+
+
+def pid(service):
+    try:
+        lines = Path(service["PIDFile"]).read_text().splitlines()
+        number = int(lines[0])
+        data = str(Path(service["PIDFile"]).parent)
+        if len(lines) < 2 or lines[1] != data:
+            return None
+        if number <= 1:
+            return None
+        process = Path("/proc") / str(number)
+        if process.stat().st_uid != pwd.getpwnam(service["User"]).pw_uid:
+            return None
+        if process.joinpath("stat").read_text().rsplit(")", 1)[1].split()[0] == "Z":
+            return None
+        command = process.joinpath("cmdline").read_bytes().split(b"\0")[0].decode()
+        expected = str(Path(shlex.split(service["ExecStart"])[0]).with_name("postgres"))
+        if command != expected and not command.startswith(expected + " "):
+            return None
+        arguments = shlex.split(
+            process.joinpath("cmdline").read_bytes().replace(b"\0", b" ").decode()
+        )
+        if "-D" not in arguments or arguments[arguments.index("-D") + 1] != data:
+            return None
+        os.kill(number, 0)
+        return number
+    except (OSError, ValueError, KeyError, IndexError):
+        return None
+
+
+def execute(service, key):
+    command = service[key]
+    privileged = command.startswith("+")
+    argv = shlex.split(command[1:] if privileged else command)
+    if not argv or not argv[0].startswith("/"):
+        raise ValueError("unit executable must be absolute")
+    environment = {"PATH": "/usr/sbin:/usr/bin:/sbin:/bin", "LC_ALL": "C.UTF-8"}
+    for item in shlex.split(service.get("Environment", "")):
+        name, value = item.split("=", 1)
+        environment[name] = value
+    options = (
+        {}
+        if privileged
+        else {
+            "user": service["User"],
+            "group": service["Group"],
+            "extra_groups": [],
+        }
+    )
+    result = subprocess.run(
+        argv,
+        cwd="/" if privileged else service["WorkingDirectory"],
+        env=environment,
+        timeout=int(service["TimeoutStopSec" if key == "ExecStop" else "TimeoutStartSec"]),
+        check=False,
+        **options,
+    )
+    if result.returncode:
+        raise RuntimeError(key + " failed with status " + str(result.returncode))
+
+
+def main(argv=None):
+    arguments = list(sys.argv[1:] if argv is None else argv)
+    quiet = "--quiet" in arguments
+    arguments = [a for a in arguments if a != "--quiet"]
+    if arguments == ["--version"]:
+        print("pg_maker systemctl test harness v1; service_manager=emulated")
+        return 0
+    if arguments == ["daemon-reload"]:
+        return 0
+    if len(arguments) != 2:
+        raise ValueError("unsupported systemctl invocation")
+    command, name = arguments
+    if command not in {
+        "start",
+        "stop",
+        "restart",
+        "reload",
+        "status",
+        "is-active",
+        "enable",
+        "disable",
+    }:
+        raise ValueError("unsupported systemctl command")
+    service = load_unit(name)
+    if command in {"enable", "disable"}:
+        link = Path("/etc/systemd/system/multi-user.target.wants") / name
+        if command == "enable":
+            link.parent.mkdir(parents=True, exist_ok=True)
+            if link.is_symlink():
+                if os.readlink(link) != "/usr/lib/systemd/system/" + name:
+                    raise ValueError("conflicting service link")
+            else:
+                link.symlink_to("/usr/lib/systemd/system/" + name)
+        else:
+            link.unlink(missing_ok=True)
+        return 0
+    if command in {"status", "is-active"}:
+        active = pid(service) is not None
+        if not quiet:
+            print("active" if active else "inactive")
+        return 0 if active else 3
+    if command in {"stop", "restart"} and pid(service):
+        execute(service, "ExecStop")
+        deadline = time.monotonic() + int(service["TimeoutStopSec"])
+        while pid(service) and time.monotonic() < deadline:
+            time.sleep(0.05)
+        if pid(service):
+            raise RuntimeError("service did not stop")
+    if command in {"start", "restart"} and not pid(service):
+        execute(service, "ExecStartPre")
+        execute(service, "ExecStart")
+        if not pid(service):
+            raise RuntimeError("service command returned success without a running server")
+    if command == "reload":
+        if not pid(service):
+            raise RuntimeError("cannot reload an inactive service")
+        execute(service, "ExecReload")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except Exception as exc:
+        print("pg-maker systemctl: " + str(exc), file=sys.stderr)
+        raise SystemExit(1) from exc

pg_maker/yamlio.py

@@ -0,0 +1,54 @@
+"""JSON-compatible YAML with explicit duplicate-key, alias and tag rejection."""
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+from yaml.events import AliasEvent
+
+from pg_maker.documents import validate_document
+from pg_maker.errors import ValidationError
+from pg_maker.storage import canonical_json
+
+
+class StrictLoader(yaml.SafeLoader):
+    def compose_node(self, parent, index):
+        if self.check_event(AliasEvent):
+            raise ValidationError("YAML aliases are not supported")
+        return super().compose_node(parent, index)
+
+    def construct_mapping(self, node, deep=False):
+        result = {}
+        for key_node, value_node in node.value:
+            key = self.construct_object(key_node, deep=deep)
+            if not isinstance(key, str):
+                raise ValidationError("YAML mapping keys must be strings")
+            if key in result:
+                raise ValidationError(
+                    "duplicate YAML key", details={"key": key, "line": key_node.start_mark.line + 1}
+                )
+            result[key] = self.construct_object(value_node, deep=deep)
+        return result
+
+
+def load_yaml(path: Path, schema_name: str | None = None) -> dict[str, Any]:
+    try:
+        value = yaml.load(path.read_text(encoding="utf-8"), Loader=StrictLoader)
+    except OSError as exc:
+        raise ValidationError("cannot read YAML document", details={"path": str(path)}) from exc
+    except yaml.YAMLError as exc:
+        # PyYAML's exception text can echo secrets from the offending source line.
+        mark = getattr(exc, "problem_mark", None)
+        raise ValidationError(
+            "invalid or unsupported YAML",
+            details={
+                "path": str(path),
+                "line": mark.line + 1 if mark else None,
+            },
+        ) from exc
+    if not isinstance(value, dict):
+        raise ValidationError("YAML document must be a mapping")
+    canonical_json(value)
+    if schema_name:
+        validate_document(value, schema_name)
+    return value

pg_maker-0.1.0.data/data/share/doc/pg-maker/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## 0.1.0 — 2026-10-18
+
+Initial alpha of the PostgreSQL distribution controller:
+
+- Strict YAML configuration, pinned sources/environments, immutable locks and plans.
+- Isolated Docker builds, durable operations, events, cancellation, recovery and caches.
+- PostgreSQL 14–19 catalog; initial Debian 13 / x86_64 / DEB platform.
+- Default pg_stat_statements, pg_stat_kcache and pg_wait_sampling recipes with manuals.
+- Documentation-only and combined builds using DocBook/Sphinx, local assets, HTML/man/PDF
+  and explicit translation bundles.
+- Server/client/libpq/docs packaging, manifests, offline installation checks and exports.
+- Owned Git development sessions, patch import/refresh/pop/push/rebase, conflict recovery,
+  selected component rebuilds, debug commands and iteration retention.
+- Optional pg_play CLI/API/MCP integration and runtime image handoff.
+- English project documentation, distribution-content checks and a tag-triggered PyPI
+  Trusted Publishing workflow.
+
+Database suites are opt-in; quick/development builds remain unverified. RPM, additional
+platforms and PostgreSQL distribution repository publication remain future work.
+See the [roadmap](docs/roadmap.md) and dated validation reports for precise boundaries.

pg_maker-0.1.0.data/data/share/doc/pg-maker/CONTRIBUTING.md

@@ -0,0 +1,63 @@
+# Contributing
+
+Use Linux and Python 3.10 or newer. Install the checkout in a virtual environment:
+
+```bash
+python3 -m venv .venv
+.venv/bin/python -m pip install -e '.[dev]'
+.venv/bin/ruff check .
+.venv/bin/ruff format --check .
+.venv/bin/python tools/generate_planning_schemas.py
+.venv/bin/python tools/check_release.py
+.venv/bin/pytest -q tests/unit tests/contracts
+```
+
+Review generated schema changes with the matching interface contract. Keep every
+project Markdown file in English, including examples and fixture descriptions.
+PostgreSQL manuals produced by the utility can use configured languages. Preserve
+upstream copyright/license notices in fixtures and generated artifacts.
+
+Public changes need an updated MD contract and, where applicable, JSON Schema.
+Use MakerService for CLI/API behavior, typed argv for commands, the shared logger,
+durable state/events and owned-resource cleanup. Prefer small concrete adapters;
+add protocols only at real replacement boundaries. See [architecture](docs/architecture.md)
+and [interfaces](docs/interfaces/README.md).
+
+## Tests and storage
+
+Unit/contract tests do not require PostgreSQL builds. Small Docker tests are opt-in;
+variables select already available images. A tiny development pipeline fixture needs
+an image with Make and the current non-root build user:
+
+```bash
+PG_MAKER_DEVELOPMENT_IMAGE=sha256:FULL_IMAGE_ID .venv/bin/pytest -q tests/integration/test_development_pipeline.py
+```
+
+This checks failed extension builds, Git fixes, core/component reuse, debug execution
+and retention without starting a database. Other fixtures use PG_MAKER_DOCKER_IMAGE,
+PG_MAKER_BUILD_IMAGE, PG_MAKER_PREPARATION_IMAGE, PG_MAKER_PACKAGE_ENVIRONMENTS and
+PG_MAKER_DOC_ENVIRONMENTS. CI prepares its own fixture environments through
+`tools/ci_pipeline.py --fixtures-only`.
+
+Database suites remain off by default. The expensive PG_MAKER_BUILD_LOCK integration
+and manual --run-db-tests path are separate checks, not routine prerequisites for
+editing the Python utility. Never treat a successful quick build as database qualification.
+Check free disk before work; use [explicit cleanup](docs/development-storage.md) and
+retain useful evidence. Do not put runs, inputs, environments, credentials or build
+artifacts into Git.
+
+## Distribution checks
+
+```bash
+.venv/bin/python -m build
+.venv/bin/python -m twine check --strict dist/*
+.venv/bin/python tools/check_release.py --dist dist
+.venv/bin/python tools/smoke_wheel.py dist/*.whl
+```
+
+Use a distribution directory containing exactly one version. Release checks compare
+all Markdown and runtime package files byte-for-byte between source, wheel and sdist,
+and ensure test fixtures/tooling are present in sdist. Wheel smoke creates and removes
+a temporary isolated environment, installs dependencies, checks entry points and
+initializes/validates a project outside checkout. It does not contact Docker.
+Publication is described in [releasing](docs/releasing.md).

pg_maker-0.1.0.data/data/share/doc/pg-maker/LICENSE

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