jobpicky 0.2.1__py3-none-any.whl

jobpicky/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.2.1"

jobpicky/__main__.py

@@ -0,0 +1,4 @@
+from .launcher import main
+
+
+raise SystemExit(main())

jobpicky/alerts.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .error_safety import redact_text
+
+
+def build_daily_message(total_new: int, relevant_rows: list[dict[str, Any]], error: str | None = None) -> str:
+    lines = [f"今日新增秋招信息：{total_new} 条", f"推荐岗位：{len(relevant_rows)} 条"]
+    if error:
+        error = redact_text(error)
+        lines.append(f"抓取异常：{error}")
+    if not relevant_rows:
+        lines.append("暂无需要推送的推荐岗位。")
+        return "\n".join(lines)
+
+    for index, row in enumerate(relevant_rows[:20], start=1):
+        company = row.get("company") or "未知公司"
+        title = row.get("title") or row.get("clean_title") or "未命名公告"
+        city = row.get("city") or "城市待确认"
+        link = row.get("original_url") or row.get("detail_url") or row.get("apply_url") or ""
+        lines.extend(
+            [
+                "",
+                f"{index}. {company} - {title} - {city}",
+            ]
+        )
+        if link:
+            lines.append(str(link))
+    if len(relevant_rows) > 20:
+        lines.append(f"\n其余 {len(relevant_rows) - 20} 条请在飞书视图查看。")
+    return "\n".join(lines)

jobpicky/audit.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Iterable
+
+from .storage import JobRepository
+
+
+KNOWN_STATUSES = frozenset({"待处理", "收藏", "不合适", "已投递", "笔试中", "面试中", "Offer", "已结束"})
+
+
+@dataclass(frozen=True, slots=True)
+class FeishuAuditReport:
+    local_job_count: int
+    remote_record_count: int
+    only_local_job_ids: list[int] = field(default_factory=list)
+    only_remote_record_ids: list[str] = field(default_factory=list)
+    duplicate_job_ids: list[int] = field(default_factory=list)
+    blank_record_ids: list[str] = field(default_factory=list)
+    unmatched_record_ids: list[str] = field(default_factory=list)
+    unknown_statuses: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class StateRecoveryResult:
+    updated_count: int
+    unknown_statuses: dict[str, str]
+    skipped_record_ids: list[str]
+
+
+def audit_feishu_records(repo: JobRepository, records: Iterable[dict[str, Any]]) -> FeishuAuditReport:
+    record_list = list(records)
+    record_to_job = repo.sync_job_ids_by_record_id()
+    local_ids = set(record_to_job.values())
+    matched_ids: set[int] = set()
+    seen_ids: set[int] = set()
+    duplicates: set[int] = set()
+    only_remote: list[str] = []
+    blank: list[str] = []
+    unmatched: list[str] = []
+    unknown: dict[str, str] = {}
+
+    for index, record in enumerate(record_list):
+        record_id = str(record.get("record_id") or f"record-{index + 1}")
+        if not record.get("record_id"):
+            blank.append(record_id)
+            continue
+        job_id = record_to_job.get(record_id)
+        if job_id in seen_ids:
+            duplicates.add(job_id)
+        seen_ids.add(job_id)
+        if job_id is None:
+            only_remote.append(record_id)
+        else:
+            matched_ids.add(job_id)
+        status = _text(_fields(record).get("求职状态")).strip()
+        if status and normalize_status(status) is None:
+            unknown[record_id] = status
+
+    return FeishuAuditReport(
+        local_job_count=len(local_ids),
+        remote_record_count=len(record_list),
+        only_local_job_ids=sorted(local_ids - matched_ids),
+        only_remote_record_ids=only_remote,
+        duplicate_job_ids=sorted(duplicates),
+        blank_record_ids=blank,
+        unmatched_record_ids=unmatched,
+        unknown_statuses=unknown,
+    )
+
+
+def recover_user_states(repo: JobRepository, records: Iterable[dict[str, Any]]) -> StateRecoveryResult:
+    record_list = list(records)
+    report = audit_feishu_records(repo, record_list)
+    record_to_job = repo.sync_job_ids_by_record_id()
+    skipped = set(report.only_remote_record_ids + report.blank_record_ids + report.unmatched_record_ids)
+    duplicate_ids = set(report.duplicate_job_ids)
+    updated = 0
+    for index, record in enumerate(record_list):
+        record_id = str(record.get("record_id") or f"record-{index + 1}")
+        fields = _fields(record)
+        job_id = record_to_job.get(record_id)
+        if job_id in duplicate_ids:
+            skipped.add(record_id)
+        if record_id in skipped or record_id in report.unknown_statuses:
+            continue
+        status = normalize_status(_text(fields.get("求职状态")).strip())
+        if job_id is None or status is None:
+            continue
+        repo.update_user_state(
+            job_id,
+            status,
+            _text(fields.get("备注")),
+            apply_url_manual=None,
+        )
+        if record.get("record_id"):
+            repo.mark_sync(job_id, "synced", record_id=str(record["record_id"]))
+        updated += 1
+    return StateRecoveryResult(updated_count=updated, unknown_statuses=report.unknown_statuses, skipped_record_ids=sorted(skipped))
+
+
+def normalize_status(value: str) -> str | None:
+    return value if value in KNOWN_STATUSES else None
+
+
+def _fields(record: dict[str, Any]) -> dict[str, Any]:
+    fields = record.get("fields", {})
+    return fields if isinstance(fields, dict) else {}
+
+
+def _text(value: Any) -> str:
+    if isinstance(value, list):
+        return "".join(_text(item) for item in value)
+    if isinstance(value, dict):
+        return str(value.get("text") or value.get("link") or "")
+    return "" if value is None else str(value)
+
+
+def _link_or_text(value: Any) -> str:
+    return _text(value)

