polygit 0.1.0__py3-none-any.whl

polygit/cli.py

@@ -0,0 +1,57 @@
+import sys
+import argparse
+from .config import find_config, load_config
+from .repo import cmd_sync, cmd_status, cmd_pull, cmd_push
+from .repos import cmd_repos
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="pgit",
+        description="Manage multiple git repos defined in a .pgit config file."
+    )
+    sub = parser.add_subparsers(dest="command", metavar="command")
+
+    sub.add_parser("sync",   help="Clone missing repos and fetch all")
+    sub.add_parser("status", help="Show repos with uncommitted changes")
+    sub.add_parser("pull",   help="Pull all repos, auto-stashing local changes")
+
+    push_p = sub.add_parser("push", help="Commit and push dirty repos")
+    mode_g = push_p.add_mutually_exclusive_group()
+    mode_g.add_argument("--interactive", dest="push_mode", action="store_const",
+                        const="interactive", help="Prompt per repo (default)")
+    mode_g.add_argument("--all", dest="push_mode", action="store_const",
+                        const="all", help="One commit message for all dirty repos")
+    mode_g.add_argument("--wip", dest="push_mode", action="store_const",
+                        const="wip", help='Auto-commit with "WIP <timestamp>"')
+    push_p.set_defaults(push_mode="interactive")
+
+    sub.add_parser("repos", help="Discover drift between .pgit and the filesystem")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    config_path = find_config()
+    if config_path is None:
+        print("Error: no .pgit config file found in this directory or any parent.", file=sys.stderr)
+        print("Create a .pgit file in your repos root directory.", file=sys.stderr)
+        sys.exit(1)
+
+    base   = config_path.parent
+    config = load_config(config_path)
+
+    commands = {
+        "sync":   lambda: cmd_sync(config, base),
+        "status": lambda: cmd_status(config, base),
+        "pull":   lambda: cmd_pull(config, base),
+        "push":   lambda: cmd_push(config, base, mode=args.push_mode),
+        "repos":  lambda: cmd_repos(config, base, config_path),
+    }
+    commands[args.command]()
+
+
+if __name__ == "__main__":
+    main()

polygit/config.py

@@ -0,0 +1,46 @@
+import yaml
+from pathlib import Path
+
+HOSTS = {
+    "github": "git@github.com",
+    "gitlab": "git@gitlab.com",
+}
+
+CONFIG_FILE = ".pgit"
+
+
+def find_config(start=None):
+    """Walk up from start (default: cwd) to find a .pgit config file."""
+    current = Path(start or Path.cwd())
+    for path in [current] + list(current.parents):
+        candidate = path / CONFIG_FILE
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def load_config(path):
+    """Load and return the .pgit YAML config."""
+    with open(path) as f:
+        return yaml.safe_load(f) or {}
+
+
+def write_config(data, path):
+    """Write .pgit config using only stdlib — preserves null and inline-remote styles."""
+    def _lines(node, indent):
+        prefix = "  " * indent
+        out = []
+        for key, value in node.items():
+            if value is None:
+                out.append(f"{prefix}{key}:")
+            elif isinstance(value, dict) and set(value.keys()) == {"remote"}:
+                out.append(f'{prefix}{key}: {{remote: "{value["remote"]}"}}'  )
+            elif isinstance(value, dict):
+                out.append(f"{prefix}{key}:")
+                out.extend(_lines(value, indent + 1))
+            else:
+                out.append(f"{prefix}{key}: {value}")
+        return out
+
+    with open(path, "w") as f:
+        f.write("\n".join(_lines(data, 0)) + "\n")

polygit/repo.py

