ferp 0.7.1__py3-none-any.whl

ferp/services/monday_sync.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+from urllib.request import Request, urlopen
+
+MONDAY_REQUIRED_COLUMNS = (
+    "Publisher",
+    "Territory",
+    "Control Type",
+    "Effective Date",
+    "Expiration Date",
+    "Status",
+)
+MONDAY_SUBITEM_COLUMNS = (
+    "Effective Date",
+    "Territory",
+    "Status",
+)
+
+
+def sync_monday_board(
+    api_token: str, board_id: int, cache_path: Path
+) -> dict[str, object]:
+    query = """
+    query ($boardId: [ID!], $cursor: String) {
+      boards(ids: $boardId) {
+        name
+        groups { id title }
+        items_page(limit: 500, cursor: $cursor) {
+          cursor
+          items {
+            id
+            name
+            group { id }
+            column_values { text column { title } }
+            subitems {
+              name
+              column_values { text column { title } }
+            }
+          }
+        }
+      }
+    }
+    """
+    headers = {
+        "Authorization": api_token,
+        "Content-Type": "application/json",
+    }
+
+    def fetch_page(cursor: str | None) -> dict[str, Any]:
+        payload = json.dumps(
+            {
+                "query": query,
+                "variables": {"boardId": [board_id], "cursor": cursor},
+            }
+        ).encode("utf-8")
+        request = Request("https://api.monday.com/v2", data=payload, headers=headers)
+        with urlopen(request, timeout=30) as response:
+            body = json.loads(response.read().decode("utf-8"))
+        if "errors" in body:
+            messages = "; ".join(
+                error.get("message", "Unknown error") for error in body["errors"]
+            )
+            raise RuntimeError(f"Monday API error: {messages}")
+        return body.get("data", {})
+
+    data = fetch_page(None)
+    boards = data.get("boards") or []
+    if not boards:
+        raise RuntimeError("Monday board not found.")
+
+    board = boards[0]
+    group_map = {
+        group.get("id"): group.get("title")
+        for group in board.get("groups", [])
+        if group.get("id")
+    }
+
+    result: dict[str, list[dict[str, object]]] = {}
+    publisher_count = 0
+    skipped = 0
+
+    def build_col_map(column_values: list[dict[str, Any]]) -> dict[str, str]:
+        col_map: dict[str, str] = {}
+        for col in column_values:
+            column = col.get("column") or {}
+            title = column.get("title")
+            if not title:
+                continue
+            col_map[title] = col.get("text") or ""
+        return col_map
+
+    while True:
+        items_page = board.get("items_page") or {}
+        items = items_page.get("items") or []
+        for item in items:
+            column_values = item.get("column_values") or []
+            col_map = build_col_map(column_values)
+
+            if "Publisher" not in col_map:
+                col_map["Publisher"] = item.get("name") or ""
+            publisher = col_map.get("Publisher", "").strip()
+            if not publisher:
+                skipped += 1
+                continue
+
+            territory_mode = col_map.get("Territory", "").strip()
+            subitems = item.get("subitems") or []
+            subitem_rows: list[dict[str, str]] = []
+            if territory_mode in {"Multiple", "Split"}:
+                for subitem in subitems:
+                    subitem_values = subitem.get("column_values") or []
+                    sub_map = build_col_map(subitem_values)
+                    row_data = {
+                        name.lower(): sub_map.get(name, "")
+                        for name in MONDAY_SUBITEM_COLUMNS
+                    }
+                    row_data["territory_code"] = subitem.get("name") or ""
+                    subitem_rows.append(row_data)
+
+            group_info = item.get("group") or {}
+            group_name = group_map.get(group_info.get("id"), "Ungrouped")
+            group_key = group_name.lower()
+            group_bucket = result.setdefault(group_key, [])
+            row: dict[str, object] = {
+                name.lower(): col_map.get(name, "") for name in MONDAY_REQUIRED_COLUMNS
+            }
+            if territory_mode == "Multiple" and subitem_rows:
+                row["multi_territory"] = subitem_rows
+            elif territory_mode == "Split" and subitem_rows:
+                row["split_territory"] = subitem_rows
+            group_bucket.append(row)
+            publisher_count += 1
+
+        cursor = items_page.get("cursor")
+        if not cursor:
+            break
+        data = fetch_page(cursor)
+        boards = data.get("boards") or []
+        if not boards:
+            break
+        board = boards[0]
+
+    cache_path.parent.mkdir(parents=True, exist_ok=True)
+    cache_path.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
+
+    return {
+        "cache_path": str(cache_path),
+        "board_name": board.get("name", ""),
+        "group_count": len(result),
+        "publisher_count": publisher_count,
+        "skipped": skipped,
+    }

