jobhunter-cli 0.0.post1.dev85__py3-none-any.whl

jobhunter/pipeline/send.py

@@ -0,0 +1,191 @@
+import logging
+import time
+
+import httpx
+
+from jobhunter.core.logger import console
+from jobhunter.core.paths import DATA_PATH, read, write
+from jobhunter.core.settings import settings
+from jobhunter.core.textutil import clean_html
+from jobhunter.models import EvaluatedCandidate
+
+logger = logging.getLogger(__name__)
+
+
+def build_send_tasks() -> list[EvaluatedCandidate]:
+  """Loads all evaluated candidates from disk and filters for jobs that passed evaluation (no score floor)."""
+  logger.info("Building send tasks...")
+
+  raw_evals = read(DATA_PATH / "evaluated.json", list)
+
+  tasks = []
+  for item in raw_evals:
+    try:
+      evaluation = item.get("evaluation", {})
+      hard_fail = evaluation.get("hard_fail", True)
+
+      if not hard_fail:
+        eval_candidate = EvaluatedCandidate(**item)
+        tasks.append(eval_candidate)
+
+    except Exception as e:
+      logger.error(f"Failed to parse evaluated candidate {item.get('uid', 'unknown')}: {e}")
+      console.print(f"  [red]✖ Failed to parse evaluated candidate {item.get('uid', 'unknown')}[/red]")
+
+  logger.info(f"Generated {len(tasks)} send tasks from evaluated candidates.")
+
+  return tasks
+
+
+def send_single_telegram_message(candidate: EvaluatedCandidate) -> bool:
+  token = settings.telegram_bot_token
+  chat_id = settings.telegram_chat_id
+  eval_data = candidate.evaluation
+
+  priority_badge = "⭐ <b>[VIP COMPANY]</b> " if candidate.priority else ""
+
+  score_threshold = settings.evaluating.score_threshold
+  if eval_data.score >= 80:
+    score_emoji = "🟢"
+  elif eval_data.score >= score_threshold:
+    score_emoji = "🟡"
+  else:
+    score_emoji = "🟠"
+
+  pitch_section = f"\n💡 <b>Pitch:</b>\n{clean_html(eval_data.pitch)}\n" if eval_data.pitch else ""
+
+  message = f"""
+🎯 <b>New Job Match!</b>
+{priority_badge}({score_emoji} Score: <code>{eval_data.score}/100</code>)
+
+🏢 <b>Company:</b> {clean_html(candidate.company)}
+💼 <b>Title:</b> {clean_html(candidate.title)}
+📍 <b>Location:</b> {clean_html(candidate.location) or "Remote"}
+
+🔍 <b>Reasoning:</b>\n{clean_html(eval_data.reasoning)}
+📈 <b>Score Breakdown:</b>\n{clean_html(eval_data.score_explanation)}
+{pitch_section}
+🔗 <a href="{candidate.url}">View Job Posting</a>
+"""
+
+  url = f"https://api.telegram.org/bot{token}/sendMessage"
+  payload = {
+    "chat_id": chat_id,
+    "text": message,
+    "parse_mode": "HTML",
+    "disable_web_page_preview": True,
+  }
+
+  try:
+    response = httpx.post(url, json=payload, timeout=10.0)
+    response.raise_for_status()
+    return True
+  except httpx.HTTPStatusError as e:
+    logger.exception(f"Telegram API Error ({e.response.status_code}) for {candidate.company}: {e.response.text}")
+    console.print(f"  [red]✖ Telegram API Error: {e.response.status_code}[/red]")
+    return False
+  except Exception as e:
+    logger.exception(f"Failed to send Telegram notification for {candidate.company}: {e}")
+    console.print(f"  [red]✖ Failed to send Telegram notification for {candidate.company}[/red]")
+    return False
+
+
+def execute_telegram_sends(tasks: list[EvaluatedCandidate]) -> tuple[list[EvaluatedCandidate], int]:
+  """Iterates through send tasks and dispatches notifications via Telegram."""
+  logger.info(f"Executing Telegram dispatch across {len(tasks)} candidates.")
+  console.print(f"[bold cyan]Sending {len(tasks)} job alerts via Telegram...[/bold cyan]")
+
+  token = settings.telegram_bot_token
+  chat_id = settings.telegram_chat_id
+
+  if not token or not chat_id:
+    logger.error("Telegram token or chat ID is missing in settings.")
+    console.print("[bold red]Error: Telegram token or chat ID not configured in settings.[/bold red]")
+    return [], 0
+
+  sent_candidates = []
+  failed_count = 0
+
+  for candidate in tasks:
+    success = send_single_telegram_message(candidate)
+
+    if success:
+      sent_candidates.append(candidate)
+      console.print(f"  [green]✔ Sent alert for {candidate.company} - {candidate.title}[/green]")
+    else:
+      failed_count += 1
+      console.print(f"  [red]✖ Failed to send alert for {candidate.company}[/red]")
+
+    time.sleep(1)
+
+  logger.info(f"Telegram dispatch complete. Successfully sent: {len(sent_candidates)}, Failed: {failed_count}")
+
+  return sent_candidates, failed_count
+
+
+def save_send_results(sent_candidates: list[EvaluatedCandidate]):
+  """Logs evaluated jobs to seen.json, then purges them from state files."""
+  logger.info("Updating state files...")
+  console.print("[dim cyan]Updating local state files...[/dim cyan]")
+
+  all_evaluated = read(DATA_PATH / "evaluated.json", list)
+  if not all_evaluated:
+    return
+
+  all_evaluated_uids = {e.get("uid") for e in all_evaluated if e.get("uid")}
+  sent_uids = {c.uid for c in sent_candidates}
+  current_time = int(time.time())
+
+  seen_data = read(DATA_PATH / "seen.json", dict)
+  for uid in all_evaluated_uids:
+    seen_data[uid] = current_time
+
+  retention_cutoff = current_time - (settings.limits.seen_retention_days * 86400)
+  seen_data = {uid: ts for uid, ts in seen_data.items() if ts > retention_cutoff}
+  write(DATA_PATH / "seen.json", seen_data)
+
+  candidates = read(DATA_PATH / "candidates.json", list)
+  filtered_candidates = [c for c in candidates if c.get("uid") not in all_evaluated_uids]
+  write(DATA_PATH / "candidates.json", filtered_candidates)
+
+  failed_to_send = [e for e in all_evaluated if e.get("uid") not in sent_uids and not e.get("evaluation", {}).get("hard_fail", True)]
+  write(DATA_PATH / "evaluated.json", failed_to_send)
+
+
+def main(dry_run: bool = False):
+  """Orchestrates the Telegram notification pipeline."""
+  logger.info("Starting Telegram send pipeline run.")
+  console.print("[bold cyan]Dispatching job evaluations to Telegram...[/bold cyan]")
+
+  all_evaluated = read(DATA_PATH / "evaluated.json", list)
+  if not all_evaluated:
+    logger.info("No evaluated candidates exist.")
+    console.print("[yellow]No evaluated jobs pending processing.[/yellow]")
+    return
+
+  tasks = build_send_tasks()
+
+  sent_candidates = []
+  failed_count = 0
+
+  if tasks:
+    sent_candidates, failed_count = execute_telegram_sends(tasks)
+  else:
+    logger.info("No pending job alerts to send (all evaluated jobs hard-failed).")
+    console.print("[dim]No passing jobs to alert you about. Updating seen state...[/dim]")
+
+  if not dry_run:
+    save_send_results(sent_candidates)
+  else:
+    logger.info("Dry run enabled. Skipping state file updates.")
+    console.print("\n[yellow]Dry run mode: skipped saving to local state files.[/yellow]")
+
+  total_sent = len(sent_candidates)
+  logger.info(f"Pipeline finished. Sent: {total_sent} | Failed: {failed_count}")
+
+  console.print("\n[bold]Telegram Dispatch Summary[/bold]")
+  console.print("───────────────────────────────────────")
+  console.print(f"Alerts sent       : [bold green]{total_sent}[/bold green]")
+  console.print(f"Failed deliveries : [red]{failed_count}[/red]")
+  console.print(f"Dry run mode      : [yellow]{dry_run}[/yellow]")
+  console.print("───────────────────────────────────────\n")

