lark-cli 0.1.1__tar.gz

lark_cli-0.1.1/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: lark-cli
+Version: 0.1.1
+Summary: A tiny CLI that says Coming soon
+Author: Your Name
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# lark-cli
+
+Python wrapper for the official `larksuite/cli` release binary.
+
+## What it does
+
+- Resolves the latest GitHub release from `https://github.com/larksuite/cli`
+- Chooses the current platform asset automatically
+- Runs the extracted `lark-cli` binary
+- Passes all CLI arguments through unchanged
+
+## Usage
+
+```bash
+lark-cli <any-args>
+```
+
+Example:
+
+```bash
+lark-cli api list --page 1
+```
+
+## Local binary cache location
+
+- macOS/Linux: `~/.cache/lark-cli-python-wrapper/current/lark-cli`
+- Windows: `%LOCALAPPDATA%\lark-cli-python-wrapper\current\lark-cli.exe`
+
+Set `LARK_CLI_WRAPPER_HOME` to override this location.
+
+## Build & publish to PyPI
+
+```bash
+python3 -m pip install --upgrade build twine
+python3 -m build
+python3 -m twine check dist/*
+```
+
+Before upload, bump `version` in `pyproject.toml` (for example `0.1.1` -> `0.1.2`).
+
+> Do not upload with `dist/*` if old files still exist in `dist/`, otherwise PyPI may reject duplicates.
+
+Upload only the current version files explicitly:
+
+```bash
+python3 -m twine upload \
+  dist/lark_cli-0.1.1-py3-none-any.whl \
+  dist/lark-cli-0.1.1.tar.gz \
+  --verbose
+```

lark_cli-0.1.1/README.md

@@ -0,0 +1,50 @@
+# lark-cli
+
+Python wrapper for the official `larksuite/cli` release binary.
+
+## What it does
+
+- Resolves the latest GitHub release from `https://github.com/larksuite/cli`
+- Chooses the current platform asset automatically
+- Runs the extracted `lark-cli` binary
+- Passes all CLI arguments through unchanged
+
+## Usage
+
+```bash
+lark-cli <any-args>
+```
+
+Example:
+
+```bash
+lark-cli api list --page 1
+```
+
+## Local binary cache location
+
+- macOS/Linux: `~/.cache/lark-cli-python-wrapper/current/lark-cli`
+- Windows: `%LOCALAPPDATA%\lark-cli-python-wrapper\current\lark-cli.exe`
+
+Set `LARK_CLI_WRAPPER_HOME` to override this location.
+
+## Build & publish to PyPI
+
+```bash
+python3 -m pip install --upgrade build twine
+python3 -m build
+python3 -m twine check dist/*
+```
+
+Before upload, bump `version` in `pyproject.toml` (for example `0.1.1` -> `0.1.2`).
+
+> Do not upload with `dist/*` if old files still exist in `dist/`, otherwise PyPI may reject duplicates.
+
+Upload only the current version files explicitly:
+
+```bash
+python3 -m twine upload \
+  dist/lark_cli-0.1.1-py3-none-any.whl \
+  dist/lark-cli-0.1.1.tar.gz \
+  --verbose
+```

lark_cli-0.1.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lark-cli"
+version = "0.1.1"
+description = "A tiny CLI that says Coming soon"
+readme = "README.md"
+requires-python = ">=3.7"
+authors = [
+  { name = "Your Name" }
+]
+
+[project.scripts]
+lark-cli = "lark_cli.cli:main"
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

lark_cli-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lark_cli-0.1.1/setup.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+import sys
+
+from setuptools import setup
+from setuptools.command.develop import develop
+from setuptools.command.install import install
+
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+SRC_DIR = PROJECT_ROOT / "src"
+sys.path.insert(0, str(SRC_DIR))
+
+
+class InstallWithBinary(install):
+    def run(self):
+        super().run()
+        from lark_cli.install_hooks import download_release_during_install
+
+        download_release_during_install()
+
+
+class DevelopWithBinary(develop):
+    def run(self):
+        super().run()
+        from lark_cli.install_hooks import download_release_during_install
+
+        download_release_during_install()
+
+
+setup(
+    cmdclass={
+        "install": InstallWithBinary,
+        "develop": DevelopWithBinary,
+    }
+)

