tlaplus-cli 0.1.7__py3-none-any.whl

tla/build_tlc_module.py

@@ -0,0 +1,70 @@
+"""Compile custom TLC modules (Java)."""
+
+import subprocess
+
+import typer
+
+from tla.config import cache_dir, load_config, workspace_root
+
+
+def build(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show compilation output."),
+) -> None:
+    """Compile custom Java modules."""
+    config = load_config()
+
+    # Jar lives in the cache directory
+    jar_path = cache_dir() / config.tla.jar_name
+
+    ws_root = workspace_root()
+    modules_dir = ws_root / config.workspace.modules_dir
+    classes_dir = ws_root / config.workspace.classes_dir
+
+    if not jar_path.exists():
+        typer.echo(f"Error: {config.tla.jar_name} not found at {jar_path}", err=True)
+        typer.echo("Run 'tla download tla' first.", err=True)
+        raise typer.Exit(1)
+
+    if not modules_dir.exists():
+        typer.echo(f"Error: modules directory not found: {modules_dir}", err=True)
+        raise typer.Exit(1)
+
+    # Find all .java files in modules dir
+    java_files = list(modules_dir.rglob("*.java"))
+    if not java_files:
+        typer.echo(f"No Java source files found in {modules_dir}", err=True)
+        return
+
+    typer.echo(f"Compiling {len(java_files)} Java files from {modules_dir} ...")
+
+    # Ensure output dir exists
+    classes_dir.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["javac", "-cp", str(jar_path), "-d", str(classes_dir), *[str(f) for f in java_files]]
+
+    try:
+        result = subprocess.run(cmd, check=True, capture_output=not verbose, text=True)
+        typer.echo(f"Successfully compiled to {classes_dir}")
+        if verbose and result.stdout:
+            typer.echo(result.stdout)
+
+        # Create META-INF/services/tlc2.overrides.ITLCOverrides
+        meta_inf = classes_dir / "META-INF" / "services"
+        meta_inf.mkdir(parents=True, exist_ok=True)
+        service_file = meta_inf / "tlc2.overrides.ITLCOverrides"
+
+        with service_file.open("w") as f:
+            f.write(f"{config.tlc.overrides_class}\n")
+
+        typer.echo(f"Created service file at {service_file}")
+
+    except subprocess.CalledProcessError as e:
+        typer.echo("Compilation failed!", err=True)
+        if e.stdout:
+            typer.echo(e.stdout, err=True)
+        if e.stderr:
+            typer.echo(e.stderr, err=True)
+        raise typer.Exit(1) from None
+    except FileNotFoundError:
+        typer.echo("Error: 'javac' not found. Ensure JDK is installed and in PATH.", err=True)
+        raise typer.Exit(1) from None

tla/check_java.py

