deploy-guard-engine 0.1.0__py3-none-any.whl

deploy_guard/report/render.py

@@ -0,0 +1,262 @@
+"""Text, Markdown and JSON renderers for a scan result."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Iterable
+
+from deploy_guard.engine import ScanResult
+
+_SEV_LABEL = {"block": "BLOCK ", "review": "REVIEW", "warn": "WARN  "}
+_SEV_MARK = {"block": "●", "review": "◐", "warn": "○"}
+
+
+def _rel(result: ScanResult, path: str) -> str:
+    try:
+        return os.path.relpath(path, result.project.root)
+    except ValueError:
+        return path
+
+
+# --------------------------------------------------------------------------
+# Plain text (terminal)
+# --------------------------------------------------------------------------
+
+def render_text(
+    result: ScanResult, *, show_behavior: bool = False, show_notes: bool = False
+) -> str:
+    p = result.project
+    lines: list[str] = []
+    lines.append(f"Deployment Guard - scan of {p.root}")
+    langs = ", ".join(sorted(p.languages)) or "none detected"
+    builds = ", ".join(p.build_systems) or "unknown"
+    lines.append(f"  languages: {langs}    build: {builds}")
+    lines.append(
+        f"  modules: {len(p.modules)}    functions analysed: {len(result.functions)}"
+    )
+    for note in p.notes:
+        lines.append(f"  note: {note}")
+    lines.append("")
+
+    counts = result.counts_by_severity()
+    summary = (
+        f"Findings: {counts['block']} block   {counts['review']} review   "
+        f"{counts['warn']} warn"
+    )
+    if counts["note"]:
+        summary += f"   ({counts['note']} note)"
+    lines.append(summary)
+    if result.collapsed_count:
+        lines.append(
+            f"  ({result.collapsed_count} duplicate finding(s) from copy-pasted "
+            "functions folded in - see [same finding in N copies ...]; --no-collapse to expand)"
+        )
+    if result.disabled_rules:
+        lines.append(f"  [disabled rules: {', '.join(sorted(result.disabled_rules))}]")
+    lines.append("")
+
+    for f in result.findings:
+        loc = f"{_rel(result, f.file)}:{f.lineno}"
+        lines.append(f"  {_SEV_MARK[f.severity]} {_SEV_LABEL[f.severity]}  {f.rule}")
+        lines.append(f"      {loc}  in {f.qualname}")
+        lines.append(f"      {f.message}")
+        if f.detail:
+            lines.append(f"      {f.detail}")
+        lines.append("")
+
+    notes = result.notes
+    if notes:
+        by_rule: dict[str, int] = {}
+        for n in notes:
+            by_rule[n.rule] = by_rule.get(n.rule, 0) + 1
+        breakdown = ", ".join(f"{v}x {k}" for k, v in sorted(by_rule.items()))
+        if show_notes:
+            lines.append(f"Notes ({len(notes)}: {breakdown}):")
+            for n in notes:
+                lines.append(
+                    f"  · {_rel(result, n.file)}:{n.lineno}  {n.rule}  -  {n.message}"
+                )
+            lines.append("")
+        else:
+            lines.append(f"Notes: {len(notes)} ({breakdown}) - run with --notes to list")
+            lines.append("")
+
+    analysis_errors = [fr for fr in result.functions if fr.error]
+    if analysis_errors:
+        lines.append(f"Analysis errors ({len(analysis_errors)}):")
+        for fr in analysis_errors:
+            lines.append(f"  {fr.fn.qualname}: {fr.error}")
+        lines.append("")
+
+    if result.parse_errors:
+        lines.append(f"Unparseable modules ({len(result.parse_errors)}):")
+        for name, err in result.parse_errors:
+            lines.append(f"  {name}: {err}")
+        lines.append("")
+
+    if show_behavior:
+        lines.append("Behavior spec:")
+        lines.extend(_behavior_block(result, indent="  "))
+        lines.append("")
+
+    if result.generated:
+        lines.append("Generated tests (use --write-tests to save):")
+        for g in result.generated:
+            lines.append(f"  .deploy-guard/generated/{g.relpath}  [{g.kind}]")
+        lines.append("")
+
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _behavior_block(result: ScanResult, *, indent: str) -> list[str]:
+    out: list[str] = []
+    for fr in result.functions:
+        if fr.error or not fr.spec.entries:
+            continue
+        out.append(f"{indent}{fr.fn.qualname}")
+        for e in fr.spec.entries:
+            when = " and ".join(e.when) if e.when else "always"
+            if e.outcome == "returns":
+                what = f"returns {e.value}"
+            elif e.outcome == "raises":
+                what = f"raises {e.value}"
+            elif e.outcome == "implicit-none":
+                what = "returns None (falls off the end)"
+            elif e.outcome == "truncated":
+                what = "... (path bound hit)"
+            else:
+                what = e.outcome
+            out.append(f"{indent}  when {when}: {what}")
+    return out
+
+
+# --------------------------------------------------------------------------
+# Markdown
+# --------------------------------------------------------------------------
+
+def render_markdown(result: ScanResult) -> str:
+    p = result.project
+    counts = result.counts_by_severity()
+    md: list[str] = []
+    md.append("# Deployment Guard - scan report")
+    md.append("")
+    md.append(f"- **Root:** `{p.root}`")
+    md.append(f"- **Languages:** {', '.join(sorted(p.languages)) or 'none detected'}")
+    md.append(f"- **Build systems:** {', '.join(p.build_systems) or 'unknown'}")
+    md.append(f"- **Modules:** {len(p.modules)}  |  **Functions analysed:** {len(result.functions)}")
+    finding_line = (
+        f"- **Findings:** {counts['block']} block, {counts['review']} review, "
+        f"{counts['warn']} warn"
+    )
+    if counts["note"]:
+        finding_line += f" ({counts['note']} note)"
+    md.append(finding_line)
+    if result.disabled_rules:
+        md.append(f"- **Disabled rules:** {', '.join(sorted(result.disabled_rules))}")
+    md.append("")
+
+    if result.findings:
+        md.append("## Findings")
+        md.append("")
+        md.append("| Severity | Rule | Location | Function | Detail |")
+        md.append("|---|---|---|---|---|")
+        for f in result.findings:
+            loc = f"{_rel(result, f.file)}:{f.lineno}"
+            detail = f.message + (f" _{f.detail}_" if f.detail else "")
+            md.append(
+                f"| {f.severity} | `{f.rule}` | `{loc}` | `{f.qualname}` | {detail} |"
+            )
+        md.append("")
+
+    if result.notes:
+        md.append("## Notes (informational, not gate findings)")
+        md.append("")
+        for n in result.notes:
+            md.append(
+                f"- `{n.rule}` `{_rel(result, n.file)}:{n.lineno}` `{n.qualname}` - {n.message}"
+            )
+        md.append("")
+
+    if result.parse_errors:
+        md.append("## Unparseable modules")
+        md.append("")
+        for name, err in result.parse_errors:
+            md.append(f"- `{name}` - {err}")
+        md.append("")
+
+    md.append("## Behavior spec")
+    md.append("")
+    for line in _behavior_block(result, indent=""):
+        if not line.startswith("  "):
+            md.append(f"### `{line}`")
+        else:
+            md.append(f"- {line.strip()}")
+    md.append("")
+    return "\n".join(md).rstrip() + "\n"
+
+
+# --------------------------------------------------------------------------
+# JSON
+# --------------------------------------------------------------------------
+
+def render_json(result: ScanResult) -> str:
+    p = result.project
+    payload = {
+        "root": str(p.root),
+        "languages": sorted(p.languages),
+        "build_systems": p.build_systems,
+        "modules": len(p.modules),
+        "functions_analysed": len(result.functions),
+        "project_notes": p.notes,
+        "disabled_rules": sorted(result.disabled_rules),
+        "counts": result.counts_by_severity(),
+        "findings": [
+            {
+                "rule": f.rule,
+                "severity": f.severity,
+                "message": f.message,
+                "detail": f.detail,
+                "qualname": f.qualname,
+                "file": _rel(result, f.file),
+                "lineno": f.lineno,
+            }
+            for f in result.findings
+        ],
+        "notes": [
+            {
+                "rule": n.rule,
+                "message": n.message,
+                "qualname": n.qualname,
+                "file": _rel(result, n.file),
+                "lineno": n.lineno,
+            }
+            for n in result.notes
+        ],
+        "parse_errors": [
+            {"module": name, "error": err} for name, err in result.parse_errors
+        ],
+        "behavior": [
+            {
+                "qualname": fr.fn.qualname,
+                "truncated": fr.spec.truncated,
+                "paths": [
+                    {
+                        "when": e.when,
+                        "outcome": e.outcome,
+                        "value": e.value,
+                        "lineno": e.lineno,
+                    }
+                    for e in fr.spec.entries
+                ],
+            }
+            for fr in result.functions
+            if not fr.error
+        ],
+        "generated": [g.relpath for g in result.generated],
+    }
+    return json.dumps(payload, indent=2)
+
+
+def _iter_lines(chunks: Iterable[str]) -> str:  # pragma: no cover - helper
+    return "\n".join(chunks)

deploy_guard/store.py

@@ -0,0 +1,50 @@
+"""Management of the ``.deploy-guard/`` working directory.
+
+Holds generated tests and (from M3) contract baselines and golden files.
+Everything here is meant to be committed and reviewed in PRs like code.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from deploy_guard.generators.base import GeneratedFile
+
+STORE_DIRNAME = ".deploy-guard"
+GENERATED_SUBDIR = "generated"
+
+_GITIGNORE = """\
+# Deployment Guard Engine - transient analysis artifacts.
+# Generated tests and baselines ARE committed; caches are not.
+cache/
+*.log
+"""
+
+
+def store_dir(root: str | Path) -> Path:
+    return Path(root).resolve() / STORE_DIRNAME
+
+
+def generated_dir(root: str | Path) -> Path:
+    return store_dir(root) / GENERATED_SUBDIR
+
+
+def ensure_store(root: str | Path) -> Path:
+    d = store_dir(root)
+    (d / GENERATED_SUBDIR).mkdir(parents=True, exist_ok=True)
+    gi = d / ".gitignore"
+    if not gi.exists():
+        gi.write_text(_GITIGNORE, encoding="utf-8")
+    return d
+
+
+def write_generated(root: str | Path, files: list[GeneratedFile]) -> list[Path]:
+    ensure_store(root)
+    out_dir = generated_dir(root)
+    written: list[Path] = []
+    for f in files:
+        target = out_dir / f.relpath
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(f.content, encoding="utf-8")
+        written.append(target)
+    return written