@@ -0,0 +1,151 @@
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from .config import HOSTS
+
+
+def walk(node, prefix):
+    """Yield (local_path, remote_path) for every repo in the tree."""
+    if node is None:
+        yield prefix, prefix
+    elif isinstance(node, dict) and set(node.keys()) == {"remote"}:
+        yield prefix, node["remote"]
+    elif isinstance(node, dict):
+        for key, value in node.items():
+            yield from walk(value, f"{prefix}/{key}")
+
+
+def each_repo(config, base):
+    """Yield (platform, local_path, remote_path, dir) for all configured repos."""
+    for platform, namespaces in config.items():
+        if platform not in HOSTS:
+            continue
+        for ns_key, ns_value in namespaces.items():
+            for local_path, remote_path in walk(ns_value, ns_key):
+                yield platform, local_path, remote_path, base / platform / local_path
+
+
+def each_existing_repo(config, base):
+    """Yield only repos that are already cloned locally."""
+    for platform, local_path, remote_path, d in each_repo(config, base):
+        if (d / ".git").exists():
+            yield platform, local_path, remote_path, d
+
+
+def is_dirty(d):
+    result = subprocess.run(
+        ["git", "-C", str(d), "status", "--porcelain"],
+        capture_output=True, text=True
+    )
+    return bool(result.stdout.strip())
+
+
+def _commit_and_push(d, label, msg):
+    print(f"Committing {label}...")
+    subprocess.run(["git", "-C", str(d), "add", "-A"])
+    subprocess.run(["git", "-C", str(d), "commit", "-m", msg])
+    result = subprocess.run(["git", "-C", str(d), "push"], capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"  Push failed: {result.stderr.strip()}")
+    else:
+        print(f"  Pushed.")
+
+
+def cmd_sync(config, base):
+    for platform, local_path, remote_path, d in each_repo(config, base):
+        url = f"{HOSTS[platform]}:{remote_path}.git"
+        if (d / ".git").exists():
+            print(f"Fetching {platform}/{local_path}...")
+            subprocess.run(["git", "-C", str(d), "fetch", "--all", "-q"])
+        else:
+            print(f"Cloning {platform}/{local_path}...")
+            d.parent.mkdir(parents=True, exist_ok=True)
+            subprocess.run(["git", "clone", url, str(d)])
+
+
+def cmd_status(config, base):
+    found_dirty = False
+    for platform, local_path, _, d in each_existing_repo(config, base):
+        result = subprocess.run(
+            ["git", "-C", str(d), "status", "--short"],
+            capture_output=True, text=True
+        )
+        if result.stdout.strip():
+            found_dirty = True
+            print(f"\n{platform}/{local_path}:")
+            for line in result.stdout.strip().splitlines():
+                print(f"  {line}")
+    if not found_dirty:
+        print("All repos are clean.")
+
+
+def cmd_pull(config, base):
+    for platform, local_path, _, d in each_existing_repo(config, base):
+        label = f"{platform}/{local_path}"
+        stashed = False
+        if is_dirty(d):
+            print(f"Stashing {label}...")
+            subprocess.run(["git", "-C", str(d), "stash"], capture_output=True)
+            stashed = True
+        print(f"Pulling {label}...")
+        result = subprocess.run(
+            ["git", "-C", str(d), "pull", "--rebase"],
+            capture_output=True, text=True
+        )
+        if result.returncode != 0:
+            print(f"  Error: {result.stderr.strip()}")
+        elif result.stdout.strip() and result.stdout.strip() != "Already up to date.":
+            print(f"  {result.stdout.strip()}")
+        if stashed:
+            pop = subprocess.run(
+                ["git", "-C", str(d), "stash", "pop"],
+                capture_output=True, text=True
+            )
+            if pop.returncode != 0:
+                print(f"  Warning: stash pop had conflicts in {label}")
+            else:
+                print(f"  Stash restored.")
+
+
+def cmd_push(config, base, mode="interactive"):
+    dirty = [
+        (platform, local_path, d)
+        for platform, local_path, _, d in each_existing_repo(config, base)
+        if is_dirty(d)
+    ]
+
+    if not dirty:
+        print("No dirty repos to commit.")
+        return
+
+    if mode == "wip":
+        msg = f"WIP {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+        for platform, local_path, d in dirty:
+            _commit_and_push(d, f"{platform}/{local_path}", msg)
+
+    elif mode == "all":
+        print("Dirty repos:")
+        for platform, local_path, _ in dirty:
+            print(f"  {platform}/{local_path}")
+        msg = input("\nCommit message for all repos (blank to abort): ").strip()
+        if not msg:
+            print("Aborted.")
+            return
+        for platform, local_path, d in dirty:
+            _commit_and_push(d, f"{platform}/{local_path}", msg)
+
+    else:  # interactive
+        for platform, local_path, d in dirty:
+            label = f"{platform}/{local_path}"
+            status = subprocess.run(
+                ["git", "-C", str(d), "status", "--short"],
+                capture_output=True, text=True
+            ).stdout.strip()
+            print(f"\n{label}:")
+            for line in status.splitlines():
+                print(f"  {line}")
+            msg = input("  Commit message (blank to skip): ").strip()
+            if not msg:
+                print("  Skipped.")
+                continue
+            _commit_and_push(d, label, msg)