ferp/services/releases.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+import json
+import shutil
+import tempfile
+import zipfile
+from pathlib import Path
+
+import requests
+
+
+def update_scripts_from_release(
+    repo_url: str, scripts_dir: Path, *, dry_run: bool = False
+) -> str:
+    payload = _fetch_latest_release(repo_url)
+
+    zip_url = payload.get("zipball_url")
+    if not zip_url:
+        raise RuntimeError("Latest release is missing a zipball URL.")
+
+    tag_name = str(payload.get("tag_name") or "").strip()
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        tmp_path = Path(tmp_dir)
+        archive_path = tmp_path / "scripts.zip"
+        try:
+            response = requests.get(zip_url, headers=headers, timeout=60)
+            response.raise_for_status()
+            archive_path.write_bytes(response.content)
+        except requests.RequestException as exc:
+            raise RuntimeError("Failed to download release archive.") from exc
+
+        extract_dir = tmp_path / "extract"
+        try:
+            with zipfile.ZipFile(archive_path) as archive:
+                archive.extractall(extract_dir)
+        except zipfile.BadZipFile as exc:
+            raise RuntimeError("Release archive is not a valid zip file.") from exc
+
+        source_dir = _find_release_payload_dir(extract_dir)
+        if not dry_run:
+            _replace_scripts_payload(source_dir, scripts_dir)
+
+    return tag_name
+
+
+def fetch_namespace_index(repo_url: str) -> tuple[str, dict]:
+    payload = _fetch_latest_release(repo_url)
+    tag_name = str(payload.get("tag_name") or "").strip()
+    assets = _release_assets(payload)
+
+    index_url = assets.get("namespaces.json")
+    if not index_url:
+        raise RuntimeError("Latest release is missing namespaces.json.")
+
+    try:
+        response = requests.get(index_url, timeout=30)
+        response.raise_for_status()
+        index_payload = response.json()
+    except requests.RequestException as exc:
+        raise RuntimeError("Failed to download namespaces.json.") from exc
+    except json.JSONDecodeError as exc:
+        raise RuntimeError("namespaces.json is not valid JSON.") from exc
+
+    return tag_name, index_payload
+
+
+def update_scripts_from_namespace_release(
+    repo_url: str,
+    scripts_dir: Path,
+    *,
+    namespace: str,
+    dry_run: bool = False,
+) -> str:
+    tag_name, index_payload = fetch_namespace_index(repo_url)
+    namespaces = index_payload.get("namespaces", [])
+    if not isinstance(namespaces, list):
+        raise RuntimeError("namespaces.json is missing a namespaces list.")
+
+    def _find_asset_id(ns_id: str) -> str:
+        for entry in namespaces:
+            if not isinstance(entry, dict):
+                continue
+            if str(entry.get("id", "")).strip() == ns_id:
+                asset = str(entry.get("asset", "")).strip()
+                if asset:
+                    return asset
+        return ""
+
+    core_asset = _find_asset_id("core")
+    if not core_asset:
+        raise RuntimeError("namespaces.json does not include a core asset.")
+    namespace_asset = _find_asset_id(namespace)
+    if not namespace_asset:
+        raise RuntimeError(f"namespaces.json does not include '{namespace}'.")
+
+    payload = _fetch_latest_release(repo_url)
+    assets = _release_assets(payload)
+    core_url = assets.get(core_asset)
+    namespace_url = assets.get(namespace_asset)
+    if not core_url or not namespace_url:
+        raise RuntimeError("Release assets missing for selected namespace.")
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        tmp_path = Path(tmp_dir)
+        core_zip = tmp_path / core_asset
+        ns_zip = tmp_path / namespace_asset
+        _download_asset(core_url, core_zip)
+        _download_asset(namespace_url, ns_zip)
+
+        payload_dir = tmp_path / "payload"
+        payload_dir.mkdir(parents=True, exist_ok=True)
+
+        for archive_path in (core_zip, ns_zip):
+            try:
+                with zipfile.ZipFile(archive_path) as archive:
+                    archive.extractall(payload_dir)
+            except zipfile.BadZipFile as exc:
+                raise RuntimeError("Release asset is not a valid zip file.") from exc
+
+        if not dry_run:
+            _replace_scripts_payload(payload_dir, scripts_dir)
+
+    return tag_name
+
+
+def _fetch_latest_release(repo_url: str) -> dict:
+    owner, repo = _parse_github_repo(repo_url)
+    api_url = f"https://api.github.com/repos/{owner}/{repo}/releases/latest"
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "User-Agent": "ferp",
+    }
+
+    try:
+        response = requests.get(api_url, headers=headers, timeout=30)
+        response.raise_for_status()
+        payload = response.json()
+    except requests.RequestException as exc:
+        raise RuntimeError("Failed to fetch latest release metadata.") from exc
+    if not isinstance(payload, dict):
+        raise RuntimeError("Release metadata response is not valid JSON.")
+    return payload
+
+
+def _release_assets(payload: dict) -> dict[str, str]:
+    assets = payload.get("assets", [])
+    if not isinstance(assets, list):
+        return {}
+    results: dict[str, str] = {}
+    for asset in assets:
+        if not isinstance(asset, dict):
+            continue
+        name = str(asset.get("name") or "").strip()
+        url = str(asset.get("browser_download_url") or "").strip()
+        if name and url:
+            results[name] = url
+    return results
+
+
+def _download_asset(url: str, target: Path) -> None:
+    try:
+        response = requests.get(url, timeout=60)
+        response.raise_for_status()
+        target.write_bytes(response.content)
+    except requests.RequestException as exc:
+        raise RuntimeError(f"Failed to download asset from {url}.") from exc
+
+
+def _find_release_payload_dir(extract_dir: Path) -> Path:
+    root_dirs = [path for path in extract_dir.iterdir() if path.is_dir()]
+    if not root_dirs:
+        raise RuntimeError("Release archive did not contain any directories.")
+
+    if len(root_dirs) == 1:
+        root = root_dirs[0]
+        nested_scripts = root / "scripts"
+        if _payload_has_scripts(nested_scripts):
+            return nested_scripts
+        if _payload_has_scripts(root):
+            return root
+
+    for config_path in extract_dir.rglob("config.json"):
+        candidate = config_path.parent
+        if _payload_has_scripts(candidate):
+            return candidate
+        nested = candidate / "scripts"
+        if _payload_has_scripts(nested):
+            return nested
+
+    raise RuntimeError("Release archive did not include scripts payload.")
+
+
+def _payload_has_scripts(candidate: Path) -> bool:
+    if not candidate.exists() or not candidate.is_dir():
+        return False
+    return any(path.name == "script.py" for path in candidate.rglob("script.py"))
+
+
+def _parse_github_repo(repo_url: str) -> tuple[str, str]:
+    url = repo_url.strip().removesuffix(".git")
+    if "github.com/" not in url:
+        raise ValueError("Only GitHub URLs are supported for release updates.")
+    owner_repo = url.split("github.com/", 1)[1].strip("/")
+    parts = owner_repo.split("/")
+    if len(parts) != 2 or not all(parts):
+        raise ValueError("Invalid GitHub repository URL.")
+    return parts[0], parts[1]
+
+
+def _replace_scripts_payload(source_dir: Path, scripts_dir: Path) -> None:
+    if scripts_dir.exists():
+        shutil.rmtree(scripts_dir)
+    shutil.copytree(source_dir, scripts_dir, dirs_exist_ok=True)

