jobpicky 0.2.1__tar.gz

jobpicky-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JobPicky contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jobpicky-0.2.1/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: jobpicky
+Version: 0.2.1
+Summary: JobPicky - Your personalized job radar
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mushang0/JobPicky
+Project-URL: Repository, https://github.com/mushang0/JobPicky
+Keywords: job-search,personalized-job-search,feishu,career,招聘,求职
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: fastapi<0.116,>=0.115
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: requests>=2.31
+Requires-Dist: uvicorn>=0.32
+Provides-Extra: test
+Requires-Dist: httpx<0.29,>=0.27; extra == "test"
+Requires-Dist: pytest<9,>=8; extra == "test"
+Dynamic: license-file
+
+# JobPicky
+
+Your personalized job radar
+
+懂你偏好的个性化岗位雷达：选择你的偏好，快速发现匹配岗位；飞书是可选的，连接后即可同步推荐。
+
+## 启动
+
+~~~powershell
+uvx --python 3.12 jobpicky
+~~~
+
+启动后浏览器会自动打开配置页面；连接飞书后会自动创建或修复工作台并同步推荐。源码安装、开发环境、测试、打包和发布流程见 [DEVELOPER.md](DEVELOPER.md)。

jobpicky-0.2.1/README.md

@@ -0,0 +1,13 @@
+# JobPicky
+
+Your personalized job radar
+
+懂你偏好的个性化岗位雷达：选择你的偏好，快速发现匹配岗位；飞书是可选的，连接后即可同步推荐。
+
+## 启动
+
+~~~powershell
+uvx --python 3.12 jobpicky
+~~~
+
+启动后浏览器会自动打开配置页面；连接飞书后会自动创建或修复工作台并同步推荐。源码安装、开发环境、测试、打包和发布流程见 [DEVELOPER.md](DEVELOPER.md)。

jobpicky-0.2.1/pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "jobpicky"
+version = "0.2.1"
+description = "JobPicky - Your personalized job radar"
+readme = "README.md"
+license = "MIT"
+keywords = ["job-search", "personalized-job-search", "feishu", "career", "招聘", "求职"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: Microsoft :: Windows",
+]
+requires-python = ">=3.11"
+dependencies = [
+    "beautifulsoup4>=4.12",
+    "fastapi>=0.115,<0.116",
+    "openpyxl>=3.1",
+    "PyYAML>=6.0",
+    "requests>=2.31",
+    "uvicorn>=0.32",
+]
+
+[project.optional-dependencies]
+test = [
+    "httpx>=0.27,<0.29",
+    "pytest>=8,<9",
+]
+
+[project.scripts]
+jobpicky = "jobpicky.launcher:main"
+
+[project.urls]
+Homepage = "https://github.com/mushang0/JobPicky"
+Repository = "https://github.com/mushang0/JobPicky"
+
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+jobpicky = [
+    "resources/*.sqlite",
+    "resources/defaults/*",
+    "web/templates/**/*",
+    "web/static/**/*",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

jobpicky-0.2.1/setup.cfg

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

jobpicky-0.2.1/src/jobpicky/__init__.py

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

jobpicky-0.2.1/src/jobpicky/__main__.py

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

jobpicky-0.2.1/src/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-0.2.1/src/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-0.2.1/src/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