polygit/repos.py

@@ -0,0 +1,204 @@
+import subprocess
+from pathlib import Path
+from .config import HOSTS, write_config
+from .repo import walk
+
+
+def parse_remote_url(url):
+    """Parse a git remote URL into (platform, remote_path).
+
+    git@github.com:org/repo.git       -> (github, org/repo)
+    git@gitlab.com:ns/sub/repo.git    -> (gitlab, ns/sub/repo)
+    https://github.com/org/repo.git   -> (github, org/repo)
+    """
+    if not url:
+        return None, None
+    url = url.strip()
+    if url.endswith(".git"):
+        url = url[:-4]
+    if url.startswith("git@"):
+        host, path = url[4:].split(":", 1)
+    elif "://" in url:
+        rest = url.split("://", 1)[1]
+        host, path = rest.split("/", 1)
+    else:
+        return None, None
+    platform = "github" if "github" in host else ("gitlab" if "gitlab" in host else None)
+    return platform, path
+
+
+def del_nested(d, keys):
+    """Delete d[k0][k1]...[kn], pruning empty parent dicts."""
+    if not keys or keys[0] not in d:
+        return
+    if len(keys) == 1:
+        del d[keys[0]]
+    else:
+        del_nested(d[keys[0]], keys[1:])
+        if isinstance(d[keys[0]], dict) and not d[keys[0]]:
+            del d[keys[0]]
+
+
+def _add_to_config(config, fs_platform, local_path, remote_url):
+    """Insert a repo entry into the config data structure."""
+    local_parts = local_path.split("/")
+    local_name  = local_parts[-1]
+    _, remote_path = parse_remote_url(remote_url)
+    platform_data = config.setdefault(fs_platform, {})
+
+    if remote_path:
+        r_parts = remote_path.split("/")
+        r_name  = r_parts[-1]
+        r_ns    = "/".join(r_parts[:-1])
+        ns_data = platform_data.setdefault(r_ns, {})
+        if local_path == f"{r_ns}/{r_name}":
+            ns_data[r_name] = None
+        else:
+            sub  = local_path[len(r_ns)+1:] if local_path.startswith(r_ns + "/") else local_name
+            node = ns_data
+            for part in sub.split("/")[:-1]:
+                node = node.setdefault(part, {})
+            node[sub.split("/")[-1]] = {"remote": remote_path}
+    else:
+        local_ns = "/".join(local_parts[:-1])
+        platform_data.setdefault(local_ns, {})[local_name] = None
+
+
+def cmd_repos(config, base, config_path):
+    """Diff .pgit config against the filesystem and offer to update."""
+
+    # ── 1. Scan filesystem ──────────────────────────────────────────────────
+    local_repos = {}  # "platform/local_path" -> (dir, remote_url)
+    for platform in ["github", "gitlab"]:
+        platform_dir = base / platform
+        if not platform_dir.exists():
+            continue
+        for git_marker in sorted(platform_dir.rglob(".git")):
+            if not git_marker.is_dir():
+                continue
+            repo_dir = git_marker.parent
+            rel      = repo_dir.relative_to(platform_dir)
+            parts    = rel.parts
+            # Skip repos nested inside another git repo
+            if any((platform_dir.joinpath(*parts[:i]) / ".git").is_dir()
+                   for i in range(1, len(parts))):
+                continue
+            result = subprocess.run(
+                ["git", "-C", str(repo_dir), "remote", "get-url", "origin"],
+                capture_output=True, text=True
+            )
+            remote_url = result.stdout.strip() if result.returncode == 0 else None
+            local_repos[f"{platform}/{rel}"] = (repo_dir, remote_url)
+
+    # ── 2. Build tracked indices ─────────────────────────────────────────────
+    tracked_by_local  = {}  # "platform/local_path"   -> (remote_path, expected_url)
+    tracked_by_remote = {}  # "platform/remote_path"  -> "platform/local_path"
+
+    for platform, namespaces in config.items():
+        host = HOSTS.get(platform, "")
+        for ns_key, ns_value in namespaces.items():
+            for local_path, remote_path in walk(ns_value, ns_key):
+                lkey = f"{platform}/{local_path}"
+                rkey = f"{platform}/{remote_path}"
+                tracked_by_local[lkey]  = (remote_path, f"{host}:{remote_path}.git")
+                tracked_by_remote[rkey] = lkey
+
+    # ── 3. Categorize ────────────────────────────────────────────────────────
+    untracked       = {}  # key -> (dir, url)
+    wrong_location  = {}  # key -> (dir, url, config_key)
+    remote_mismatch = {}  # key -> (expected_url, actual_url)
+    missing = {k for k in tracked_by_local if k not in local_repos}
+
+    for key, (repo_dir, remote_url) in local_repos.items():
+        fs_platform = key.split("/")[0]
+        _, remote_path = parse_remote_url(remote_url)
+        rkey = f"{fs_platform}/{remote_path}" if remote_path else None
+
+        if key in tracked_by_local:
+            _, expected_url = tracked_by_local[key]
+            if remote_url and remote_url != expected_url:
+                remote_mismatch[key] = (expected_url, remote_url)
+        elif rkey and rkey in tracked_by_remote:
+            wrong_location[key] = (repo_dir, remote_url, tracked_by_remote[rkey])
+        else:
+            untracked[key] = (repo_dir, remote_url)
+
+    # ── 4. Report ─────────────────────────────────────────────────────────────
+    if not any([untracked, wrong_location, remote_mismatch, missing]):
+        print(".pgit is in sync with the filesystem.")
+        return
+
+    if remote_mismatch:
+        print("\nRemote mismatch (local path matches config but git remote differs):")
+        for key, (expected, actual) in sorted(remote_mismatch.items()):
+            print(f"  ~ {key}")
+            print(f"      config: {expected}")
+            print(f"      actual: {actual}")
+
+    if wrong_location:
+        print("\nCloned to a different path than .pgit expects:")
+        for key, (_, url, config_key) in sorted(wrong_location.items()):
+            actual_dir   = base / Path(*key.split("/"))
+            expected_dir = base / Path(*config_key.split("/"))
+            is_rename    = actual_dir.parent == expected_dir.parent
+            hint = f"  (rename: {actual_dir.name} → {expected_dir.name})" if is_rename else ""
+            print(f"  ? {key}")
+            print(f"      remote:   {url}")
+            print(f"      expected: {config_key}{hint}")
+
+    if untracked:
+        print("\nOn disk but not in .pgit:")
+        for key, (_, url) in sorted(untracked.items()):
+            print(f"  + {key}  ({url or 'no remote'})")
+
+    if missing:
+        print("\nIn .pgit but not cloned locally (run: pgit sync):")
+        for key in sorted(missing):
+            print(f"  - {key}")
+
+    # ── 5. Add untracked ──────────────────────────────────────────────────────
+    if untracked:
+        print()
+        if input("Add untracked repos to .pgit? [y/N] ").strip().lower() == "y":
+            for key, (_, remote_url) in sorted(untracked.items()):
+                fs_platform, local_path = key.split("/", 1)
+                _add_to_config(config, fs_platform, local_path, remote_url)
+                print(f"  Added {key}")
+            write_config(config, config_path)
+            print(f"\nUpdated {config_path}")
+
+    # ── 6. Fix wrong-location ─────────────────────────────────────────────────
+    if wrong_location:
+        for key, (_, remote_url, config_key) in sorted(wrong_location.items()):
+            actual_dir   = base / Path(*key.split("/"))
+            expected_dir = base / Path(*config_key.split("/"))
+            is_rename    = actual_dir.parent == expected_dir.parent
+            print()
+            if is_rename:
+                if input(f"Rename {actual_dir.name} → {expected_dir.name}? [y/N] ").strip().lower() == "y":
+                    actual_dir.rename(expected_dir)
+                    print(f"  Renamed.")
+            else:
+                if input(f"Add {key} to .pgit with remote override? [y/N] ").strip().lower() == "y":
+                    fs_platform, local_path = key.split("/", 1)
+                    _add_to_config(config, fs_platform, local_path, remote_url)
+                    print(f"  Added {key}")
+                    write_config(config, config_path)
+                    print(f"\nUpdated {config_path}")
+
+    # ── 7. Remove missing ─────────────────────────────────────────────────────
+    if missing:
+        print()
+        if input("Remove missing repos from .pgit? [y/N] ").strip().lower() == "y":
+            for key in sorted(missing):
+                fs_platform, local_path = key.split("/", 1)
+                for ns_key in list(config.get(fs_platform, {}).keys()):
+                    if local_path.startswith(ns_key + "/"):
+                        sub = local_path[len(ns_key)+1:].split("/")
+                        del_nested(config[fs_platform][ns_key], sub)
+                        if not config[fs_platform][ns_key]:
+                            del config[fs_platform][ns_key]
+                        break
+                print(f"  Removed {key}")
+            write_config(config, config_path)
+            print(f"\nUpdated {config_path}")