ferp/services/scripts.py

@@ -0,0 +1,90 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from ferp.domain.scripts import Script
+
+
+@dataclass(frozen=True)
+class ScriptExecutionContext:
+    """Normalized FSCP execution details for a script."""
+
+    script: Script
+    script_path: Path
+    target_path: Path
+    target_kind: Literal["file", "directory"]
+
+
+def build_execution_context(
+    *,
+    app_root: Path,
+    current_path: Path,
+    selected_path: Path | None,
+    script: Script,
+) -> ScriptExecutionContext:
+    """Resolve script metadata into an execution context for the FSCP runner."""
+
+    full_path = (app_root / script.script).resolve()
+
+    if not full_path.exists():
+        raise FileNotFoundError(full_path)
+
+    if full_path.suffix != ".py":
+        raise ValueError(
+            f"FSCP scripts must be Python files. Unsupported script: {full_path}"
+        )
+
+    if script.target == "current_directory":
+        target_path = current_path
+    elif script.target in {"highlighted_file", "highlighted_directory"}:
+        if selected_path is None:
+            raise ValueError("Select a file or directory before running this script.")
+        target_path = selected_path
+    else:
+        raise ValueError(f"Unsupported script target: {script.target}")
+
+    if not target_path.exists():
+        raise FileNotFoundError(target_path)
+
+    target_kind: Literal["file", "directory"] = (
+        "directory" if target_path.is_dir() else "file"
+    )
+    if script.target == "highlighted_file" and target_kind != "file":
+        raise ValueError(
+            f"'{script.name}' expects a file. Highlight a file and try again."
+        )
+    if script.target == "highlighted_directory" and target_kind != "directory":
+        raise ValueError(
+            f"'{script.name}' expects a directory. Highlight a folder and try again."
+        )
+    if script.target == "highlighted_file":
+        allowed_extensions = _normalize_extensions(script.file_extensions)
+        if allowed_extensions:
+            name = target_path.name.lower()
+            if not any(name.endswith(ext) for ext in allowed_extensions):
+                extensions_label = ", ".join(sorted(allowed_extensions))
+                raise ValueError(
+                    f"'{script.name}' expects {extensions_label} file(s). "
+                    "Highlight a matching file and try again."
+                )
+
+    return ScriptExecutionContext(
+        script=script,
+        script_path=full_path,
+        target_path=target_path,
+        target_kind=target_kind,
+    )
+
+
+def _normalize_extensions(extensions: list[str] | None) -> list[str]:
+    if not extensions:
+        return []
+    normalized: list[str] = []
+    for ext in extensions:
+        cleaned = ext.strip().lower()
+        if not cleaned:
+            continue
+        if not cleaned.startswith("."):
+            cleaned = f".{cleaned}"
+        normalized.append(cleaned)
+    return normalized