jobhunter/sources/__init__.py

@@ -0,0 +1,21 @@
+import importlib
+import pkgutil
+from pathlib import Path
+
+SOURCES = {}
+
+current_dir = str(Path(__file__).parent)
+
+for _, module_name, _ in pkgutil.iter_modules([current_dir]):
+  if module_name == "base":
+    continue
+
+  module = importlib.import_module(f".{module_name}", package=__name__)
+
+  if hasattr(module, "Source"):
+    source_instance = module.Source()
+    if getattr(source_instance, "enabled", True):
+      SOURCES[source_instance.name] = source_instance
+
+
+__all__ = ["SOURCES"]

jobhunter/sources/arbeitnow.py

@@ -0,0 +1,77 @@
+import logging
+import time
+from datetime import UTC, datetime
+
+from jobhunter.core.http import fetch_url
+from jobhunter.core.logger import console
+from jobhunter.core.textutil import clean_html, parse_date
+from jobhunter.models import Job
+from jobhunter.sources.base import BaseSource
+
+logger = logging.getLogger(__name__)
+
+
+class Source(BaseSource):
+  name = "arbeitnow"
+  domains = ["arbeitnow.com"]
+  is_aggregator = True
+
+  def fetch(self, slug: str = "", skip_parsing: bool = False, **kwargs) -> list[Job]:
+    """Fetches all available job listings from the Arbeitnow API via pagination link traversal."""
+    url = "https://www.arbeitnow.com/api/job-board-api"
+    jobs: list[Job] = []
+
+    while url:
+      data = fetch_url(url, expected_type=dict)
+
+      for item in data.get("data", []):
+        if not isinstance(item, dict):
+          logger.warning(f"[ {self.name} ] Skipping unexpected item format: {type(item).__name__}")
+          console.print(f"  [yellow]⚠ [ {self.name} ] Skipping unexpected item format...[/yellow]")
+          continue
+
+        job_id = str(item.get("slug") or "")
+        title = str(item.get("title") or "")
+        job_url = str(item.get("url") or "")
+
+        if not all([job_id, title, job_url]):
+          logger.warning(f"[ {self.name} ] Skipping item with missing required fields: {item}")
+          console.print(f"  [yellow]⚠ [ {self.name} ] Skipping item with missing required fields.[/yellow]")
+          continue
+
+        try:
+          raw_tags = item.get("tags") or []
+          tags = ", ".join(str(t) for t in raw_tags if t)
+          description = item.get("description", "")
+          if tags:
+            description = f"Tags: {tags}\n\n{description}"
+
+          created = item.get("created_at")
+          posted = datetime.fromtimestamp(created, tz=UTC).strftime("%Y-%m-%d") if isinstance(created, (int, float)) else parse_date(str(created))
+
+          jobs.append(
+            Job(
+              source=self.name,
+              board=self.name,
+              company=item.get("company_name") or "Unknown",
+              job_id=job_id,
+              title=title,
+              url=job_url,
+              location=item.get("location") or "",
+              remote=True if item.get("remote") else None,
+              posted=posted,
+              description=clean_html(description),
+            )
+          )
+
+        except Exception as e:
+          logger.exception(f"[ {self.name} ] Error parsing job '{job_id}': {e}")
+          console.print(f"  [red]✖ [ {self.name} ] Error parsing job '{job_id}'[/red]")
+          continue
+
+      url = (data.get("links") or {}).get("next")
+
+      if url:
+        time.sleep(1.5)
+
+    return jobs