deploy_guard_engine-0.1.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.5
+Name: deploy-guard-engine
+Version: 0.1.0
+Summary: Static root-cause analysis for a Python stack trace - offline, no account. Plus a deployment-gate scanner.
+Project-URL: Homepage, https://github.com/sai55387/deploy-guard
+Project-URL: Issues, https://github.com/sai55387/deploy-guard/issues
+Project-URL: Changelog, https://github.com/sai55387/deploy-guard/blob/main/CHANGELOG.md
+Author: sai55387
+License: MIT
+License-File: LICENSE
+Keywords: ci,control-flow,debugging,deployment,incident,nullability,root-cause,stacktrace,static-analysis,traceback
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# deploy-guard
+
+**Static root-cause analysis for a Python stack trace.** Paste a traceback,
+point it at the repo, and get: which variable is `None` and *why*, the branch
+path that reached the crash, where the bad value entered across the call
+chain, and a concrete fix. Fully local — no server, no account, no
+network. Zero dependencies. Python 3.10+.
+
+It also ships a deployment-gate scanner (`scan` / `check`), but for
+general-purpose linting you should run **[ruff](https://docs.astral.sh/ruff/)
++ [mypy](https://mypy-lang.org/)** — they are faster and deeper. What
+deploy-guard does that they don't is turn *a traceback you already have* into
+an explanation grounded in your code.
+
+## Install
+
+```bash
+pip install deploy-guard-engine   # or: pipx install deploy-guard-engine
+```
+
+Or run it with no install at all — a single ~120 KB file:
+
+```bash
+./scripts/build-standalone.sh     # -> dist/deploy-guard.pyz
+python deploy-guard.pyz explain --project ./service < traceback.txt
+```
+
+## Explain a traceback
+
+```bash
+deploy-guard explain --project ./service --file traceback.txt
+# or pipe it
+deploy-guard explain --project ./service < traceback.txt
+```
+
+```
+Explaining:  AttributeError: 'NoneType' object has no attribute 'empty'
+
+Crash site:  dg_financial_profile/financial_main.py:231  create_json
+             231 | if profile_df.empty or profile_df is None:
+
+Why:
+  - `profile_df` can be None here - the default passed to .get() is None.
+  - It reaches this line when: overall_financial_dict
+  - This line does check `profile_df is None`, but only after dereferencing it -
+    and/or evaluate left to right, so the attribute access raises first.
+
+Call chain (from the traceback):
+  multiprocessing_script:164  lambda_handler
+    └─ financial_main:231      create_json   <- raised
+
+Matches scan finding:  none-dereference (block) at financial_main.py:231
+
+Fix:  reorder the check so `profile_df is None` comes first.
+```
+
+Dedicated explanations for `AttributeError` / `TypeError` (None), `KeyError`,
+`IndexError`, `ZeroDivisionError`, `UnboundLocalError`, `NameError`, and
+`int()` / `float()` `ValueError`. Anything else falls back to the call chain
++ the branch conditions that reach the line. The call chain is analysed
+*interprocedurally* &mdash; each project frame is checked, and a `None` that
+originates in an argument is traced back to the caller that passed it.
+
+## Scan a project
+
+```bash
+deploy-guard scan  ./service                 # report, never fails
+deploy-guard scan  ./service --behavior      # + the when-X-returns-Y table
+deploy-guard check ./service --fail-on review  # gate: exit 1 on findings
+deploy-guard scan  ./service --report report.json
+```
+
+| Rule | Severity | Catches |
+|---|---|---|
+| `none-dereference` | block / review | attr/subscript on a possibly-`None` value (interprocedural: a call to a project function that can return `None` counts) |
+| `inconsistent-return` | review / note | returns a value on some paths, `None` on others &mdash; **review only when an in-project caller uses the result without a guard**, otherwise a note |
+| `swallowed-exception` | review | `except …: pass` |
+| `unreachable-code` | warn | code after an always-diverting branch |
+| `bare-except` | warn | `except:` with no type |
+| `mutable-default-arg` | warn | `def f(x=[])` |
+| `invalid-escape` | note | `"\d"` in a non-raw string |
+| `path-explosion` | note | too-branchy function (detection still complete) |
+
+Notes are collapsed to a one-line count; `--notes` lists them. Identical
+findings from copy-pasted functions fold into one; `--no-collapse` expands.
+
+## Configuration
+
+A `[tool.deploy-guard]` table in the **scanned project's** `pyproject.toml`
+(Python 3.11+ for TOML reading):
+
+```toml
+[tool.deploy-guard]
+disable = ["bare-except"]
+exclude = ["vendor", "migrations"]
+fail-on = "review"
+include-tests = false
+```
+
+CLI flags override the file.
+
+## How it works
+
+```
+discover -> lower to IR -> CFG per function -> call graph
+   -> behavior spec (path conditions -> returns/raises)
+   -> nullability data-flow (merges None facts at every branch join; interprocedural)
+   -> findings   |   explain (traceback -> the above, focused on one failure)
+```
+
+The nullability pass is a forward fixpoint over the CFG &mdash; it merges
+facts at branch joins, so it covers 100% of a function regardless of how
+branchy it is, in roughly linear time.
+
+`scan` and `explain` only **read** your code &mdash; never import or run it.
+
+## Develop
+
+```bash
+pip install -e ".[dev]"
+pytest
+ruff check src
+```
+
+## What changed from the prototype
+
+See [CHANGELOG.md](CHANGELOG.md). Headline: an interprocedural call graph, so
+`explain` traces a `None` across frames and `inconsistent-return` no longer
+fires on copy-pasted helpers whose callers all guard the result; plus real
+packaging and a config file.

deploy_guard_engine-0.1.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+deploy_guard/__init__.py,sha256=ZnpgqPXRdlEhr6-MW9oauCMFhnAi6LvV4L62zuPmmk4,299
+deploy_guard/__main__.py,sha256=EpBj9gNzkz57SL1By2r7bQyQrK8hJzTiXgIVdjS6umc,91
+deploy_guard/cli.py,sha256=Kdfc38f4m-OHyCbrIqbEjAUaswRHSxMrHcua2Oc4EnY,7288
+deploy_guard/config.py,sha256=i3cq_P8cWKyfHt_sLYlr4_ONAHMEjQwuirPsfCKwNH0,2221
+deploy_guard/engine.py,sha256=PCZFyGkhavDj9zjCiJ9i3BvIRD3oL1QyU6kX7z1vAnY,9567
+deploy_guard/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deploy_guard/store.py,sha256=Uay0bRYRAPKhOVEejap4o7PVx00JWXK5J7M7ZtOhKtk,1367
+deploy_guard/analysis/__init__.py,sha256=MBZ6qK7vPyivfM734ZuwhOenuUTmYl_KrMx99pt7rX0,1119
+deploy_guard/analysis/callgraph.py,sha256=xg7GUZQniEIJHZyRvMYKDG86ee94Tuj183Y3eth1I8A,5078
+deploy_guard/analysis/context.py,sha256=tmeV-yWWwlmQCdakpQ1VqenxN_0E-pklcLGLS5H-VjM,1182
+deploy_guard/analysis/findings.py,sha256=fd7euStrpLJO49YKMsclvtp0Ale61ws3B3dlh6RafZM,11650
+deploy_guard/analysis/nullability.py,sha256=vvYVp4fC3qAAY3sphmiGBm7pEryX1SslbRzs9S_a6UU,18082
+deploy_guard/analysis/paths.py,sha256=9zl3Pcr3dPiscBB3LqdzRqZ0ZZvZmYvKDKoXBlv3qzU,6939
+deploy_guard/explain/__init__.py,sha256=JRhvmlhCH8hzS3CNyMh1Oelcvt7YhG_VqVMO65SGtPQ,521
+deploy_guard/explain/explainer.py,sha256=txzs0o5F7hlqqKcjwNnkFjEJjRpY9xF73VxI9TlwYN4,17682
+deploy_guard/explain/render.py,sha256=lE5l3Y01IK3NTf8DFsEQDo1tXFuF9RDWfyyagJLZkNI,1766
+deploy_guard/explain/traceback_parse.py,sha256=2_JyusIvHyBgM8JHeryokKwjGvMyLOj4xuTKA26Ak6Q,2496
+deploy_guard/frontend/__init__.py,sha256=WfuzQpPNurN45Du2DXyPNHuM4dM8RSRc0jENUuZfQME,347
+deploy_guard/frontend/python_cfg.py,sha256=tYKOGJ5oaPs7Frn_OQHMWfBOXwJ-pEuUPJaX3hnzYDU,12677
+deploy_guard/frontend/python_frontend.py,sha256=4GLgzmI4Kc5fsHFSmSuqUHgaMYCIAi4xJ9_jPuNE_HI,5761
+deploy_guard/generators/__init__.py,sha256=Da-ussjB1y1nN5U-HL-UwJ1V-SYwJcsfgM8JmmdAQtI,457
+deploy_guard/generators/base.py,sha256=EKuB6MCEuzG8ri7EP_A2dxhSUN82LnYjkDxpqVwLP64,247
+deploy_guard/generators/import_smoke.py,sha256=fJ2qjl170tlPLTc7RAUfuFb_OWT7hr2hKvSeGeUK5Ns,3071
+deploy_guard/ingest/__init__.py,sha256=1HbCTyg5BaxrS4xLsCYgnSjC1OsZNYFIpgYYQBaA9k0,155
+deploy_guard/ingest/discover.py,sha256=c_BwT67wu99Wbqh79qsrcT9VAwmxP2aWGNWAWbmdRHQ,5249
+deploy_guard/ir/__init__.py,sha256=WrxIHAPxRwVvgWn5dCC3BIso7A1HEzT-L6hpMduFeYk,470
+deploy_guard/ir/cfg.py,sha256=UuMgKhY5aDRL89j0wsLpJ7jG--KeFKgsp5jpBMxoW3Y,3778
+deploy_guard/ir/model.py,sha256=Xa1r3QvMkMaoA0gJD28qvOUzo5lxf7YjDYXP9giWPXg,3980
+deploy_guard/report/__init__.py,sha256=8Qe7ha2-GYiBc3JFuB16kHrgy09pExi6FyytKLu5X0o,228
+deploy_guard/report/render.py,sha256=TVR537HN9VcWo800bbs9WJzVs7xvC6piUZbqZjZm85w,9121
+deploy_guard_engine-0.1.0.dist-info/METADATA,sha256=zrsNu6ZN3dGScYjkY36lPT5-WKFn-T3o30OhcoQdtPE,6323
+deploy_guard_engine-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+deploy_guard_engine-0.1.0.dist-info/entry_points.txt,sha256=bh2T76PdJzYqirWSMYzzSa4xbrV5AyySPxz3zsSUMf8,82
+deploy_guard_engine-0.1.0.dist-info/licenses/LICENSE,sha256=3lCxvJJXjv3cG2n8Zw0LyBS1L6cfYcCgnh7MeZQBYsw,1065
+deploy_guard_engine-0.1.0.dist-info/RECORD,,

deploy_guard_engine-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

deploy_guard_engine-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+deploy-guard = deploy_guard.cli:main
+dg = deploy_guard.cli:main

deploy_guard_engine-0.1.0.dist-info/licenses/LICENSE

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