ferp/services/update_check.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import json
+import urllib.request
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class UpdateCheckResult:
+    ok: bool
+    current: str
+    latest: str | None
+    is_update: bool
+    error: str | None
+    checked_at: datetime | None
+
+
+def check_for_update(
+    package: str,
+    current: str,
+    cache_path: Path,
+    *,
+    ttl_seconds: int,
+    force: bool = False,
+) -> UpdateCheckResult:
+    now = datetime.now(timezone.utc)
+    if not force:
+        cached = _read_cache(cache_path, ttl_seconds)
+        if cached is not None:
+            latest, checked_at = cached
+            return UpdateCheckResult(
+                ok=True,
+                current=current,
+                latest=latest,
+                is_update=is_newer(latest, current),
+                error=None,
+                checked_at=checked_at,
+            )
+
+    try:
+        latest = fetch_latest_version(package)
+    except Exception as exc:
+        cached = _read_cache(cache_path, None)
+        latest = cached[0] if cached else None
+        checked_at = cached[1] if cached else None
+        return UpdateCheckResult(
+            ok=cached is not None,
+            current=current,
+            latest=latest,
+            is_update=is_newer(latest, current) if latest else False,
+            error=str(exc),
+            checked_at=checked_at,
+        )
+
+    _write_cache(cache_path, latest, now)
+    return UpdateCheckResult(
+        ok=True,
+        current=current,
+        latest=latest,
+        is_update=is_newer(latest, current),
+        error=None,
+        checked_at=now,
+    )
+
+
+def fetch_latest_version(package: str) -> str:
+    url = f"https://pypi.org/pypi/{package}/json"
+    with urllib.request.urlopen(url, timeout=5) as response:
+        payload = json.load(response)
+    info = payload.get("info", {})
+    version = info.get("version")
+    if not isinstance(version, str) or not version:
+        raise RuntimeError("PyPI response missing latest version.")
+    return version
+
+
+def is_newer(latest: str, current: str) -> bool:
+    def normalize(value: str) -> tuple[int, ...]:
+        parts: list[int] = []
+        for token in value.split("."):
+            digits = []
+            for ch in token:
+                if ch.isdigit():
+                    digits.append(ch)
+                else:
+                    break
+            number = int("".join(digits) or "0")
+            parts.append(number)
+        while parts and parts[-1] == 0:
+            parts.pop()
+        return tuple(parts)
+
+    latest_parts = normalize(latest)
+    current_parts = normalize(current)
+    max_len = max(len(latest_parts), len(current_parts))
+    latest_parts += (0,) * (max_len - len(latest_parts))
+    current_parts += (0,) * (max_len - len(current_parts))
+    return latest_parts > current_parts
+
+
+def _read_cache(
+    cache_path: Path, ttl_seconds: int | None
+) -> tuple[str, datetime] | None:
+    try:
+        raw = json.loads(cache_path.read_text())
+    except (OSError, json.JSONDecodeError):
+        return None
+    latest = raw.get("latest")
+    checked_at = raw.get("checked_at")
+    if not isinstance(latest, str) or not latest:
+        return None
+    if not isinstance(checked_at, (int, float)):
+        return None
+    checked_at_dt = datetime.fromtimestamp(checked_at, tz=timezone.utc)
+    if ttl_seconds is not None:
+        age = (datetime.now(timezone.utc) - checked_at_dt).total_seconds()
+        if age > ttl_seconds:
+            return None
+    return latest, checked_at_dt
+
+
+def _write_cache(cache_path: Path, latest: str, checked_at: datetime) -> None:
+    cache_path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "latest": latest,
+        "checked_at": checked_at.timestamp(),
+    }
+    cache_path.write_text(json.dumps(payload))