jobpicky/backup.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+
+
+@dataclass(frozen=True, slots=True)
+class SQLiteBackup:
+    backup_path: Path
+    metadata_path: Path
+
+
+class BackupService:
+    """Create self-describing, restorable snapshots without touching the source."""
+
+    def __init__(self, backup_directory: str | Path):
+        self.backup_directory = Path(backup_directory)
+
+    def backup_sqlite(self, database_path: str | Path, *, source: str) -> SQLiteBackup:
+        database_path = Path(database_path)
+        if not database_path.is_file():
+            raise FileNotFoundError(database_path)
+
+        self.backup_directory.mkdir(parents=True, exist_ok=True)
+        created_at = _utc_now()
+        filename = f"{_safe_name(source)}-{database_path.stem}-{created_at.replace(':', '').replace('-', '')}.sqlite"
+        backup_path = self.backup_directory / filename
+        temporary_path = backup_path.with_suffix(".sqlite.tmp")
+        try:
+            source_connection = sqlite3.connect(database_path)
+            target_connection = sqlite3.connect(temporary_path)
+            try:
+                source_connection.backup(target_connection)
+            finally:
+                target_connection.close()
+                source_connection.close()
+            os.replace(temporary_path, backup_path)
+        finally:
+            if temporary_path.exists():
+                temporary_path.unlink()
+
+        metadata = {
+            "format_version": 1,
+            "created_at": created_at,
+            "source": source,
+            "backup_file": backup_path.name,
+            "sha256": _sha256(backup_path),
+        }
+        metadata_path = backup_path.with_suffix(".json")
+        _write_json(metadata_path, metadata)
+        return SQLiteBackup(backup_path=backup_path, metadata_path=metadata_path)
+
+
+def write_feishu_backup(
+    pages: Iterable[Iterable[dict[str, Any]]], backup_directory: str | Path, *, source: str = "feishu"
+) -> Path:
+    """Persist already-fetched Feishu pages while removing credential-shaped fields."""
+    directory = Path(backup_directory)
+    directory.mkdir(parents=True, exist_ok=True)
+    created_at = _utc_now()
+    output = directory / f"{_safe_name(source)}-records-{created_at.replace(':', '').replace('-', '')}.json"
+    records = [_redact_credentials(record) for page in pages for record in page]
+    _write_json(output, {"format_version": 1, "created_at": created_at, "source": source, "records": records})
+    return output
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def _safe_name(value: str) -> str:
+    return re.sub(r"[^A-Za-z0-9_.-]+", "-", value).strip("-") or "backup"
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _write_json(path: Path, payload: dict[str, Any]) -> None:
+    temporary_path = path.with_suffix(path.suffix + ".tmp")
+    try:
+        temporary_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+        os.replace(temporary_path, path)
+    finally:
+        if temporary_path.exists():
+            temporary_path.unlink()
+
+
+def _redact_credentials(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {
+            key: _redact_credentials(item)
+            for key, item in value.items()
+            if not any(marker in key.lower() for marker in ("secret", "token", "authorization", "webhook", "password"))
+        }
+    if isinstance(value, list):
+        return [_redact_credentials(item) for item in value]
+    return value