jobhunter/sources/ashby.py

@@ -0,0 +1,75 @@
+import logging
+import re
+
+from jobhunter.core.http import fetch_url
+from jobhunter.core.logger import console
+from jobhunter.core.textutil import clean_html, parse_date
+from jobhunter.models import Job
+from jobhunter.sources.base import BaseSource
+
+logger = logging.getLogger(__name__)
+
+
+class Source(BaseSource):
+  name = "ashby"
+  domains = ["jobs.ashbyhq.com"]
+  url_patterns = [re.compile(r"(?://|www\.)(?P<slug>[^/?#.]+)\.ashbyhq\.com"), re.compile(r"ashbyhq\.com/(?P<slug>[^/?#]+)")]
+
+  def fetch(self, slug: str = "", skip_parsing: bool = False, **kwargs) -> list[Job]:
+    """Fetches job listings from a specific company's Ashby API."""
+    if not slug:
+      raise ValueError(f"A company slug must be provided to fetch {self.name} jobs.")
+
+    url = f"https://api.ashbyhq.com/posting-api/job-board/{slug}"
+    data = fetch_url(url, expected_type=dict)
+
+    if skip_parsing:
+      return []
+
+    jobs: list[Job] = []
+
+    for item in data.get("jobs", []):
+      if not isinstance(item, dict):
+        logger.warning(f"[ {self.name} ] Skipping unexpected item format: {type(item).__name__}")
+        console.print(f"  [yellow]⚠ [ {self.name} ] Skipping unexpected item format...[/yellow]")
+        continue
+
+      if item.get("isListed") is False:
+        continue
+
+      job_id = str(item.get("id") or "")
+      title = str(item.get("title") or "")
+      job_url = str(item.get("jobUrl") or item.get("applyUrl") or "")
+
+      if not all([job_id, title, job_url]):
+        logger.warning(f"[ {self.name} ] Skipping item with missing required fields: {item}")
+        console.print(f"  [yellow]⚠ [ {self.name} ] Skipping item with missing required fields.[/yellow]")
+        continue
+
+      try:
+        extra = [s.get("location", "") if isinstance(s, dict) else str(s) for s in item.get("secondaryLocations") or []]
+        location = ", ".join(x for x in [item.get("location", ""), *extra] if x)
+
+        is_remote = bool(item.get("isRemote")) or str(item.get("workplaceType", "")).lower() == "remote"
+
+        jobs.append(
+          Job(
+            source=self.name,
+            board=slug,
+            company=slug.replace("-", " ").title(),
+            job_id=job_id,
+            title=title,
+            url=job_url,
+            location=location,
+            remote=True if is_remote else None,
+            posted=parse_date(item.get("publishedAt") or item.get("publishedDate")),
+            description=item.get("descriptionPlain") or clean_html(item.get("descriptionHtml", "")),
+          )
+        )
+
+      except Exception as e:
+        logger.exception(f"[ {self.name} ] Error parsing job '{job_id}' for '{slug}': {e}")
+        console.print(f"  [red]✖ [ {self.name} ] Error parsing job '{job_id}'[/red]")
+        continue
+
+    return jobs