polygit-0.1.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: polygit
+Version: 0.1.0
+Summary: Manage multiple git repos from a single .pgit config file.
+Project-URL: Repository, https://gitlab.com/gary.schaetz/public/polygit
+Author-email: Gary Schaetz <gary@schaetzkc.com>
+License: MIT License
+        
+        Copyright (c) 2025 Gary Schaetz
+        
+        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.
+License-File: LICENSE.txt
+Keywords: devtools,git,multi-repo,pgit,polygit,repos
+Requires-Python: >=3.8
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+# polygit
+
+Manage multiple git repos from a single `.pgit` config file.
+
+```bash
+pip install polygit
+```
+
+## Usage
+
+```bash
+pgit sync      # clone missing repos, fetch all
+pgit status    # show repos with uncommitted changes
+pgit pull      # pull all repos, auto-stashing local changes
+pgit push      # interactively commit and push dirty repos
+pgit repos     # discover drift between .pgit and the filesystem
+```
+
+## Configuration
+
+Create a `.pgit` file in the root directory that contains your repos:
+
+```yaml
+github:
+  your-username:
+    repo-one:
+    repo-two:
+  some-org:
+    their-repo: {remote: "some-org/their-repo"}
+
+gitlab:
+  your-namespace/group:
+    private-repo:
+    another-repo:
+```
+
+`pgit` discovers this file by walking up from the current directory — so running `pgit status` anywhere inside your repos root just works.
+
+### Remote overrides
+
+If a repo is cloned to a local path that differs from its remote path, use the `remote` key:
+
+```yaml
+github:
+  my-local-name:
+    project: {remote: "upstream-org/project"}
+```
+
+## push modes
+
+```bash
+pgit push                # prompt for a message per repo (default)
+pgit push --all          # one message for all dirty repos
+pgit push --wip          # auto-commit with "WIP <timestamp>"
+```
+
+## repos — drift detection
+
+`pgit repos` compares what's actually on disk against your `.pgit` config and reports:
+
+- **Remote mismatch** — repo is at the right path but the git remote differs (e.g. SSH vs HTTPS)
+- **Wrong location** — remote is tracked in `.pgit` but cloned to a different directory
+- **Untracked** — repo on disk not referenced in `.pgit` at all
+- **Missing** — in `.pgit` but not yet cloned (run `pgit sync`)
+
+It then offers to update `.pgit` or rename directories interactively.
+
+## Migrating from repos.yaml
+
+If you were using the `sync.sh` predecessor, rename your `repos.yaml` to `.pgit` — the format is identical.
+
+## Requirements
+
+- Python 3.8+
+- git