lark_cli-0.1.1/src/lark_cli/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["main"]
+
+from .cli import main

lark_cli-0.1.1/src/lark_cli/cli.py

@@ -0,0 +1,10 @@
+import subprocess
+import sys
+
+from .release import ensure_installed_binary
+
+
+def main() -> None:
+    binary_path = ensure_installed_binary()
+    result = subprocess.run([binary_path, *sys.argv[1:]])
+    raise SystemExit(result.returncode)

lark_cli-0.1.1/src/lark_cli/install_hooks.py

@@ -0,0 +1,5 @@
+from .release import ensure_installed_binary
+
+
+def download_release_during_install() -> None:
+    ensure_installed_binary()

lark_cli-0.1.1/src/lark_cli/release.py

@@ -0,0 +1,146 @@
+import json
+import os
+import shutil
+import tarfile
+import tempfile
+import time
+import urllib.request
+import zipfile
+from pathlib import Path
+from platform import machine, system
+from stat import S_IXGRP, S_IXOTH, S_IXUSR
+from typing import Dict, Iterable, Tuple
+
+
+LATEST_RELEASE_API = "https://api.github.com/repos/larksuite/cli/releases/latest"
+
+
+def normalize_platform(raw_system: str, raw_machine: str) -> Tuple[str, str, str]:
+    os_name = raw_system.lower()
+    if os_name not in {"darwin", "linux", "windows"}:
+        raise RuntimeError(f"Unsupported OS: {raw_system}")
+
+    normalized_machine = raw_machine.lower()
+    if normalized_machine in {"x86_64", "amd64"}:
+        arch = "amd64"
+    elif normalized_machine in {"arm64", "aarch64"}:
+        arch = "arm64"
+    else:
+        raise RuntimeError(f"Unsupported architecture: {raw_machine}")
+
+    extension = ".zip" if os_name == "windows" else ".tar.gz"
+    return os_name, arch, extension
+
+
+def choose_asset(assets: Iterable[Dict[str, str]], os_name: str, arch: str, extension: str) -> Dict[str, str]:
+    target_suffix = f"-{os_name}-{arch}{extension}"
+    for asset in assets:
+        name = asset.get("name", "")
+        if name.startswith("lark-cli-") and name.endswith(target_suffix):
+            return asset
+    raise RuntimeError(f"No matching release asset for {os_name}/{arch}{extension}")
+
+
+def _fetch_latest_release() -> Dict[str, object]:
+    request = urllib.request.Request(
+        LATEST_RELEASE_API,
+        headers={"Accept": "application/vnd.github+json"},
+    )
+    with urllib.request.urlopen(request, timeout=20) as response:
+        payload = json.loads(response.read().decode("utf-8"))
+    return payload
+
+
+def _default_install_root() -> Path:
+    custom_root = os.environ.get("LARK_CLI_WRAPPER_HOME")
+    if custom_root:
+        return Path(custom_root)
+
+    home = Path.home()
+    if os.name == "nt":
+        base = Path(os.environ.get("LOCALAPPDATA", home))
+    else:
+        base = Path(os.environ.get("XDG_CACHE_HOME", home / ".cache"))
+    return base / "lark-cli-python-wrapper"
+
+
+def _find_binary(extracted_dir: Path, binary_name: str) -> Path:
+    for root, _, files in os.walk(extracted_dir):
+        if binary_name in files:
+            return Path(root) / binary_name
+    raise RuntimeError(f"Binary '{binary_name}' not found in extracted release archive")
+
+
+def _extract_archive(archive_path: Path, destination: Path) -> None:
+    if archive_path.name.endswith(".tar.gz"):
+        with tarfile.open(archive_path, mode="r:gz") as tar:
+            tar.extractall(destination)
+        return
+
+    if archive_path.name.endswith(".zip"):
+        with zipfile.ZipFile(archive_path, mode="r") as archive:
+            archive.extractall(destination)
+        return
+
+    raise RuntimeError(f"Unsupported archive format: {archive_path.name}")
+
+
+def _download_file(url: str, destination: Path) -> None:
+    request = urllib.request.Request(
+        url,
+        headers={
+            "Accept": "application/octet-stream",
+            "User-Agent": "lark-cli-python-wrapper",
+        },
+    )
+
+    last_error = None
+    for _ in range(3):
+        try:
+            with urllib.request.urlopen(request, timeout=60) as response, destination.open("wb") as file_obj:
+                shutil.copyfileobj(response, file_obj)
+            return
+        except Exception as error:  # noqa: BLE001
+            last_error = error
+            time.sleep(1)
+
+    if last_error is not None:
+        raise last_error
+
+
+def ensure_installed_binary(force: bool = False) -> str:
+    os_name, arch, extension = normalize_platform(system(), machine())
+    binary_name = "lark-cli.exe" if os_name == "windows" else "lark-cli"
+
+    install_root = _default_install_root()
+    target_dir = install_root / "current"
+    binary_path = target_dir / binary_name
+
+    if binary_path.exists() and not force:
+        return str(binary_path)
+
+    release = _fetch_latest_release()
+    assets = release.get("assets", [])
+    if not isinstance(assets, list):
+        raise RuntimeError("Release payload missing assets list")
+    selected_asset = choose_asset(assets, os_name, arch, extension)
+
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+        archive_path = temp_path / selected_asset["name"]
+        _download_file(selected_asset["browser_download_url"], archive_path)
+
+        extract_dir = temp_path / "extract"
+        extract_dir.mkdir(parents=True, exist_ok=True)
+        _extract_archive(archive_path, extract_dir)
+        extracted_binary = _find_binary(extract_dir, binary_name)
+
+        shutil.copy2(extracted_binary, binary_path)
+
+    if os_name != "windows":
+        current_mode = binary_path.stat().st_mode
+        binary_path.chmod(current_mode | S_IXUSR | S_IXGRP | S_IXOTH)
+
+    return str(binary_path)