jobhunter/sources/base.py

@@ -0,0 +1,108 @@
+import logging
+import re
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Any
+from urllib.parse import unquote
+
+import httpx
+
+from jobhunter.core.logger import console
+from jobhunter.core.settings import settings
+from jobhunter.models import Job
+
+logger = logging.getLogger(__name__)
+
+DEFINITIVE_INVALID_STATUS = {404, 410}
+
+
+class SlugStatus(Enum):
+  VALID = "valid"
+  INVALID = "invalid"
+  UNKNOWN = "unknown"
+
+
+class BaseSource(ABC):
+  name: str
+  domains: list[str]
+  url_patterns: list[re.Pattern] = []
+  is_aggregator: bool = False
+  board_config: dict[str, Any] | bool
+  enabled: bool
+
+  def __init__(self):
+    super().__init__()
+    self.board_config = settings.boards.get(self.name, {})
+    if isinstance(self.board_config, dict):
+      self.enabled = self.board_config.get("enabled", True)
+    else:
+      self.enabled = bool(self.board_config)
+
+  def extract_slug(self, url: str) -> str | None:
+    """Extracts the company slug from a URL using source-specific regex patterns."""
+    if not url:
+      return None
+
+    for pattern in self.url_patterns:
+      match = pattern.search(url)
+      if match:
+        slug = match.group("slug").lower().strip()
+        slug = unquote(slug)
+        if 1 < len(slug) < 60:
+          return slug
+
+    return None
+
+  def validate_slug(self, slug: str) -> SlugStatus:
+    """Validates a slug and returns its status."""
+    if not slug or not isinstance(slug, str):
+      return SlugStatus.INVALID
+
+    try:
+      self.fetch(slug=slug, skip_parsing=True)
+      return SlugStatus.VALID
+
+    except httpx.HTTPStatusError as e:
+      if e.response.status_code in DEFINITIVE_INVALID_STATUS:
+        return SlugStatus.INVALID
+      return SlugStatus.UNKNOWN
+
+    except Exception:
+      return SlugStatus.UNKNOWN
+
+  def execute_scraper(self, slug: str = "") -> list[Job]:
+    """Executes the scraper for a given source and slug."""
+    if not self.enabled:
+      return []
+
+    if not self.is_aggregator and not slug:
+      logger.warning(f"[ {self.name} ] Skipping execution: Non-aggregator sources require a slug.")
+      console.print(f"  [yellow]⚠ [ {self.name} ] Skipping execution: Non-aggregator sources require a slug.[/yellow]")
+      return []
+
+    try:
+      return self.fetch(slug=slug) or []
+
+    except httpx.HTTPStatusError as e:
+      logger.error(f"[ {self.name} ] HTTP {e.response.status_code} error for slug '{slug}': {e}")
+      console.print(f"  [red]✖ [ {self.name} ] HTTP {e.response.status_code} error for slug '{slug}'[/red]")
+      return []
+
+    except httpx.RequestError as e:
+      logger.error(f"[ {self.name} ] Network error while connecting to '{slug}': {e}")
+      console.print(f"  [red]✖ [ {self.name} ] Network error while connecting to '{slug}'[/red]")
+      return []
+
+    except ValueError as e:
+      logger.error(f"[ {self.name} ] Validation error for slug '{slug}': {e}")
+      console.print(f"  [red]✖ [ {self.name} ] Validation error for slug '{slug}': {e}[/red]")
+      return []
+
+    except Exception as e:
+      logger.exception(f"[ {self.name} ] Unexpected error executing scraper for slug '{slug}': {e}")
+      console.print(f"  [red]✖ [ {self.name} ] Unexpected error executing scraper for slug '{slug}'[/red]")
+      return []
+
+  @abstractmethod
+  def fetch(self, slug: str = "", skip_parsing: bool = False, **kwargs) -> list[Job]:
+    pass