@@ -0,0 +1,82 @@
+"""Check minimal Java version."""
+
+import re
+import shutil
+import subprocess
+
+import typer
+
+
+def get_java_version() -> str | None:
+    """Get the installed Java version string using 'java -version'."""
+    java_executable = shutil.which("java")
+    if not java_executable:
+        return None
+
+    try:
+        # java -version prints to stderr
+        result = subprocess.run(
+            [java_executable, "-version"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        # Combine stdout and stderr just in case
+        output = result.stderr + result.stdout
+
+        # Look for version string like "1.8.0_202" or "11.0.2" or "17"
+        # Output typically starts with: openjdk version "11.0.2" ...
+        match = re.search(r'version "(\d+(\.\d+)*(_\d+)?(-\w+)?)"', output)
+        if match:
+            return match.group(1)
+
+        # Fallback for some distributions that might minimal output
+        match = re.search(r"version (\d+(\.\d+)*)", output)
+        if match:
+            return match.group(1)
+
+    except (subprocess.SubprocessError, OSError):
+        pass
+
+    return None
+
+
+def parse_java_version(version_str: str) -> int:
+    """Parse major Java version from string.
+
+    Examples:
+    - "1.8.0_202" -> 8
+    - "11.0.2" -> 11
+    - "17" -> 17
+    """
+    parts = version_str.split(".")
+    if parts[0] == "1":
+        # legacy format 1.x
+        if len(parts) > 1:
+            return int(parts[1])
+        return 1  # Fallback, though unlikely
+    return int(parts[0])
+
+
+def check_java_version(min_version: int) -> None:
+    """Check if installed Java version is at least min_version.
+
+    Exits with error if check fails.
+    """
+    version_str = get_java_version()
+
+    if not version_str:
+        typer.echo("Error: Java is not installed or not found in PATH.", err=True)
+        typer.echo(f"Please install Java {min_version} or higher.", err=True)
+        raise typer.Exit(1)
+
+    try:
+        major_version = parse_java_version(version_str)
+    except (ValueError, IndexError):
+        typer.echo(f"Warning: Could not parse Java version from '{version_str}'. Assuming compatible.", err=True)
+        return
+
+    if major_version < min_version:
+        typer.echo(f"Error: Java version {min_version} or higher is required.", err=True)
+        typer.echo(f"Found version {version_str} (major version {major_version}).", err=True)
+        raise typer.Exit(1)

tla/cli.py

@@ -0,0 +1,70 @@
+"""TLA+ CLI tool - entry point."""
+
+import importlib.metadata
+
+import typer
+
+from tla.build_tlc_module import build as build_tlc_cmd
+from tla.check_java import check_java_version, get_java_version
+from tla.config import load_config
+from tla.download_tla2tools import tla as download_tla_cmd
+from tla.run_tlc import tlc as run_tlc_cmd
+
+app = typer.Typer(
+    name="tla",
+    help="TLA+ tools: download TLC, compile custom modules, run model checker.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        meta = importlib.metadata.metadata("tlaplus-cli")
+        typer.echo(f"{meta['Name']} v{meta['Version']}")
+        typer.echo(meta["Summary"])
+        raise typer.Exit()
+
+
+@app.callback()
+def root(
+    version: bool = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Show the application's version and exit.",
+        callback=version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """TLA+ CLI tool."""
+    # Load config early to trigger first-run copy
+    load_config()
+    if version:
+        # This branch is effectively redundant due to callback, but keeps type checker happy
+        pass
+
+
+# --- Subcommands ---
+
+# Register 'download' directly as a command, effectively 'tla download'
+app.command(name="download")(download_tla_cmd)
+
+app.command(name="tlc")(run_tlc_cmd)
+app.command(name="build")(build_tlc_cmd)
+
+
+@app.command(name="check-java")
+def check_java() -> None:
+    """Check if Java is installed and meets the minimum version requirement."""
+    config = load_config()
+    version = get_java_version()
+    if version:
+        typer.echo(f"Detected Java version: {version}")
+    check_java_version(config.java.min_version)
+    typer.echo(f"Java version is compatible (>= {config.java.min_version}).")
+
+
+def main() -> None:
+    """Entry point for [project.scripts]."""
+    app()

tla/config.py

@@ -0,0 +1,63 @@
+import shutil
+from functools import lru_cache
+from pathlib import Path
+
+import platformdirs
+import yaml
+
+from tla.settings import Settings
+
+_APP_NAME = "tla"
+
+
+@lru_cache(maxsize=1)
+def load_config() -> Settings:
+    """Load config from the user config directory.
+
+    Creates a default config on first run.
+    """
+    cp = _ensure_config()
+    with cp.open() as f:
+        data = yaml.safe_load(f)
+        return Settings.model_validate(data)
+
+
+def config_dir() -> Path:
+    """OS-standard user config directory for this app."""
+    return Path(platformdirs.user_config_dir(_APP_NAME))
+
+
+def config_path() -> Path:
+    """Path to the user's config.yaml."""
+    return config_dir() / "config.yaml"
+
+
+def cache_dir() -> Path:
+    """OS-standard cache directory (stores tla2tools.jar)."""
+    return Path(platformdirs.user_cache_dir(_APP_NAME))
+
+
+def _default_config_path() -> Path:
+    """Path to the default config shipped with the package."""
+    return Path(__file__).parent / "resources" / "default_config.yaml"
+
+
+def _ensure_config() -> Path:
+    """Copy default config to user config dir if it doesn't exist yet."""
+    cp = config_path()
+    if not cp.exists():
+        cp.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(_default_config_path(), cp)
+    return cp
+
+
+def workspace_root() -> Path:
+    """Return the resolved workspace root directory.
+
+    Relative paths are resolved from the current working directory.
+    """
+    config = load_config()
+    ws_root = Path(config.workspace.root)
+    if not ws_root.is_absolute():
+        ws_root = (Path.cwd() / ws_root).resolve()
+    return ws_root

tla/download_tla2tools.py

@@ -0,0 +1,109 @@
+"""Download tla2tools.jar into the cache directory."""
+
+import os
+import subprocess
+from datetime import UTC, datetime
+from email.utils import parsedate_to_datetime
+from pathlib import Path
+
+import requests
+import typer
+
+from tla.check_java import check_java_version
+from tla.config import cache_dir, load_config
+
+
+def _get_version(jar_path: Path) -> str | None:
+    """Run TLC to extract the version string, or None if java is unavailable."""
+    try:
+        result = subprocess.run(
+            ["java", "-cp", str(jar_path), "tlc2.TLC"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        output = result.stdout + result.stderr
+        for line in output.splitlines():
+            if "Version" in line:
+                parts = line.split()
+                idx = parts.index("Version")
+                if idx + 1 < len(parts):
+                    return parts[idx + 1]
+    except FileNotFoundError:
+        pass
+    except subprocess.TimeoutExpired:
+        typer.echo("Warning: Timed out trying to get TLC version.", err=True)
+    return None
+
+
+def _set_file_mtime(path: Path, last_modified: str) -> None:
+    """Set file modification time from an HTTP Last-Modified header value."""
+    try:
+        dt = parsedate_to_datetime(last_modified)
+        mtime = dt.timestamp()
+        os.utime(path, (mtime, mtime))
+    except Exception as e:
+        typer.echo(f"Warning: could not set mtime: {e}", err=True)
+
+
+def download(jar_path: Path, url: str) -> str:
+    """Download the jar. Returns 'created', 'updated', or 'no_update'."""
+    headers: dict[str, str] = {}
+
+    if jar_path.exists():
+        mtime = jar_path.stat().st_mtime
+        dt = datetime.fromtimestamp(mtime, tz=UTC)
+        headers["If-Modified-Since"] = dt.strftime("%a, %d %b %Y %H:%M:%S GMT")
+
+    typer.echo(f"Downloading {jar_path.name}...")
+    resp = requests.get(url, headers=headers, stream=True, timeout=120, allow_redirects=True)
+
+    if resp.status_code == 304:
+        return "no_update"
+
+    resp.raise_for_status()
+
+    jar_path.parent.mkdir(parents=True, exist_ok=True)
+    existed = jar_path.exists()
+
+    total_size = int(resp.headers.get("content-length", 0))
+
+    with jar_path.open("wb") as f, typer.progressbar(length=total_size, label="Downloading") as progress:
+        for chunk in resp.iter_content(chunk_size=8192):
+            f.write(chunk)
+            progress.update(len(chunk))
+
+    if "Last-Modified" in resp.headers:
+        _set_file_mtime(jar_path, resp.headers["Last-Modified"])
+
+    return "updated" if existed else "created"
+
+
+def tla(
+    nightly: bool = typer.Option(False, "--nightly", help="Download nightly build instead of stable."),
+) -> None:
+    """Download or update tla2tools.jar."""
+
+    config = load_config()
+
+    # Check Java version before proceeding
+    check_java_version(config.java.min_version)
+
+    url = config.tla.urls.nightly if nightly else config.tla.urls.stable
+    jar_path = cache_dir() / config.tla.jar_name
+
+    try:
+        result = download(jar_path, url)
+    except requests.RequestException as e:
+        typer.echo(f"Error: could not download {config.tla.jar_name}: {e}", err=True)
+        raise typer.Exit(1) from None
+
+    version = _get_version(jar_path)
+    version_str = f" (version {version})" if version else ""
+
+    if result == "created":
+        typer.echo(f"Created {jar_path}{version_str}")
+    elif result == "updated":
+        typer.echo(f"Updated {jar_path}{version_str}")
+    else:
+        typer.echo(f"{config.tla.jar_name} is already at the latest version{version_str}")

tla/resources/default_config.yaml

@@ -0,0 +1,23 @@
+tla:
+  jar_name: tla2tools.jar
+  urls:
+    stable: https://github.com/tlaplus/tlaplus/releases/latest/download/tla2tools.jar
+    nightly: https://tla.msr-inria.inria.fr/tlatoolbox/ci/dist/tla2tools.jar
+
+# Path to the TLA+ workspace (specs, custom modules, compiled classes).
+# Relative paths are resolved from the current working directory.
+workspace:
+  root: .
+  spec_dir: spec
+  modules_dir: modules
+  classes_dir: classes
+
+tlc:
+  java_class: tlc2.TLC
+  overrides_class: tlc2.overrides.TLCOverrides
+
+java:
+  min_version: 11
+  opts:
+    - "-XX:+IgnoreUnrecognizedVMOptions"
+    - "-XX:+UseParallelGC"

tla/run_tlc.py

@@ -0,0 +1,45 @@
+"""Run TLC model checker on a TLA+ specification."""
+
+import os
+import subprocess
+
+import typer
+
+from tla.check_java import check_java_version
+from tla.config import cache_dir, load_config, workspace_root
+
+
+def tlc(
+    spec: str = typer.Argument(help="Name of the TLA+ specification (without .tla extension)."),
+) -> None:
+    """Run TLC model checker on a TLA+ specification."""
+    config = load_config()
+
+    # Check Java version before proceeding
+    check_java_version(config.java.min_version)
+
+    # Jar lives in the cache directory
+    jar_path = cache_dir() / config.tla.jar_name
+    if not jar_path.exists():
+        typer.echo(f"Error: {config.tla.jar_name} not found at {jar_path}", err=True)
+        typer.echo("Run 'tla download tla' first.", err=True)
+        raise typer.Exit(1)
+
+    ws_root = workspace_root()
+    spec_dir = ws_root / config.workspace.spec_dir
+    spec_file = spec_dir / f"{spec}.tla"
+    if not spec_file.exists():
+        typer.echo(f"Error: specification not found: {spec_file}", err=True)
+        raise typer.Exit(1)
+
+    classpath = str(jar_path)
+    classes_path = ws_root / config.workspace.classes_dir
+    if classes_path.exists():
+        classpath = f"{classes_path}{os.pathsep}{classpath}"
+
+    cmd = ["java", *config.java.opts, "-cp", classpath, config.tlc.java_class, str(spec_file)]
+
+    typer.echo(f"Running TLC on {spec}.tla ...")
+    typer.echo(f"Command: {' '.join(cmd)}")
+    result = subprocess.run(cmd, cwd=str(spec_dir))
+    raise typer.Exit(result.returncode)

tla/settings.py

@@ -0,0 +1,48 @@
+import os
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class TlaUrls(BaseModel):
+    stable: str
+    nightly: str
+
+
+class TlaConfig(BaseModel):
+    jar_name: str
+    urls: TlaUrls
+
+
+class WorkspaceConfig(BaseModel):
+    root: Path
+    spec_dir: Path
+    modules_dir: Path
+    classes_dir: Path
+
+
+class TlcConfig(BaseModel):
+    java_class: str = "tlc2.TLC"
+    overrides_class: str = "tlc2.overrides.TLCOverrides"
+
+
+class JavaConfig(BaseModel):
+    min_version: int = 11
+    opts: list[str] = Field(default_factory=lambda: ["-XX:+IgnoreUnrecognizedVMOptions", "-XX:+UseParallelGC"])
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_env_opts(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            env_opts = os.environ.get("JAVA_OPTS")
+            if env_opts:
+                data["opts"] = env_opts.split()
+        return data
+
+
+class Settings(BaseModel):
+    tla: TlaConfig
+    workspace: WorkspaceConfig
+    tlc: TlcConfig
+    java: JavaConfig = Field(default_factory=JavaConfig)

tlaplus_cli-0.1.7.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: tlaplus-cli
+Version: 0.1.7
+Summary: TLA+ tools: download TLC, compile custom modules, run model checker
+Author-email: Denis Nikolskiy <codeomatics@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nikolskiy/tlaplus-cli
+Project-URL: Repository, https://github.com/nikolskiy/tlaplus-cli
+Project-URL: Issues, https://github.com/nikolskiy/tlaplus-cli/issues
+Project-URL: Changelog, https://github.com/nikolskiy/tlaplus-cli/blob/main/CHANGELOG.md
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer<1.0.0,>=0.22.0
+Requires-Dist: requests<3.0.0,>=2.31.0
+Requires-Dist: pyyaml<7.0,>=6.0
+Requires-Dist: platformdirs<5.0,>=4.0
+Requires-Dist: pydantic<3.0.0,>=2.12.5
+Dynamic: license-file
+
+# TLA+ CLI
+
+Command-line tool for working with TLA+ specifications and the TLC model checker.
+
+## Installation
+
+Install system-wide via uv tool
+
+```bash
+uv tool install git+https://github.com/nikolskiy/tlaplus-cli
+```
+
+Upgrade:
+```bash
+uv tool upgrade tlaplus-cli
+```
+
+Uninstall
+
+```bash
+uv tool uninstall tlaplus-cli
+```
+
+## Usage
+
+### Download TLC
+
+```bash
+# Download stable release
+tla download
+
+# Download nightly build
+tla download --nightly
+```
+
+### Check Java Version
+
+```bash
+tla check-java
+```
+
+### Compile Custom Java Modules
+
+```bash
+tla build
+
+# Verbose output
+tla build --verbose
+```
+
+Compiles `.java` files from `workspace/modules/` into `workspace/classes/`.
+
+### Run TLC
+
+```bash
+tla tlc <spec_name>
+```
+
+For example:
+
+```bash
+tla tlc queue
+```
+
+## Configuration
+
+On first run, a default config is created at:
+
+```
+~/.config/tla/config.yaml
+```
+
+Edit this file to set your workspace path and TLC options:
+
+```yaml
+tla:
+  jar_name: tla2tools.jar
+  urls:
+    stable: https://github.com/tlaplus/tlaplus/releases/latest/download/tla2tools.jar
+    nightly: https://tla.msr-inria.inria.fr/tlatoolbox/ci/dist/tla2tools.jar
+
+workspace:
+  root: .                 # Project root (relative to CWD)
+  spec_dir: spec          # Directory containing .tla files
+  modules_dir: modules    # Directory containing .java files
+  classes_dir: classes    # Directory for compiled .class files
+
+tlc:
+  java_class: tlc2.TLC
+  overrides_class: tlc2.overrides.TLCOverrides
+
+java:
+  min_version: 11
+  opts:
+    - "-XX:+IgnoreUnrecognizedVMOptions"
+    - "-XX:+UseParallelGC"
+```
+
+### Directory Layout
+
+| Directory | Purpose | Location |
+|---|---|---|
+| Config | `config.yaml` | `~/.config/tla/` |
+| Cache | `tla2tools.jar` | `~/.cache/tla/` |
+| Workspace | specs + modules + classes | Set via `workspace.root` in config |
+
+## Note on Package Name
+
+This package is distributed on PyPI as **`tlaplus-cli`** but imports as **`tla`**. There is a separate, unrelated [`tla`](https://pypi.org/project/tla/) package on PyPI (a TLA+ parser). If you have both installed, they will conflict. In practice this is unlikely since they serve different purposes, but be aware of it.
+
+## Dependencies
+
+*   **Java >= 11**: Required for TLC.
+*   [**uv**](https://docs.astral.sh/uv/getting-started/installation/): For installing the tool.

tlaplus_cli-0.1.7.dist-info/RECORD

@@ -0,0 +1,16 @@
+tla/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tla/build_tlc_module.py,sha256=uclqwA4rXBydllUWKoMF6bz8T3p2Ee-Y5pE0yqgJS94,2444
+tla/check_java.py,sha256=2XCK7lEJXZ8sLl3W3iHL-8i_0Q1yvq8KGVRJ1HYD3_4,2428
+tla/cli.py,sha256=E6P1yJFGVzWQNeWz3gcJDycMjZQexfFD8ButQZFjSwo,1899
+tla/config.py,sha256=89yTVrtWlQVXel7d-uCLXvpk0Mxc3jBK4Vi21-BowXU,1620
+tla/download_tla2tools.py,sha256=VPjrxZgmyYnuEe8OylaiFrkV-SkzWQaV_YuMC5nfYXA,3581
+tla/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tla/run_tlc.py,sha256=QGE9NXFq3ClanXExtglv6gQPWDLjghXP7l_ckntdhSY,1517
+tla/settings.py,sha256=EFUR4TxjUc8YMTuamX-5dPh0qgD6o_EWctcyzX-QKqM,1079
+tla/resources/default_config.yaml,sha256=altsNmZ8YGVhZgR5NVr0wFbpasgRZ870uCfwommF9RQ,602
+tlaplus_cli-0.1.7.dist-info/licenses/LICENSE,sha256=kSdiS8uZ4kMvuDD_2ttsaoTtFbnf6Pyv_RrNWDKFRyM,1072
+tlaplus_cli-0.1.7.dist-info/METADATA,sha256=nCFuwu7EhN2hEaXLd4a_12sviRVBRNPZf07qEAsI6tk,3480
+tlaplus_cli-0.1.7.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+tlaplus_cli-0.1.7.dist-info/entry_points.txt,sha256=W7e3tHBQcfdnUYKInVqzmkMa8mV2wg6mACw06U72k9E,37
+tlaplus_cli-0.1.7.dist-info/top_level.txt,sha256=hPeD7gCgxcaE0qw9JQATNEfCwIEh300GKJyysU_XoS8,4
+tlaplus_cli-0.1.7.dist-info/RECORD,,

tlaplus_cli-0.1.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tlaplus_cli-0.1.7.dist-info/entry_points.txt

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

tlaplus_cli-0.1.7.dist-info/licenses/LICENSE

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

tlaplus_cli-0.1.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+tla