lark_cli-0.1.1/src/lark_cli.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: lark-cli
+Version: 0.1.1
+Summary: A tiny CLI that says Coming soon
+Author: Your Name
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# lark-cli
+
+Python wrapper for the official `larksuite/cli` release binary.
+
+## What it does
+
+- Resolves the latest GitHub release from `https://github.com/larksuite/cli`
+- Chooses the current platform asset automatically
+- Runs the extracted `lark-cli` binary
+- Passes all CLI arguments through unchanged
+
+## Usage
+
+```bash
+lark-cli <any-args>
+```
+
+Example:
+
+```bash
+lark-cli api list --page 1
+```
+
+## Local binary cache location
+
+- macOS/Linux: `~/.cache/lark-cli-python-wrapper/current/lark-cli`
+- Windows: `%LOCALAPPDATA%\lark-cli-python-wrapper\current\lark-cli.exe`
+
+Set `LARK_CLI_WRAPPER_HOME` to override this location.
+
+## Build & publish to PyPI
+
+```bash
+python3 -m pip install --upgrade build twine
+python3 -m build
+python3 -m twine check dist/*
+```
+
+Before upload, bump `version` in `pyproject.toml` (for example `0.1.1` -> `0.1.2`).
+
+> Do not upload with `dist/*` if old files still exist in `dist/`, otherwise PyPI may reject duplicates.
+
+Upload only the current version files explicitly:
+
+```bash
+python3 -m twine upload \
+  dist/lark_cli-0.1.1-py3-none-any.whl \
+  dist/lark-cli-0.1.1.tar.gz \
+  --verbose
+```

