typst-pkg-sync 0.2.0__tar.gz → 0.2.1__tar.gz

{typst_pkg_sync-0.2.0 → typst_pkg_sync-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: typst-pkg-sync
-Version: 0.2.0
+Version: 0.2.1
 Summary: Sync tagged Typst packages from GitHub, GitLab, and Codeberg
 Author: Jan-Philipp Reßler
 License-Expression: MIT

{typst_pkg_sync-0.2.0 → typst_pkg_sync-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "typst-pkg-sync"
-version = "0.2.0"
+version = "0.2.1"
 requires-python = ">=3.14"
 description = "Sync tagged Typst packages from GitHub, GitLab, and Codeberg"
 readme = "README.md"

{typst_pkg_sync-0.2.0 → typst_pkg_sync-0.2.1}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "typst-pkg-sync"
-version = "0.2.0"
+version = "0.2.1"
 requires-python = ">=3.14"
 description = "Sync tagged Typst packages from GitHub, GitLab, and Codeberg"
 readme = "README.md"

{typst_pkg_sync-0.2.0 → typst_pkg_sync-0.2.1}/src/typst_pkg_sync/cli.py

@@ -1,5 +1,5 @@
 """
-typst-pkg-sync — Local Package Manager for Typst
+typst-pkg-sync - Local Package Manager for Typst
 
 Downloads tagged source files from GitHub, GitLab, and Codeberg
 and installs them into the local Typst package directory structure:
@@ -17,6 +17,7 @@ No third-party dependencies.
 import argparse
 import http.client
 import json
+import logging
 import os
 import re
 import shutil
@@ -29,6 +30,7 @@ import urllib.parse
 import urllib.request
 import zipfile
 from pathlib import Path
+from typing import ClassVar
 
 # ---------------------------------------------------------------------------
 # Constants
@@ -71,7 +73,7 @@ PLATFORMS = {
 }
 
 DEFAULT_CONFIG = """\
-# typst-pkg-sync — Local Package Manager for Typst
+# typst-pkg-sync - Local Package Manager for Typst
 #
 # Packages are installed to:
 #   <base_dir>/<namespace>/<package-name>/<version>/
@@ -109,21 +111,30 @@ tags = "all"
 # Logging
 # ---------------------------------------------------------------------------
 
+_LOGGER = logging.getLogger(__name__)
 
-def log_info(msg: str) -> None:
-    print(f"\033[32m[INFO]\033[0m  {msg}")
 
+class _ColorFormatter(logging.Formatter):
+    FORMATS: ClassVar[dict[int, tuple[str, str, str]]] = {
+        logging.DEBUG: ("\033[34m", "DEBUG", " "),
+        logging.INFO: ("\033[32m", "INFO", "  "),
+        logging.WARNING: ("\033[33m", "WARN", "  "),
+        logging.ERROR: ("\033[31m", "ERROR", " "),
+    }
 
-def log_warn(msg: str) -> None:
-    print(f"\033[33m[WARN]\033[0m  {msg}")
+    def format(self, record: logging.LogRecord) -> str:
+        color, level, padding = self.FORMATS.get(record.levelno, ("", record.levelname, " "))
+        reset = "\033[0m" if color else ""
+        return f"{color}[{level}]{reset}{padding}{record.getMessage()}"
 
 
-def log_error(msg: str) -> None:
-    print(f"\033[31m[ERROR]\033[0m {msg}")
-
-
-def log_debug(msg: str) -> None:
-    print(f"\033[34m[DEBUG]\033[0m {msg}")
+def configure_logging(verbose: bool = True) -> None:
+    """Configure colored console logging at the requested verbosity."""
+    _LOGGER.setLevel(logging.DEBUG if verbose else logging.INFO)
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(_ColorFormatter())
+    _LOGGER.addHandler(handler)
+    _LOGGER.propagate = False
 
 
 # ---------------------------------------------------------------------------
@@ -158,18 +169,20 @@ def validate_tags(tags: object, repo: str) -> list[str] | str:
     if isinstance(tags, str):
         if tags == "all":
             return "all"
-        log_error(f'[{repo}] tags must be an array of versions or the string "all", got: "{tags}"')
+        _LOGGER.error(
+            f'[{repo}] tags must be an array of versions or the string "all", got: "{tags}"'
+        )
         sys.exit(1)
 
     if isinstance(tags, list):
         if not tags:
-            log_error(f"[{repo}] tags array is empty")
+            _LOGGER.error(f"[{repo}] tags array is empty")
             sys.exit(1)
         normalized = []
         for t in tags:
             version = normalize_tag(t) if isinstance(t, str) else None
             if version is None:
-                log_error(
+                _LOGGER.error(
                     f"[{repo}] invalid tag {t!r}: tags must consist of an "
                     f"optional 'v' prefix followed by digits and dots "
                     f'(e.g. "0.2.0" or "v1.0.0")'
@@ -178,7 +191,7 @@ def validate_tags(tags: object, repo: str) -> list[str] | str:
             normalized.append(version)
         return normalized
 
-    log_error(f'[{repo}] tags must be an array of versions or "all"')
+    _LOGGER.error(f'[{repo}] tags must be an array of versions or "all"')
     sys.exit(1)
 
 
@@ -196,12 +209,12 @@ def filter_remote_tags(raw_tags: list[str], owner: str, repo: str) -> list[str]:
     for raw in raw_tags:
         version = normalize_tag(raw)
         if version is None:
-            log_warn(f"[{owner}/{repo}] skipping non-version tag: {raw!r}")
+            _LOGGER.warning(f"[{owner}/{repo}] skipping non-version tag: {raw!r}")
             continue
         if version in seen:
-            log_warn(
+            _LOGGER.warning(
                 f"[{owner}/{repo}] tag {raw!r} maps to version {version!r}, "
-                f"which was already seen — skipping duplicate"
+                f"which was already seen - skipping duplicate"
             )
             continue
         seen.add(version)
@@ -218,8 +231,8 @@ def filter_remote_tags(raw_tags: list[str], owner: str, repo: str) -> list[str]:
 def create_default_config(config_file: Path) -> None:
     config_file.parent.mkdir(parents=True, exist_ok=True)
     config_file.write_text(DEFAULT_CONFIG)
-    log_info(f"Created default config at {config_file}")
-    log_info("Edit it to add your repositories, then re-run.")
+    _LOGGER.info(f"Created default config at {config_file}")
+    _LOGGER.info("Edit it to add your repositories, then re-run.")
     sys.exit(0)
 
 
@@ -230,7 +243,7 @@ def load_config(config_file: Path = CONFIG_FILE) -> dict:
         with open(config_file, "rb") as f:
             return tomllib.load(f)
     except tomllib.TOMLDecodeError as e:
-        log_error(f"Invalid TOML in {config_file}: {e}")
+        _LOGGER.error(f"Invalid TOML in {config_file}: {e}")
         sys.exit(1)
 
 
@@ -241,23 +254,23 @@ def resolve_platform_config(platform: str, repo_cfg: dict) -> dict | None:
 
     token_env = repo_cfg.get("token_env", plat["auth_env"])
     if not isinstance(token_env, str) or not token_env:
-        log_error(f"Invalid token_env for repository '{repo_cfg.get('repo', '')}'")
+        _LOGGER.error(f"Invalid token_env for repository '{repo_cfg.get('repo', '')}'")
         return None
     plat["auth_env"] = token_env
 
     if "base_url" in repo_cfg:
         if platform != "gitlab":
-            log_error("The 'base_url' option is only supported for GitLab repositories")
+            _LOGGER.error("The 'base_url' option is only supported for GitLab repositories")
             return None
         base_url = repo_cfg["base_url"]
         if not isinstance(base_url, str) or not base_url or base_url != base_url.strip():
-            log_error(f"Invalid GitLab base_url: {base_url!r}")
+            _LOGGER.error(f"Invalid GitLab base_url: {base_url!r}")
             return None
         try:
             parsed = urllib.parse.urlsplit(base_url)
             _ = parsed.port
         except ValueError:
-            log_error(f"Invalid GitLab base_url: {base_url!r}")
+            _LOGGER.error(f"Invalid GitLab base_url: {base_url!r}")
             return None
         if (
             parsed.scheme not in {"http", "https"}
@@ -267,7 +280,7 @@ def resolve_platform_config(platform: str, repo_cfg: dict) -> dict | None:
             or parsed.query
             or parsed.fragment
         ):
-            log_error(f"Invalid GitLab base_url: {base_url!r}")
+            _LOGGER.error(f"Invalid GitLab base_url: {base_url!r}")
             return None
         plat["base_url"] = base_url.rstrip("/")
 
@@ -302,8 +315,8 @@ def fetch_tags(plat: dict, owner: str, repo: str) -> list[str]:
     try:
         data = json.loads(make_request(url, plat))
         return [tag["name"] for tag in data]
-    except (http.client.HTTPException, OSError, ValueError, KeyError, TypeError) as e:
-        log_warn(f"Could not fetch tags for {owner}/{repo}: {e}")
+    except (http.client.HTTPException, OSError, ValueError, TypeError) as e:
+        _LOGGER.warning(f"Could not fetch tags for {owner}/{repo}: {e}")
         return []
 
 
@@ -352,7 +365,7 @@ def read_package_name(package_dir: Path) -> str | None:
         name = data.get("package", {}).get("name")
         return name if isinstance(name, str) and name else None
     except (tomllib.TOMLDecodeError, OSError) as e:
-        log_warn(f"Could not parse typst.toml: {e}")
+        _LOGGER.warning(f"Could not parse typst.toml: {e}")
         return None
 
 
@@ -373,7 +386,7 @@ def download_and_install(
     """
     Download one tag of one repository and install it.
 
-    'tag' must already be normalized (no 'v' prefix) — it is used both
+    'tag' must already be normalized (no 'v' prefix) - it is used both
     to build the archive URL (with prefix re-added if the remote uses
     one) and as the version directory name.
 
@@ -401,22 +414,22 @@ def download_and_install(
             tag=urllib.parse.quote(candidate, safe=""),
         )
         try:
-            log_info(f"⬇  Downloading {owner}/{repo}@{candidate} from {platform}...")
+            _LOGGER.info(f"Downloading {owner}/{repo}@{candidate} from {platform}...")
             archive_bytes = make_request(url, plat)
             used_tag = candidate
             break
         except urllib.error.HTTPError as e:
             if e.code == 404 and candidate != candidates[-1]:
-                log_debug(f"Tag '{candidate}' not found, trying next candidate...")
+                _LOGGER.debug(f"Tag '{candidate}' not found, trying next candidate...")
                 continue
-            log_error(f"HTTP {e.code} for {url}")
+            _LOGGER.error(f"HTTP {e.code} for {url}")
             return False
-        except (http.client.HTTPException, OSError, ValueError) as e:
-            log_error(f"Download failed for {owner}/{repo}@{candidate}: {e}")
+        except (http.client.HTTPException, OSError) as e:
+            _LOGGER.error(f"Download failed for {owner}/{repo}@{candidate}: {e}")
             return False
 
     if archive_bytes is None or used_tag is None:
-        log_error(f"Could not download {owner}/{repo}@{tag}")
+        _LOGGER.error(f"Could not download {owner}/{repo}@{tag}")
         return False
 
     # Extract to a staging dir first so we can read typst.toml
@@ -426,35 +439,30 @@ def download_and_install(
 
         try:
             extract_archive(archive_bytes, staging, plat["archive_format"])
-        except (
-            tarfile.TarError,
-            zipfile.BadZipFile,
-            OSError,
-            EOFError,
-        ) as e:
-            log_error(f"Extraction failed for {owner}/{repo}@{used_tag}: {e}")
+        except (tarfile.TarError, zipfile.BadZipFile, EOFError) as e:
+            _LOGGER.error(f"Extraction failed for {owner}/{repo}@{used_tag}: {e}")
             return False
 
         # Read the package name from typst.toml
         package_name = read_package_name(staging)
         if package_name is None:
-            log_error(
+            _LOGGER.error(
                 f"No valid typst.toml with [package] name found in "
-                f"{owner}/{repo}@{used_tag} — cannot determine package name"
+                f"{owner}/{repo}@{used_tag} - cannot determine package name"
             )
             return False
 
         if package_name != repo:
-            log_debug(f"Package name '{package_name}' differs from repo '{repo}'")
+            _LOGGER.debug(f"Package name '{package_name}' differs from repo '{repo}'")
 
         # Final destination: normalized tag (no 'v' prefix) as version dir
         dest = base_dir / namespace / package_name / tag
 
         if dest.exists():
             if skip_existing:
-                log_warn(f"⊘ Already exists: {dest}")
+                _LOGGER.warning(f"Already exists: {dest}")
                 return True
-            log_warn(f"Overwriting existing: {dest}")
+            _LOGGER.warning(f"Overwriting existing: {dest}")
             shutil.rmtree(dest)
 
         dest.mkdir(parents=True, exist_ok=True)
@@ -463,11 +471,11 @@ def download_and_install(
             for item in staging.iterdir():
                 shutil.move(str(item), str(dest / item.name))
         except OSError as e:
-            log_error(f"Install failed: {e}")
+            _LOGGER.error(f"Install failed: {e}")
             shutil.rmtree(dest, ignore_errors=True)
             return False
 
-    log_info(f"✅ Installed {package_name}@{tag} → {dest}")
+    _LOGGER.info(f"Installed {package_name}@{tag} -> {dest}")
     return True
 
 
@@ -483,10 +491,10 @@ def sync_repository(repo_cfg: dict, settings: dict) -> bool:
     raw_tags = repo_cfg.get("tags")
 
     if platform not in PLATFORMS:
-        log_error(f"Unknown platform '{platform}' for repo '{repo}'")
+        _LOGGER.error(f"Unknown platform '{platform}' for repo '{repo}'")
         return False
     if not owner or not repo:
-        log_error(f"Missing 'owner' or 'repo' in config entry: {repo_cfg}")
+        _LOGGER.error(f"Missing 'owner' or 'repo' in config entry: {repo_cfg}")
         return False
 
     plat = resolve_platform_config(platform, repo_cfg)
@@ -499,13 +507,13 @@ def sync_repository(repo_cfg: dict, settings: dict) -> bool:
     if tags == "all":
         raw_remote = fetch_tags(plat, owner, repo)
         if not raw_remote:
-            log_error(f"No tags found for {owner}/{repo}")
+            _LOGGER.error(f"No tags found for {owner}/{repo}")
             return False
         tags = filter_remote_tags(raw_remote, owner, repo)
         if not tags:
-            log_error(f"No tags matching the version pattern found for {owner}/{repo}")
+            _LOGGER.error(f"No tags matching the version pattern found for {owner}/{repo}")
             return False
-        log_info(f'[{owner}/{repo}] tags = "all" → {len(tags)} version(s): {tags}')
+        _LOGGER.info(f'[{owner}/{repo}] tags = "all" -> {len(tags)} version(s): {tags}')
 
     base_dir = Path(settings.get("base_dir", str(DEFAULT_BASE_DIR))).expanduser()
     namespace = settings.get("namespace", "preview")
@@ -516,11 +524,13 @@ def sync_repository(repo_cfg: dict, settings: dict) -> bool:
         if download_and_install(plat, owner, repo, tag, base_dir, namespace, skip_existing):
             ok += 1
 
-    log_info(f"── {owner}/{repo}: {ok}/{len(tags)} version(s) synced")
+    _LOGGER.info(f"-- {owner}/{repo}: {ok}/{len(tags)} version(s) synced")
     return ok == len(tags)
 
 
 def main(argv: list[str] | None = None) -> None:
+    configure_logging()
+
     parser = argparse.ArgumentParser(description="Sync Typst packages from Git repositories")
     parser.add_argument(
         "--config",
@@ -533,31 +543,35 @@ def main(argv: list[str] | None = None) -> None:
 
     config = load_config(config_file)
     settings = config.get("settings", {})
+    verbose = settings.get("verbose", True)
+    if not isinstance(verbose, bool):
+        _LOGGER.error("Invalid 'verbose' setting: expected a boolean")
+        sys.exit(1)
+    configure_logging(verbose)
+
     repos = config.get("repositories", [])
 
     if not repos:
-        log_warn("No [[repositories]] defined in config.")
-        log_info(f"Edit {config_file} to add some.")
+        _LOGGER.warning("No [[repositories]] defined in config.")
+        _LOGGER.info(f"Edit {config_file} to add some.")
         sys.exit(0)
 
     namespace = settings.get("namespace", "preview")
     base_dir = Path(settings.get("base_dir", str(DEFAULT_BASE_DIR))).expanduser()
 
-    log_info("📦 typst-pkg-sync — Typst Package Sync")
-    log_info(f"📁 Base:      {base_dir}")
-    log_info(f"🏷  Namespace: {namespace}")
-    print()
+    _LOGGER.info("typst-pkg-sync - Typst Package Sync")
+    _LOGGER.info(f"Base:      {base_dir}")
+    _LOGGER.info(f"Namespace: {namespace}")
 
     failures = 0
     for repo_cfg in repos:
         if not sync_repository(repo_cfg, settings):
             failures += 1
 
-    print()
     if failures:
-        log_error(f"{failures} repository(ies) had errors")
+        _LOGGER.error(f"{failures} repository(ies) had errors")
         sys.exit(1)
-    log_info("🎉 All done!")
+    _LOGGER.info("All done!")
 
 
 if __name__ == "__main__":