polygit-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+polygit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polygit/cli.py,sha256=t55G_27aWlqScA3mQeRVFg1HwitpzBYOATn3qVl7Ulk,2163
+polygit/config.py,sha256=3lZCp073173cskTxXpqNjP8bk50QuYstz0zKLCEieQY,1378
+polygit/repo.py,sha256=92l_OO63KBIdho-Sq1KaWoRhbLT616trA08Ct03GRlE,5384
+polygit/repos.py,sha256=1X4xpA7d32cdHt--v2-1yRjw4uiMxGRrWz-uMw27zfE,9602
+polygit-0.1.0.dist-info/METADATA,sha256=5vNz9Ny6u74O6Zk8kWJp1Wf5bPZy0hKrY3r8MS9Wjb8,3593
+polygit-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+polygit-0.1.0.dist-info/entry_points.txt,sha256=hBPbWbQygzHXMfwect-YNoaVPFh1_9EMfIo4ec3EY_A,42
+polygit-0.1.0.dist-info/licenses/LICENSE.txt,sha256=YxFgIp_vc7jYYhGaqNWuAcBNNenp4Kgnj622VLgew_U,1069
+polygit-0.1.0.dist-info/RECORD,,

polygit-0.1.0.dist-info/WHEEL

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

polygit-0.1.0.dist-info/entry_points.txt

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

polygit-0.1.0.dist-info/licenses/LICENSE.txt

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