lark_cli-0.1.1/src/lark_cli.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+setup.py
+src/lark_cli/__init__.py
+src/lark_cli/cli.py
+src/lark_cli/install_hooks.py
+src/lark_cli/release.py
+src/lark_cli.egg-info/PKG-INFO
+src/lark_cli.egg-info/SOURCES.txt
+src/lark_cli.egg-info/dependency_links.txt
+src/lark_cli.egg-info/entry_points.txt
+src/lark_cli.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_install_hooks.py
+tests/test_release.py

lark_cli-0.1.1/src/lark_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lark_cli-0.1.1/src/lark_cli.egg-info/entry_points.txt

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

lark_cli-0.1.1/src/lark_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+lark_cli

lark_cli-0.1.1/tests/test_cli.py

@@ -0,0 +1,27 @@
+import pytest
+
+from lark_cli import cli
+
+
+def test_main_forwards_all_args_to_downloaded_binary(monkeypatch):
+    captured = {}
+
+    def fake_ensure_installed_binary():
+        return "/tmp/lark-cli"
+
+    class Result:
+        returncode = 7
+
+    def fake_run(cmd):
+        captured["cmd"] = cmd
+        return Result()
+
+    monkeypatch.setattr(cli, "ensure_installed_binary", fake_ensure_installed_binary)
+    monkeypatch.setattr(cli.subprocess, "run", fake_run)
+    monkeypatch.setattr(cli.sys, "argv", ["lark-cli", "im", "send", "--text", "hello"])
+
+    with pytest.raises(SystemExit) as raised:
+        cli.main()
+
+    assert raised.value.code == 7
+    assert captured["cmd"] == ["/tmp/lark-cli", "im", "send", "--text", "hello"]

lark_cli-0.1.1/tests/test_install_hooks.py

@@ -0,0 +1,13 @@
+from lark_cli import install_hooks
+
+
+def test_install_hook_triggers_download(monkeypatch):
+    called = {"value": False}
+
+    def fake_download():
+        called["value"] = True
+
+    monkeypatch.setattr(install_hooks, "ensure_installed_binary", fake_download)
+    install_hooks.download_release_during_install()
+
+    assert called["value"] is True

lark_cli-0.1.1/tests/test_release.py

@@ -0,0 +1,38 @@
+from lark_cli.release import choose_asset, normalize_platform
+from lark_cli import release
+
+
+def test_normalize_platform_for_macos_arm64():
+    os_name, arch, ext = normalize_platform("Darwin", "arm64")
+    assert os_name == "darwin"
+    assert arch == "arm64"
+    assert ext == ".tar.gz"
+
+
+def test_choose_asset_for_linux_amd64():
+    assets = [
+        {"name": "lark-cli-1.0.0-darwin-arm64.tar.gz", "browser_download_url": "a"},
+        {"name": "lark-cli-1.0.0-linux-amd64.tar.gz", "browser_download_url": "b"},
+    ]
+
+    selected = choose_asset(assets, "linux", "amd64", ".tar.gz")
+    assert selected["browser_download_url"] == "b"
+
+
+def test_ensure_binary_uses_cached_file_without_network(monkeypatch, tmpdir):
+    root = tmpdir.mkdir("wrapper-home")
+    current_dir = root.mkdir("current")
+    binary_path = current_dir.join("lark-cli")
+    binary_path.write("#!/bin/sh\n")
+
+    monkeypatch.setenv("LARK_CLI_WRAPPER_HOME", str(root))
+    monkeypatch.setattr(release, "system", lambda: "Darwin")
+    monkeypatch.setattr(release, "machine", lambda: "arm64")
+
+    def fail_fetch():
+        raise AssertionError("network should not be called when cached binary exists")
+
+    monkeypatch.setattr(release, "_fetch_latest_release", fail_fetch)
+
+    resolved = release.ensure_installed_binary()
+    assert resolved == str(binary_path)