jobhunter/sources/greenhouse.py

@@ -0,0 +1,70 @@
+import logging
+import re
+
+from jobhunter.core.http import fetch_url
+from jobhunter.core.logger import console
+from jobhunter.core.textutil import clean_html, parse_date
+from jobhunter.models import Job
+from jobhunter.sources.base import BaseSource
+
+logger = logging.getLogger(__name__)
+
+
+class Source(BaseSource):
+  name = "greenhouse"
+  domains = ["boards.greenhouse.io", "job-boards.greenhouse.io"]
+  url_patterns = [
+    re.compile(r"greenhouse\.io/(?P<slug>[^/?#]+)"),
+  ]
+
+  def fetch(self, slug: str = "", skip_parsing: bool = False, **kwargs) -> list[Job]:
+    """Fetches job listings from a specific company's Greenhouse API."""
+    if not slug:
+      raise ValueError(f"A company slug must be provided to fetch {self.name} jobs.")
+
+    url = f"https://boards-api.greenhouse.io/v1/boards/{slug}/jobs?content=true"
+    data = fetch_url(url, expected_type=dict)
+
+    if skip_parsing:
+      return []
+
+    jobs: list[Job] = []
+
+    for item in data.get("jobs", []):
+      if not isinstance(item, dict):
+        logger.warning(f"[ {self.name} ] Skipping unexpected item format: {type(item).__name__}")
+        console.print(f"  [yellow]⚠ [ {self.name} ] Skipping unexpected item format...[/yellow]")
+        continue
+
+      job_id = str(item.get("id") or "")
+      title = str(item.get("title") or "")
+      job_url = str(item.get("absolute_url") or "")
+
+      if not all([job_id, title, job_url]):
+        logger.warning(f"[ {self.name} ] Skipping item with missing required fields: {item}")
+        console.print(f"  [yellow]⚠ [ {self.name} ] Skipping item with missing required fields.[/yellow]")
+        continue
+
+      try:
+        location = (item.get("location") or {}).get("name") or ""
+
+        jobs.append(
+          Job(
+            source=self.name,
+            board=slug,
+            company=slug.replace("-", " ").title(),
+            job_id=job_id,
+            title=title,
+            url=job_url,
+            location=location,
+            posted=parse_date(item.get("first_published") or item.get("updated_at")),
+            description=clean_html(item.get("content", "")),
+          )
+        )
+
+      except Exception as e:
+        logger.exception(f"[ {self.name} ] Error parsing job '{job_id}' for '{slug}': {e}")
+        console.print(f"  [red]✖ [ {self.name} ] Error parsing job '{job_id}'[/red]")
+        continue
+
+    return jobs

