shappetrack 1.0.0__py3-none-any.whl

shappetrack/README.md

@@ -0,0 +1,67 @@
+# ShappeTrack CLI
+
+Clone, commit, and push ShappeTrack repositories with **one app token**. Real
+`git` runs under the hood; the git engine is never exposed.
+
+```
+shappetrack login --server https://track-api.shappe.ai/api/v1
+shappetrack clone my-repo
+```
+
+## Install
+
+The CLI is a small Python package (`shappetrack-cli`). The recommended way is
+[`pipx`](https://pipx.pypa.io/), which installs it in an isolated environment so
+it never clashes with your other Python tools.
+
+### For end users (once published to PyPI)
+
+```bash
+pipx install shappetrack
+```
+
+### From source (internal / development)
+
+From the directory containing `pyproject.toml`:
+
+```bash
+pipx install .          # isolated, recommended
+# or
+pip install .           # into the current environment
+```
+
+Requires **Python 3.9+** and **git** on your PATH (the CLI runs real git under the hood).
+
+## Usage
+
+1. Create an app token in the web app: **Settings → Access Tokens** (starts with `shp_`).
+2. Log in once — this configures git credentials automatically:
+
+   ```bash
+   shappetrack login --server https://track-api.shappe.ai/api/v1
+   ```
+
+3. Then use the familiar commands (they run standard git underneath):
+
+   ```bash
+   shappetrack clone my-repo
+   shappetrack status
+   shappetrack add .
+   shappetrack commit -m "message" --task MT-101
+   shappetrack push
+   shappetrack pull
+   shappetrack branch feature-x
+   ```
+
+## How it works
+
+`shappetrack clone my-repo` runs `git clone https://track-api.shappe.ai/repos/my-repo`
+using the app token you logged in with. The backend proxies git traffic to the
+internal engine — you never see or handle the engine, its host, or its token.
+
+You can also clone with plain git directly (no CLI needed):
+
+```bash
+git clone https://track-api.shappe.ai/repos/my-repo
+# username: your ShappeTrack username, password: your shp_ app token
+```

shappetrack/RELEASING.md

@@ -0,0 +1,89 @@
+# Releasing the ShappeTrack CLI
+
+Three distribution channels, in order of how real CLIs ship (`gh`, `aws`, `stripe`):
+
+1. **PyPI** — `pipx install shappetrack` (primary for Python users)
+2. **Standalone binary** — a single `shappetrack.exe` / `shappetrack`, no Python needed
+3. **One-line installer** — `curl … | sh` that fetches the right binary
+
+---
+
+## 0. Build the artifacts
+
+From `shappetrack-backend/` (the folder with `pyproject.toml`):
+
+```bash
+python -m build                 # → dist/shappetrack-1.0.0-{.whl,.tar.gz}
+python -m twine check dist/*    # metadata validation (must PASS)
+```
+
+Standalone binary:
+
+```bash
+python -m PyInstaller --onefile --name shappetrack \
+  --collect-all typer --collect-all click --collect-all httpx \
+  --paths . shappetrack/__pyinstaller_entry.py --distpath dist/bin
+# → dist/bin/shappetrack.exe  (or dist/bin/shappetrack on Linux/macOS)
+```
+
+Both are already built and verified (twine PASSED; the exe runs standalone).
+
+---
+
+## 1. Publish to PyPI  ⚠️ needs a PyPI account + API token (only you can do this)
+
+The name `shappetrack` is currently FREE on PyPI (verified). To claim + publish:
+
+1. Create an account at https://pypi.org and an **API token**
+   (Account settings → API tokens → scope "Entire account" for the first upload).
+2. Test on **TestPyPI** first (optional but recommended):
+
+   ```bash
+   python -m twine upload --repository testpypi dist/*
+   pipx install --index-url https://test.pypi.org/simple/ shappetrack
+   ```
+
+3. Publish for real:
+
+   ```bash
+   python -m twine upload dist/*
+   # username: __token__
+   # password: <your PyPI API token, starts with pypi-…>
+   ```
+
+Then anyone can:
+
+```bash
+pipx install shappetrack
+```
+
+**Bump `version` in `pyproject.toml` for every release** — PyPI rejects re-uploading the same version.
+
+---
+
+## 2. Standalone binary (no Python for the user)
+
+Attach `dist/bin/shappetrack.exe` (Windows) and a Linux/macOS build to a GitHub
+Release. Build the exe **on each target OS** (PyInstaller isn't cross-platform).
+
+---
+
+## 3. One-line installer (later polish)
+
+Host `install.sh` at e.g. `get.shappe.ai`; it detects OS/arch, downloads the
+matching binary from the Releases page, and drops it on the user's PATH:
+
+```bash
+curl -fsSL https://get.shappe.ai | sh
+```
+
+---
+
+## User-facing install summary (put in main docs)
+
+| Method | Command | Needs Python? |
+|--------|---------|---------------|
+| pipx (recommended) | `pipx install shappetrack` | yes |
+| pip | `pip install shappetrack` | yes |
+| standalone binary | download `shappetrack.exe`, add to PATH | no |
+| one-line (future) | `curl -fsSL https://get.shappe.ai \| sh` | no |

shappetrack/__init__.py

@@ -0,0 +1,7 @@
+"""ShappeTrack CLI — clone/commit/push ShappeTrack repos with one app token.
+
+Real git runs underneath; the git engine stays invisible. Installed as the
+`shappetrack` command (see ../pyproject.toml). Run standalone with `python -m shappetrack`.
+"""
+
+__version__ = "1.0.0"

shappetrack/__main__.py

@@ -0,0 +1,4 @@
+from .shapetrack import app
+
+if __name__ == "__main__":
+    app()

shappetrack/__pyinstaller_entry.py

@@ -0,0 +1,10 @@
+"""PyInstaller entry point — builds the standalone `shappetrack` executable.
+
+PyInstaller needs a real script (not a module target), so this just invokes the
+Typer app. Not used at runtime by the pip-installed CLI (that uses the console
+entry point in pyproject.toml).
+"""
+from shappetrack.shapetrack import app
+
+if __name__ == "__main__":
+    app()

shappetrack/local.py

@@ -0,0 +1,121 @@
+"""Local working-copy format for ShapeTrack (the `.shapetrack/` folder)."""
+import hashlib
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional
+
+ST_DIR = ".shapetrack"
+CRED_PATH = Path.home() / ".shapetrack" / "credentials.json"
+
+# Directories never tracked
+_IGNORE_DIRS = {".shapetrack", ".git", "node_modules", "__pycache__", "venv", ".venv", "dist", "build"}
+
+
+# ---------- credentials (global) ----------
+def save_credentials(server_url: str, token: str) -> None:
+    CRED_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CRED_PATH.write_text(json.dumps({"server_url": server_url, "token": token}, indent=2))
+
+
+def load_credentials() -> Optional[dict]:
+    if CRED_PATH.exists():
+        return json.loads(CRED_PATH.read_text())
+    return None
+
+
+# ---------- local repo (.shapetrack/) ----------
+def st_root(start: Optional[Path] = None) -> Optional[Path]:
+    """Walk up from `start` to find a directory containing `.shapetrack/`."""
+    cur = (start or Path.cwd()).resolve()
+    for d in [cur, *cur.parents]:
+        if (d / ST_DIR).is_dir():
+            return d
+    return None
+
+
+def _meta_dir(root: Path) -> Path:
+    return root / ST_DIR
+
+
+def init_local(root: Path, server_url: str, repo_slug: str, branch: str = "main") -> None:
+    meta = _meta_dir(root)
+    meta.mkdir(parents=True, exist_ok=True)
+    write_config(root, {"server_url": server_url, "repo_slug": repo_slug})
+    write_head(root, {"branch": branch, "commit_sha": None})
+    write_tree(root, {})
+    write_index(root, {})
+
+
+def _read_json(path: Path, default):
+    return json.loads(path.read_text()) if path.exists() else default
+
+
+def read_config(root: Path) -> dict:
+    return _read_json(_meta_dir(root) / "config.json", {})
+
+
+def write_config(root: Path, data: dict) -> None:
+    (_meta_dir(root) / "config.json").write_text(json.dumps(data, indent=2))
+
+
+def read_head(root: Path) -> dict:
+    return _read_json(_meta_dir(root) / "HEAD", {"branch": "main", "commit_sha": None})
+
+
+def write_head(root: Path, data: dict) -> None:
+    (_meta_dir(root) / "HEAD").write_text(json.dumps(data, indent=2))
+
+
+def read_tree(root: Path) -> Dict[str, str]:
+    """The committed file-tree at HEAD ({path: blob_sha})."""
+    return _read_json(_meta_dir(root) / "tree.json", {})
+
+
+def write_tree(root: Path, tree: Dict[str, str]) -> None:
+    (_meta_dir(root) / "tree.json").write_text(json.dumps(tree, indent=2, sort_keys=True))
+
+
+def read_index(root: Path) -> Dict[str, str]:
+    """Staged paths ({path: blob_sha})."""
+    return _read_json(_meta_dir(root) / "index.json", {})
+
+
+def write_index(root: Path, index: Dict[str, str]) -> None:
+    (_meta_dir(root) / "index.json").write_text(json.dumps(index, indent=2, sort_keys=True))
+
+
+# ---------- working tree ----------
+def hash_bytes(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def scan_working_tree(root: Path) -> Dict[str, str]:
+    """Map every tracked working file (relative posix path) -> content sha."""
+    tree: Dict[str, str] = {}
+    root = root.resolve()
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in _IGNORE_DIRS]
+        for fn in filenames:
+            full = Path(dirpath) / fn
+            rel = full.relative_to(root).as_posix()
+            try:
+                tree[rel] = hash_bytes(full.read_bytes())
+            except OSError:
+                continue
+    return tree
+
+
+def diff_trees(base: Dict[str, str], target: Dict[str, str]):
+    """Return (added, modified, deleted) paths comparing base -> target."""
+    base_keys, target_keys = set(base), set(target)
+    added = sorted(target_keys - base_keys)
+    deleted = sorted(base_keys - target_keys)
+    modified = sorted(k for k in (base_keys & target_keys) if base[k] != target[k])
+    return added, modified, deleted
+
+
+def write_working_file(root: Path, rel_path: str, data: bytes) -> None:
+    dest = root / rel_path
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_bytes(data)

shappetrack/shapetrack.py

@@ -0,0 +1,266 @@
+"""
+shapetrack — ShapeTrack's CLI. Your command, real git underneath, talking to the
+ShapeTrack engine. Commands stay identical; internally we run standard git.
+
+Run via:  python -m cli <command>
+Commands: login, whoami, clone, init, status, add, commit, push, pull, branch, checkout, logout
+"""
+import json
+import subprocess
+from pathlib import Path
+from typing import List, Optional
+
+import httpx
+import typer
+
+from . import local
+
+app = typer.Typer(add_completion=False, help="ShappeTrack CLI — one app token, git-powered. The engine stays invisible.")
+
+# Point the CLI at the ShappeTrack APP. You log in with ONE app token (made in the
+# web app: Settings → Access Tokens). The app bridges it to git access on the engine,
+# so you never touch the engine directly.
+DEFAULT_SERVER = "http://127.0.0.1:8000"
+
+
+# ---------- helpers ----------
+def _fail(msg: str):
+    typer.secho(f"error: {msg}", fg=typer.colors.RED)
+    raise typer.Exit(code=1)
+
+
+def _creds() -> dict:
+    c = local.load_credentials()
+    if not c or not c.get("token"):
+        _fail("not logged in. Run `shapetrack login` first.")
+    return c
+
+
+def _save_creds(server: str, token: str, username: str):
+    """Store ONLY the public app URL + the user's app token. The engine URL/token
+    are never handed to the client anymore — git auths to the public proxy with the
+    app token, and the proxy swaps in the engine token server-side."""
+    local.CRED_PATH.parent.mkdir(parents=True, exist_ok=True)
+    local.CRED_PATH.write_text(json.dumps({
+        "server_url": server.rstrip("/"),     # the ShappeTrack app (REST/chat + git proxy)
+        "token": token,                        # your app token (shp_…)
+        "username": username,
+    }, indent=2))
+
+
+def _host(server: str) -> str:
+    return server.split("://", 1)[-1].rstrip("/")
+
+
+def _clean_url(creds: dict, owner: str, name: str) -> str:
+    """Public, slug-based clone/push URL through the ShappeTrack proxy — the engine
+    host/owner never appear. Auth comes from the git credential store (set at login).
+    `name` is the repo slug; owner is unused (the proxy resolves it internally)."""
+    return f"{creds['server_url'].rstrip('/')}/repos/{name}"
+
+
+def _setup_git_credentials(server_url: str, app_token: str, username: str):
+    """Teach git to authenticate to the ShappeTrack PUBLIC proxy using the user's
+    app token. After this, the IDE (native git), the terminal, and this CLI all
+    auth automatically — the engine is never contacted directly and the user never
+    handles the engine token. Scoped to the public host so other creds are untouched."""
+    from urllib.parse import urlsplit
+    parts = urlsplit(server_url)
+    scheme = parts.scheme or "https"
+    host = parts.netloc or _host(server_url)
+    subprocess.run(["git", "config", "--global", f"credential.{scheme}://{host}.helper", "store"],
+                   text=True, capture_output=True)
+    payload = (f"protocol={scheme}\nhost={host}\n"
+               f"username={username or 'shappetrack'}\npassword={app_token}\n\n")
+    subprocess.run(["git", "credential", "approve"], input=payload, text=True, capture_output=True)
+
+
+def _split_repo(repo: str, default_owner: str):
+    """'owner/name' -> (owner, name); 'name' -> (default_owner, name)."""
+    if "/" in repo:
+        owner, name = repo.split("/", 1)
+        return owner, name
+    return default_owner, repo
+
+
+def _git(*args: str, cwd: Optional[str] = None, check: bool = True) -> subprocess.CompletedProcess:
+    proc = subprocess.run(["git", *args], cwd=cwd, text=True, capture_output=True)
+    if check and proc.returncode != 0:
+        _fail((proc.stderr or proc.stdout or f"git {' '.join(args)} failed").strip())
+    return proc
+
+
+def _redact(url: str) -> str:
+    # hide the token when printing a remote URL
+    import re
+    return re.sub(r"://[^@/]+@", "://<token>@", url)
+
+
+# ---------- commands ----------
+@app.command()
+def login(server: str = typer.Option(DEFAULT_SERVER, help="ShappeTrack app URL"),
+          token: Optional[str] = typer.Option(None, "--token", help="Your ShappeTrack app token (shp_…)")):
+    """Log in with ONE ShappeTrack app token (made in the web app: Settings → Access Tokens).
+
+    The app bridges it to git access on the engine automatically — you never touch the engine."""
+    if not token:
+        token = typer.prompt("ShappeTrack app token (shp_…)", hide_input=True)
+    server = server.rstrip("/")
+    try:
+        r = httpx.post(f"{server}/api/v1/cli/bootstrap",
+                       headers={"Authorization": f"Bearer {token}"}, timeout=15)
+    except httpx.HTTPError as e:
+        _fail(f"could not reach ShappeTrack at {server} — {e}")
+    if r.status_code == 401:
+        _fail("login failed — invalid app token. Make one in the web app: Settings → Access Tokens.")
+    if r.status_code == 409:
+        _fail(r.json().get("detail", "git access not linked — log into the web app once, then retry."))
+    if r.status_code != 200:
+        _fail(f"login failed ({r.status_code}): {r.text[:200]}")
+    data = r.json()
+    username = data["username"]
+    _save_creds(server, token, username)
+    # git auths to the PUBLIC proxy with the app token; the engine stays invisible.
+    _setup_git_credentials(server, token, username)
+    typer.secho(f"Logged in as {username}", fg=typer.colors.GREEN)
+    typer.echo("git configured — the IDE, terminal, and CLI can now clone/push ShappeTrack repos.")
+
+
+@app.command()
+def whoami():
+    """Show the logged-in user."""
+    creds = _creds()
+    typer.echo(f"{creds.get('username')} @ {creds.get('server_url')}")
+
+
+@app.command()
+def logout():
+    """Forget stored credentials."""
+    if local.CRED_PATH.exists():
+        local.CRED_PATH.unlink()
+    typer.secho("Logged out.", fg=typer.colors.GREEN)
+
+
+@app.command("setup-git")
+def setup_git():
+    """(Re)configure git to authenticate to the engine — for the IDE / terminal git."""
+    creds = _creds()
+    _setup_git_credentials(creds["server_url"], creds["token"], creds["username"])
+    typer.secho(f"git configured for {creds['username']} (engine access bridged automatically).",
+                fg=typer.colors.GREEN)
+    typer.echo("Now the UniversalCode IDE can Clone/Push ShappeTrack repos with no token prompts.")
+
+
+@app.command()
+def clone(repo: str = typer.Argument(..., help="repo name, or owner/repo"),
+          directory: Optional[str] = typer.Argument(None)):
+    """Clone a ShapeTrack repository (real git clone under the hood)."""
+    creds = _creds()
+    owner, name = _split_repo(repo, creds["username"])
+    dest = directory or name
+    url = _clean_url(creds, owner, name)
+    typer.echo(f"Cloning {owner}/{name} …")
+    _git("clone", url, dest)
+    typer.secho(f"Cloned into {dest}", fg=typer.colors.GREEN)
+
+
+@app.command()
+def init(name: str,
+         private: bool = typer.Option(True, help="Create the repo as private"),
+         owner: Optional[str] = typer.Option(None, help="Org owner (defaults to you)")):
+    """Create a new ShapeTrack repository and link the current directory to it."""
+    creds = _creds()
+    # Create via the ShappeTrack APP API (not the engine) — the app owns repo
+    # creation and returns the slug; the engine stays invisible.
+    headers = {"Authorization": f"Bearer {creds['token']}"}
+    endpoint = f"{creds['server_url'].rstrip('/')}/api/v1/repositories"
+    r = httpx.post(endpoint, headers=headers,
+                   json={"name": name, "is_private": private}, timeout=20)
+    if r.status_code not in (200, 201):
+        _fail(f"could not create repo: {r.text[:200]}")
+    slug = (r.json() or {}).get("slug") or name
+
+    root = Path.cwd()
+    if not (root / ".git").exists():
+        _git("init", "-b", "main", cwd=str(root))
+    url = f"{creds['server_url'].rstrip('/')}/repos/{slug}"
+    # set or replace origin
+    if _git("remote", cwd=str(root)).stdout.find("origin") >= 0:
+        _git("remote", "set-url", "origin", url, cwd=str(root))
+    else:
+        _git("remote", "add", "origin", url, cwd=str(root))
+    typer.secho(f"Initialized '{owner}/{name}'. Remote 'origin' set ({_redact(url)}).", fg=typer.colors.GREEN)
+    typer.echo("Next: shapetrack add . && shapetrack commit -m \"#MT-100 first\" && shapetrack push")
+
+
+@app.command()
+def status():
+    """Show working-tree status (git status)."""
+    typer.echo(_git("status", "-sb").stdout.rstrip())
+
+
+@app.command()
+def add(paths: List[str] = typer.Argument(None, help="Files to stage, or '.' for all")):
+    """Stage files for the next commit (git add)."""
+    _git("add", *(paths or ["."]))
+    typer.secho("Staged.", fg=typer.colors.GREEN)
+
+
+@app.command()
+def commit(message: str = typer.Option(..., "-m", "--message"),
+           task: Optional[str] = typer.Option(None, "--task", help="Task id, e.g. MT-104 (added to the message)")):
+    """Commit staged changes (git commit). A --task id is appended as #MT-… for linking."""
+    msg = message
+    if task:
+        tag = task if task.startswith("#") else f"#{task}"
+        if tag not in msg:
+            msg = f"{msg} {tag}"
+    proc = _git("commit", "-m", msg, check=False)
+    out = (proc.stdout + proc.stderr).strip()
+    if proc.returncode != 0:
+        _fail(out or "nothing to commit.")
+    typer.secho(out, fg=typer.colors.GREEN)
+
+
+@app.command()
+def push(branch: Optional[str] = typer.Argument(None)):
+    """Push commits to the engine (git push)."""
+    cur = _git("rev-parse", "--abbrev-ref", "HEAD").stdout.strip()
+    target = branch or cur
+    proc = _git("push", "-u", "origin", target, check=False)
+    out = (proc.stdout + proc.stderr).strip()
+    if proc.returncode != 0:
+        _fail(_redact(out))
+    typer.secho(_redact(out) or f"Pushed {target}.", fg=typer.colors.GREEN)
+
+
+@app.command()
+def pull(branch: Optional[str] = typer.Argument(None)):
+    """Pull the latest from the engine (git pull)."""
+    proc = _git("pull", "origin", *( [branch] if branch else [] ), check=False)
+    out = (proc.stdout + proc.stderr).strip()
+    if proc.returncode != 0:
+        _fail(_redact(out))
+    typer.secho(_redact(out), fg=typer.colors.GREEN)
+
+
+@app.command()
+def branch(name: Optional[str] = typer.Argument(None, help="Create+switch to a branch; omit to list"),
+           switch: bool = typer.Option(True, help="Switch to the new branch")):
+    """Create a branch (or list branches)."""
+    if not name:
+        typer.echo(_git("branch", "--all").stdout.rstrip())
+        return
+    _git("checkout", "-b", name) if switch else _git("branch", name)
+    typer.secho(f"Branch '{name}'" + (" (switched)" if switch else ""), fg=typer.colors.GREEN)
+
+
+@app.command()
+def checkout(name: str):
+    """Switch branches (git checkout)."""
+    _git("checkout", name)
+    typer.secho(f"Switched to '{name}'.", fg=typer.colors.GREEN)
+
+
+if __name__ == "__main__":
+    app()

shappetrack-1.0.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: shappetrack
+Version: 1.0.0
+Summary: ShappeTrack CLI — clone, commit, and push ShappeTrack repositories with one app token. The git engine stays invisible.
+Project-URL: Homepage, https://track.shappe.ai
+Author: ShappeTrack
+License: Proprietary
+Keywords: cli,git,shappetrack,vcs
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.9
+Requires-Dist: httpx==0.26.0
+Requires-Dist: typer<1.0,>=0.12
+Description-Content-Type: text/markdown
+
+# ShappeTrack CLI
+
+Clone, commit, and push ShappeTrack repositories with **one app token**. Real
+`git` runs under the hood; the git engine is never exposed.
+
+```
+shappetrack login --server https://track-api.shappe.ai/api/v1
+shappetrack clone my-repo
+```
+
+## Install
+
+The CLI is a small Python package (`shappetrack-cli`). The recommended way is
+[`pipx`](https://pipx.pypa.io/), which installs it in an isolated environment so
+it never clashes with your other Python tools.
+
+### For end users (once published to PyPI)
+
+```bash
+pipx install shappetrack
+```
+
+### From source (internal / development)
+
+From the directory containing `pyproject.toml`:
+
+```bash
+pipx install .          # isolated, recommended
+# or
+pip install .           # into the current environment
+```
+
+Requires **Python 3.9+** and **git** on your PATH (the CLI runs real git under the hood).
+
+## Usage
+
+1. Create an app token in the web app: **Settings → Access Tokens** (starts with `shp_`).
+2. Log in once — this configures git credentials automatically:
+
+   ```bash
+   shappetrack login --server https://track-api.shappe.ai/api/v1
+   ```
+
+3. Then use the familiar commands (they run standard git underneath):
+
+   ```bash
+   shappetrack clone my-repo
+   shappetrack status
+   shappetrack add .
+   shappetrack commit -m "message" --task MT-101
+   shappetrack push
+   shappetrack pull
+   shappetrack branch feature-x
+   ```
+
+## How it works
+
+`shappetrack clone my-repo` runs `git clone https://track-api.shappe.ai/repos/my-repo`
+using the app token you logged in with. The backend proxies git traffic to the
+internal engine — you never see or handle the engine, its host, or its token.
+
+You can also clone with plain git directly (no CLI needed):
+
+```bash
+git clone https://track-api.shappe.ai/repos/my-repo
+# username: your ShappeTrack username, password: your shp_ app token
+```

shappetrack-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+shappetrack/README.md,sha256=6nasLIP4ZsJJ_kzwB2B1KBy8ub7qz_PkU6SNovHz-qw,1853
+shappetrack/RELEASING.md,sha256=FtUgoA8NmBbGRGUuCVGlNVHVZYQ9Qlp0XCVfZMumlkw,2655
+shappetrack/__init__.py,sha256=1Xgjp1irKJHStHO7QX8HbAPCVWV087Br3Tq4NtVRnI0,274
+shappetrack/__main__.py,sha256=tJk1nRDKqMbRPSvlCJrlQ96cDbV8GKgCBmZW63EH-58,70
+shappetrack/__pyinstaller_entry.py,sha256=clO1Qsh83eVRw4KkvPJWNbty-unLdT9r54lDsLvd4V4,352
+shappetrack/local.py,sha256=rrmNJJZMaE0OZL7zTqGL5QJtPIEP-enWJMyPrNLgf9Q,4136
+shappetrack/shapetrack.py,sha256=jDTZQhcN9BYdxQ_ApmMzZ--Wo-gwrsGAHdrHT_Fn7cI,11070
+shappetrack-1.0.0.dist-info/METADATA,sha256=2QNpIuFe05wYKgKDv3Sg887TSlXGWctmFq_BKqhS38M,2480
+shappetrack-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+shappetrack-1.0.0.dist-info/entry_points.txt,sha256=tEuHE3fitA1AIPHh6W7jzKfotIlHaBFDWL3R8o05ZsM,59
+shappetrack-1.0.0.dist-info/RECORD,,

shappetrack-1.0.0.dist-info/WHEEL

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

shappetrack-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+shappetrack = shappetrack.shapetrack:app