pymap-cli 0.3.0__py3-none-any.whl

pymap/templates/index.html

@@ -0,0 +1,42 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Map of __PYMAP_NAME__</title>
+<style>
+  :root {
+    --ink:#12171c; --paper:#f7f6f3; --rule:#c9c4ba;
+    --accent:#1a5e63; --alert:#9c3b28; --muted:#6a6459;
+  }
+  * { box-sizing:border-box }
+  body {
+    margin:0; background:var(--paper); color:var(--ink);
+    font:15px/1.6 "SF Mono",ui-monospace,"JetBrains Mono",Menlo,monospace;
+  }
+  header { padding:44px 32px 28px; border-bottom:2px solid var(--ink) }
+  h1 { margin:0; font-size:30px; font-weight:600; letter-spacing:-.02em }
+  .sub { color:var(--muted); margin-top:6px }
+  main { padding:0 32px 64px }
+  section { border-bottom:1px solid var(--rule); padding:28px 0 }
+  h2 { font-size:17px; margin:0 0 4px; font-weight:600 }
+  .what { color:var(--muted); margin:0 0 14px; max-width:62ch }
+  .stats { display:flex; gap:26px; margin:14px 0 18px; flex-wrap:wrap }
+  .stat b { display:block; font-size:26px; font-weight:600; color:var(--accent) }
+  .stat span { color:var(--muted); font-size:13px }
+  a.view {
+    display:inline-block; padding:9px 15px; border:1.5px solid var(--ink);
+    color:var(--ink); text-decoration:none; margin:0 8px 8px 0;
+  }
+  a.view:hover { background:var(--ink); color:var(--paper) }
+  a.view:focus-visible { outline:3px solid var(--accent); outline-offset:2px }
+  .absent { color:var(--muted); font-style:italic }
+  .cycles { border-left:4px solid var(--alert); padding:12px 16px; background:#fff }
+  .cycles b { color:var(--alert) }
+  code { background:#ebe8e2; padding:1px 5px }
+  ul { margin:8px 0; padding-left:20px }
+</style>
+<header>
+  <h1>__PYMAP_NAME__</h1>
+  <div class="sub">__PYMAP_FILES__ Python files · __PYMAP_LINES__ lines · analysed locally, nothing is sent anywhere</div>
+</header>
+<main>
+__PYMAP_BODY__
+</main>

pymap/templates/section.html

@@ -0,0 +1,7 @@
+<section>
+  <h2>__PYMAP_TITLE__</h2>
+  <p class="what">__PYMAP_WHAT__</p>
+  __PYMAP_STATS__
+  __PYMAP_DETAIL__
+  __PYMAP_LINKS__
+</section>

pymap/tools/__init__.py

@@ -0,0 +1,22 @@
+"""Wrappers around external tools: one module per tool.
+
+Each module exposes ``execute(settings)`` and returns raw facts, never HTML --
+layout belongs to :mod:`pymap.render`. A missing tool returns an empty result
+carrying an explanatory ``log``; it never aborts the run.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+def count_svg(path: str | Path) -> tuple[int, int]:
+    """(nodes, edges) of an SVG produced by Graphviz."""
+    try:
+        text = Path(path).read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return 0, 0
+    titles = re.findall(r"<title>([^<]+)</title>", text)
+    edges = [t for t in titles if "&#45;&gt;" in t or "->" in t]
+    return len(titles) - len(edges), len(edges)

pymap/tools/code2flow.py

@@ -0,0 +1,56 @@
+"""code2flow -- call graph between functions.
+
+Only the JSON is produced: pymap's own explorer supersedes code2flow's SVG, but
+it feeds on this graph.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from pymap import runner
+from pymap.settings import Settings
+
+ROLE = "call graph"
+
+#: Past this point the file list would exceed the maximum command-line length,
+#: so we fall back to the directory (and therefore to code2flow's own walk).
+MAX_ARGUMENTS = 3000
+
+#: code2flow is slow on large codebases; it needs more than the shared timeout.
+MIN_TIMEOUT = 420
+
+
+def execute(settings: Settings) -> dict[str, Any]:
+    """Write ``calls.json``. Returns ``{json, functions, calls, log}``."""
+    empty: dict[str, Any] = {"json": None, "functions": 0, "calls": 0}
+    base = runner.resolve("code2flow")
+    if not base:
+        return dict(empty, log="code2flow is not installed")
+
+    files = settings.files()
+    if not files:
+        return dict(empty, log="no Python file to analyse")
+    # Pass the filtered list rather than the directory: code2flow does not know
+    # about our exclusions and would walk into .venv/ if pointed at the root.
+    sources = (
+        [str(path) for path in files] if len(files) <= MAX_ARGUMENTS else [str(settings.target)]
+    )
+
+    output = settings.output / "calls.json"
+    ok, log = runner.run(
+        base + sources + ["-o", str(output)], timeout=max(settings.timeout, MIN_TIMEOUT)
+    )
+    if not (ok and output.exists()):
+        return dict(empty, log=log or "code2flow failed")
+    try:
+        graph = json.loads(output.read_text(encoding="utf-8"))["graph"]
+    except (OSError, ValueError, KeyError):
+        return dict(empty, json=output, log="unreadable code2flow JSON")
+    return {
+        "json": output,
+        "functions": len(graph["nodes"]),
+        "calls": len(graph["edges"]),
+        "log": "",
+    }

pymap/tools/pydeps.py

@@ -0,0 +1,42 @@
+"""pydeps -- who imports whom, at module level."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pymap import runner
+from pymap.settings import Settings
+from pymap.tools import count_svg
+
+ROLE = "import graph"
+
+
+def execute(settings: Settings) -> dict[str, Any]:
+    """Write ``imports.svg``. Returns ``{svg, modules, imports, log}``."""
+    empty: dict[str, Any] = {"svg": None, "modules": 0, "imports": 0}
+    base = runner.resolve("pydeps")
+    if not base:
+        return dict(empty, log="pydeps is not installed")
+    if not runner.resolve("dot"):
+        return dict(empty, log="graphviz (dot) missing: pydeps cannot render the SVG")
+
+    svg = settings.output / "imports.svg"
+    ok, log = runner.run(
+        [
+            *base,
+            str(settings.target),
+            "--noshow",
+            "--cluster",
+            "--max-bacon",
+            "2",
+            "-T",
+            "svg",
+            "-o",
+            str(svg),
+        ],
+        timeout=settings.timeout,
+    )
+    if not (ok and svg.exists()):
+        return dict(empty, log=log or "pydeps failed")
+    nodes, edges = count_svg(svg)
+    return {"svg": svg, "modules": nodes, "imports": edges, "log": ""}

pymap/tools/pyreverse.py

@@ -0,0 +1,41 @@
+"""pyreverse (from pylint) -- class and package diagrams."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from pymap import runner
+from pymap.settings import Settings
+
+ROLE = "class diagrams"
+
+
+def execute(settings: Settings) -> dict[str, Any]:
+    """Write ``classes_<name>.svg`` and ``packages_<name>.svg``.
+
+    Returns ``{classes, packages, log}``.
+    """
+    empty: dict[str, Any] = {"classes": None, "packages": None}
+    base = runner.resolve("pyreverse")
+    if not base:
+        return dict(empty, log="pyreverse is not installed (ships with pylint)")
+    if not runner.resolve("dot"):
+        return dict(empty, log="graphviz (dot) missing: pyreverse cannot render the SVG")
+
+    project = re.sub(r"[^A-Za-z0-9_.-]", "_", settings.name) or "project"
+    ok, log = runner.run(
+        [*base, "-o", "svg", "-p", project, "-d", str(settings.output), str(settings.target)],
+        cwd=str(settings.target.parent),
+        timeout=settings.timeout,
+    )
+
+    classes = settings.output / f"classes_{project}.svg"
+    packages = settings.output / f"packages_{project}.svg"
+    if not ok and not classes.exists():
+        return dict(empty, log=log or "pyreverse failed")
+    return {
+        "classes": classes if classes.exists() else None,
+        "packages": packages if packages.exists() else None,
+        "log": "",
+    }

pymap/tools/tach.py

@@ -0,0 +1,104 @@
+"""tach -- module boundaries and file-by-file dependencies.
+
+tach requires a ``tach.toml`` at the root of wherever it runs. Rather than drop
+that file into the analysed project -- and risk clobbering the user's own --
+pymap copies the ``.py`` sources into a temporary directory and works there.
+The target project is never modified.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import tempfile
+from collections.abc import Iterable, Sequence
+from pathlib import Path
+from typing import Any
+
+from pymap import runner
+from pymap.settings import Settings, is_excluded
+
+ROLE = "module boundaries"
+
+#: Past this point ``tach sync`` gets very slow, for a graph already unreadable.
+MAX_MODULES = 60
+
+
+def _copy_sources(target: Path, into: Path, excluded: Sequence[str]) -> None:
+    """Copy the tree keeping only ``.py`` files, excluded branches pruned."""
+
+    def ignore(directory: str, names: list[str]) -> set[str]:
+        rejected = set()
+        for name in names:
+            if (Path(directory) / name).is_dir():
+                if is_excluded(name, excluded):
+                    rejected.add(name)
+            elif not name.endswith(".py"):
+                rejected.add(name)
+        return rejected
+
+    shutil.copytree(target, into, ignore=ignore, symlinks=True)
+
+
+def _module_paths(target: Path, files: Iterable[Path]) -> list[str]:
+    """Dotted module paths, relative to the source root."""
+    names = set()
+    for path in files:
+        if path.name == "__init__.py":
+            continue
+        relative = path.relative_to(target).with_suffix("").as_posix().replace("/", ".")
+        names.add(f"{target.name}.{relative}")
+    return sorted(names)
+
+
+def execute(settings: Settings) -> dict[str, Any]:
+    """Write ``tach.mmd``. Returns ``{mermaid, deps, modules, truncated, log}``."""
+    empty: dict[str, Any] = {"mermaid": None, "deps": {}, "modules": 0, "truncated": 0}
+    base = runner.resolve("tach")
+    if not base:
+        return dict(empty, log="tach is not installed")
+
+    every = _module_paths(settings.target, settings.files())
+    if not every:
+        return dict(empty, log="no module to declare")
+    kept = every[:MAX_MODULES]
+
+    with tempfile.TemporaryDirectory(prefix="pymap-tach-") as tmp:
+        workspace = Path(tmp)
+        try:
+            _copy_sources(settings.target, workspace / settings.target.name, settings.excluded)
+        except OSError as exc:
+            return dict(empty, log=f"could not copy sources: {exc}")
+
+        lines = ['source_roots = ["."]\n']
+        lines += [f'[[modules]]\npath = "{m}"\ndepends_on = []\n\n' for m in kept]
+        (workspace / "tach.toml").write_text("".join(lines), encoding="utf-8")
+
+        ok, log = runner.run([*base, "sync"], cwd=str(workspace), timeout=settings.timeout)
+        if not ok:
+            return dict(empty, log=log or "tach sync failed")
+
+        mermaid = settings.output / "tach.mmd"
+        drawn, _ = runner.run(
+            [*base, "show", "--mermaid", "-o", str(mermaid)],
+            cwd=str(workspace),
+            timeout=settings.timeout,
+        )
+
+        deps: dict[str, list[str]] = {}
+        mapped, raw = runner.run(
+            [*base, "map", "-o", "-"], cwd=str(workspace), timeout=settings.timeout, full=True
+        )
+        if mapped:
+            try:
+                deps = json.loads(raw[raw.index("{") : raw.rindex("}") + 1])
+            except (ValueError, json.JSONDecodeError):
+                deps = {}
+
+    return {
+        "mermaid": mermaid if (drawn and mermaid.exists()) else None,
+        "deps": deps,
+        "modules": len(kept),
+        "truncated": len(every) - len(kept),
+        "log": "",
+    }

pymap_cli-0.3.0.dist-info/METADATA

@@ -0,0 +1,197 @@
+Metadata-Version: 2.5
+Name: pymap-cli
+Version: 0.3.0
+Summary: Map a Python codebase in one command.
+Project-URL: Homepage, https://github.com/hermann225-zrouama/pymap-cli
+Project-URL: Issues, https://github.com/hermann225-zrouama/pymap-cli/issues
+Project-URL: Changelog, https://github.com/hermann225-zrouama/pymap-cli/blob/main/CHANGELOG.md
+Author: Franck Zrouama
+License-Expression: MIT
+License-File: LICENSE
+Keywords: architecture,ast,call graph,codebase map,documentation
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+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 :: Documentation
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: code2flow>=2.5; extra == 'dev'
+Requires-Dist: pydeps>=1.11; extra == 'dev'
+Requires-Dist: pylint>=2.15; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: tach>=0.9; extra == 'dev'
+Requires-Dist: tomli>=2.0; (python_version < '3.11') and extra == 'dev'
+Provides-Extra: graphs
+Requires-Dist: code2flow>=2.5; extra == 'graphs'
+Requires-Dist: pydeps>=1.11; extra == 'graphs'
+Requires-Dist: pylint>=2.15; extra == 'graphs'
+Requires-Dist: tach>=0.9; extra == 'graphs'
+Provides-Extra: toml
+Requires-Dist: tomli>=2.0; (python_version < '3.11') and extra == 'toml'
+Description-Content-Type: text/markdown
+
+# pymap
+
+Map a Python codebase in one command. No service, no upload: everything is
+analysed and rendered locally.
+
+```bash
+cd my-project
+pymap --open
+```
+
+pymap guesses which package to analyse, runs whichever graph tools you have
+installed, and assembles the result into a single page — plus a **flow
+explorer** that pymap builds itself: for every function, the order of the calls,
+the conditions, the loops, the error paths, and the data flowing through.
+
+## Install
+
+```bash
+pipx install pymap-cli          # isolated, available everywhere
+# or, inside the project you want to map:
+pip install pymap-cli
+```
+
+The core depends only on the standard library, so installing pymap into a
+project adds **no version constraint** to it. The graph tools are optional and
+live behind an extra:
+
+```bash
+pip install "pymap-cli[graphs]"     # pydeps, code2flow, pylint, tach
+brew install graphviz               # or: apt install graphviz
+```
+
+Any missing tool is reported at start-up and then skipped; the explorer always
+works.
+
+## Usage
+
+```bash
+pymap                              # guess the current project's package
+pymap src/mypkg                    # explicit target
+pymap src/mypkg -o map/ --open     # output directory, open when done
+pymap --exclude "generated_*"      # skip more paths
+pymap --editor pycharm             # code links for another editor
+```
+
+How the target is guessed, in order: `[tool.pymap] target` in `pyproject.toml`,
+a `src/<package>/` layout, the package named after the project, then the single
+top-level package. If nothing stands out, pymap says so and waits for a path.
+
+### Configuration
+
+Optional, in the project's `pyproject.toml` (read on Python ≥ 3.11, or with
+`tomli` installed):
+
+```toml
+[tool.pymap]
+target  = "src/mypkg"
+output  = "pymap-out"
+editor  = "vscode"          # vscodium, cursor, windsurf, zed, pycharm,
+                            # idea, sublime, none, or "myeditor://{f}:{l}"
+exclude = ["vendor", "generated_*"]
+timeout = 300               # seconds per external tool
+```
+
+### As a library
+
+```python
+from pymap import Settings, map_codebase
+
+report = map_codebase(Settings(target="src/mypkg", output="map/"))
+print(report.coverage, "% documented,", len(report.cycles), "cycles")
+```
+
+## What the map contains
+
+| View | Source | What you read there |
+|---|---|---|
+| **Walkthrough tree** | pymap (AST) | The execution flow function by function, keyboard-navigable |
+| Imports between modules | pydeps | The layers, and the modules everyone pulls in |
+| Classes and inheritance | pyreverse | Attributes and hierarchies, when the code is object-oriented |
+| Module boundaries | tach | File-by-file dependencies, cycles, Mermaid source |
+
+The output directory (`pymap-out/` by default) holds `index.html` — the page to
+open — and the views it links to.
+
+### In the explorer
+
+<kbd>↓</kbd> <kbd>↑</kbd> walk the steps · <kbd>↵</kbd> step into the
+highlighted call · <kbd>←</kbd> go back up · <kbd>m</kbd> mark seen ·
+<kbd>o</kbd> open in the editor · <kbd>/</kbd> search
+
+## How the code is organised
+
+```
+src/pymap/
+├── cli.py           command line: arguments, pyproject, messages
+├── settings.py      what to analyse, where to write, what to skip
+├── mapper.py        orchestration + library API
+├── runner.py        launching external tools, detecting missing ones
+├── render.py        templates → HTML pages
+├── analysis/        what pymap works out on its own, from the AST
+│   ├── symbols.py     modules, classes, functions, signatures
+│   ├── flow.py        execution tree of a function
+│   ├── calls.py       code2flow's call graph
+│   └── cycles.py      circular dependencies
+├── tools/           one module per external tool
+│   ├── pydeps.py    pyreverse.py    code2flow.py    tach.py
+└── templates/       index.html, section.html, explorer.html
+```
+
+Adding a tool: drop a module in `tools/` exposing `execute(settings)` that
+returns raw facts (never HTML), then add one line to `STEPS` and one section to
+`_sections()`, both in `mapper.py`. See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Guarantees
+
+- **Nothing is executed** from the analysed code: everything goes through the
+  standard library's AST.
+- **Nothing is written** into the target project. `tach` requires a `tach.toml`
+  at the root of wherever it runs, so pymap copies the sources into a temporary
+  directory instead of dropping that file in your tree.
+- Environments and caches (`.venv/`, `node_modules/`, `build/`,
+  `__pycache__/`, …) are pruned during the walk, never traversed.
+
+## Known limitations
+
+- **Files sharing a basename share a namespace.** Symbol keys are
+  `<file stem>::<qualified name>`, because that is how code2flow names its
+  graph nodes and it is what lets the two data sets be joined. In a project
+  with `app/models.py` and `blog/models.py`, their symbols merge in the
+  explorer. pymap prints a note when it detects the case.
+- **tach declares at most 60 modules.** Beyond that `tach sync` gets very slow
+  for a graph that is already unreadable. The count left out is reported.
+- The call graph is only as good as code2flow's static resolution: calls
+  through dynamic dispatch or `getattr` do not appear.
+
+## Development
+
+```bash
+git clone https://github.com/hermann225-zrouama/pymap-cli
+cd pymap-cli
+pip install -e ".[dev]"
+pytest
+ruff check src tests && ruff format --check src tests
+pymap                  # pymap maps itself
+```
+
+`tests/test_contract.py` pins the key names shared between the Python payload
+and `templates/explorer.html`. A rename on one side without the other produces
+a blank page rather than an error, so that test is what keeps them honest.
+
+## Licence
+
+MIT — see [LICENSE](LICENSE).
+
+The distribution is named `pymap-cli` because `pymap` is already taken on PyPI
+by an IMAP library. The command and the import name are both `pymap`.

pymap_cli-0.3.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+pymap/__init__.py,sha256=C1jcrwBVVCpCK6fNFLdbZohI0L99BMVgA5JWDN_w6YQ,1223
+pymap/__main__.py,sha256=LnOY_l14VeZ9NVefVstic4CxBNVaq9H4dUdgz4S3bHk,169
+pymap/cli.py,sha256=O8rGgY8MC_8jYFeuSl4n6qAP7uJjAcnsR-GG2y7k7l0,4718
+pymap/mapper.py,sha256=bFcdsImrGbxSNPzb5vjVVBnngbjgcATMGLsvpcIuDqc,7229
+pymap/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymap/render.py,sha256=ctnR5yEtiHkc-Aj0L1MNlf_rM4HIEWZg7q9k5sez9gY,5249
+pymap/runner.py,sha256=TB-8WDQuw6Q2IFqxUhxG0etkswWCOtmxnO-X_Kb3HbA,3302
+pymap/settings.py,sha256=P_cML1kHCBgaGRMaaB89CHUfaC5tdzlo9aya7tUV8uQ,6025
+pymap/analysis/__init__.py,sha256=sQkLkcimHcjMabQoBq74N2p7jl4suuVRUbmMMk-4Egk,80
+pymap/analysis/calls.py,sha256=K_vC7v4e0Cgb_1Xo1kDmlgxpk9omBsJFbk9wfeKHinU,1319
+pymap/analysis/cycles.py,sha256=YuKIYs2LHRnkEt46AnzlzDq3NApf8FONT76LcVyggtE,1342
+pymap/analysis/flow.py,sha256=o__gpjM7qmipfeMa7q5a0eYWiwYKR-dOiEIgA1pqRR0,6453
+pymap/analysis/symbols.py,sha256=wOqHGDHmGuXWy77KQWqDG74HJwgnt76uqUZY1rd3fM4,6884
+pymap/templates/__init__.py,sha256=u1GeOJbGJC3VdLp1WiZN-Xwu52tNK2RElXJ8e0j230A,437
+pymap/templates/explorer.html,sha256=XJLJh7bh-0ucu2ZlY55yDLaHkby7g0ReJJCkSdbRYjQ,37734
+pymap/templates/index.html,sha256=tdtChG7Oipp7S5KWjaebMcpftkNgloTp9rhIcYkgxZo,1760
+pymap/templates/section.html,sha256=bFB1E2mvl89XuzRPZO3K0oNEi8M_V4VPsre9XxEubkU,140
+pymap/tools/__init__.py,sha256=a7_ToNuCq6Rc08Vi1-v919XQPghdfbt1a8OHcJ-jjYc,749
+pymap/tools/code2flow.py,sha256=XxjZRCxaAK38FVKGM0DOTU1Dds4JTiw8G67nmtmWiGo,1889
+pymap/tools/pydeps.py,sha256=NLq1ogy0jkAyhY7hNDUwifkH5ck5i3Q31LfwMkgeQog,1207
+pymap/tools/pyreverse.py,sha256=aOoNnL7E3JC31UA6qbT1mnR4OaFObExHHljKbGjp3_0,1361
+pymap/tools/tach.py,sha256=JknllG_rWIGr-FjPNGDsG7gwmWGyvrdZgX2tVmsssxc,3669
+pymap_cli-0.3.0.dist-info/METADATA,sha256=sBo9Zim92TSOtpDzV3Vz7sGSG5Vs8vip2KAI6TxYF_E,7674
+pymap_cli-0.3.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+pymap_cli-0.3.0.dist-info/entry_points.txt,sha256=fIJReyb8moS3dUNAxWnMTQan-joX10DqqmZs2Esym3k,41
+pymap_cli-0.3.0.dist-info/licenses/LICENSE,sha256=7BJhC6lQ3aGXwDNyJcE9U2MhD9I0krkxJKrSZAX8RlI,1071
+pymap_cli-0.3.0.dist-info/RECORD,,

pymap_cli-0.3.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

pymap_cli-0.3.0.dist-info/entry_points.txt

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

pymap_cli-0.3.0.dist-info/licenses/LICENSE

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