jobhunter/sources/lever.py

@@ -0,0 +1,85 @@
+import logging
+import re
+from datetime import UTC, datetime
+
+from jobhunter.core.http import fetch_url
+from jobhunter.core.logger import console
+from jobhunter.core.textutil import clean_html, parse_date
+from jobhunter.models import Job
+from jobhunter.sources.base import BaseSource
+
+logger = logging.getLogger(__name__)
+
+
+class Source(BaseSource):
+  name = "lever"
+  domains = ["lever.co"]
+  url_patterns = [
+    re.compile(r"lever\.co/(?P<slug>[^/?#]+)"),
+  ]
+
+  def fetch(self, slug: str = "", skip_parsing: bool = False, **kwargs) -> list[Job]:
+    """Fetches job listings from a specific company's Lever API."""
+    if not slug:
+      raise ValueError(f"A company slug must be provided to fetch {self.name} jobs.")
+
+    url = f"https://api.lever.co/v0/postings/{slug}?mode=json"
+    data = fetch_url(url, expected_type=list)
+
+    if skip_parsing:
+      return []
+
+    jobs: list[Job] = []
+
+    for item in data:
+      if not isinstance(item, dict):
+        logger.warning(f"[ {self.name} ] Skipping unexpected item format: {type(item).__name__}")
+        console.print(f"  [yellow]⚠ [ {self.name} ] Skipping unexpected item format...[/yellow]")
+        continue
+
+      job_id = str(item.get("id") or "")
+      title = str(item.get("text") or "")
+      job_url = str(item.get("hostedUrl") or "")
+
+      if not all([job_id, title, job_url]):
+        logger.warning(f"[ {self.name} ] Skipping item with missing required fields: {item}")
+        console.print(f"  [yellow]⚠ [ {self.name} ] Skipping item with missing required fields.[/yellow]")
+        continue
+
+      try:
+        categories = item.get("categories") or {}
+        location = categories.get("location") or ", ".join(categories.get("allLocations") or [])
+
+        parts = [item.get("descriptionPlain") or ""]
+        for block in item.get("lists") or []:
+          block_text = block.get("text") or ""
+          block_content = clean_html(block.get("content") or "")
+          parts.append(f"{block_text}\n{block_content}")
+        parts.append(item.get("additionalPlain") or "")
+
+        is_remote = str(item.get("workplaceType", "")).lower() == "remote"
+
+        created_raw = item.get("createdAt")
+        posted = datetime.fromtimestamp(created_raw / 1000, tz=UTC).strftime("%Y-%m-%d") if isinstance(created_raw, (int, float)) else parse_date(str(created_raw) if created_raw else None)
+
+        jobs.append(
+          Job(
+            source=self.name,
+            board=slug,
+            company=slug.replace("-", " ").title(),
+            job_id=job_id,
+            title=title,
+            url=job_url,
+            location=location or "",
+            remote=True if is_remote else None,
+            posted=posted,
+            description="\n\n".join(p for p in parts if p).strip(),
+          )
+        )
+
+      except Exception as e:
+        logger.exception(f"[ {self.name} ] Error parsing job '{job_id}' for '{slug}': {e}")
+        console.print(f"  [red]✖ [ {self.name} ] Error parsing job '{job_id}'[/red]")
+        continue
+
+    return jobs