jobhunter-cli 1.0__py3-none-any.whl

jobhunter/models.py

@@ -0,0 +1,81 @@
+from pydantic import BaseModel, Field, computed_field
+
+from jobhunter.core.settings import settings
+
+
+class Job(BaseModel):
+  source: str
+  board: str
+  company: str
+  job_id: str
+  title: str
+  url: str
+  location: str
+  remote: bool | None = None
+  posted: str = ""
+  description: str
+
+  @computed_field
+  @property
+  def uid(self) -> str:
+    """Dynamically generates a unique identifier for the job."""
+    return f"{self.source}:{self.board}:{self.job_id or self.url}"
+
+
+class Candidate(BaseModel):
+  uid: str = Field(..., description="Unique compound identifier: source:board:job_id_or_url")
+  priority: bool = False
+  stack_hits: int = 0
+  status: str = Field(default="pending", description="Pipeline status: pending, saved, applied, rejected")
+  source: str = ""
+  board: str = ""
+  company: str
+  job_id: str = ""
+  title: str
+  url: str
+  location: str
+  remote: bool | None = None
+  posted: str = ""
+  description: str = ""
+
+  @classmethod
+  def from_job(cls, job: Job, priority: bool, stack_hits: int) -> Candidate:
+    """Factory method to convert a raw scraped Job into a stored Candidate."""
+    max_chars = settings.limits.description_max_chars
+    truncated_description = (job.description or "No description provided.")[:max_chars]
+
+    return cls(
+      uid=job.uid,
+      priority=priority,
+      stack_hits=stack_hits,
+      status="pending",
+      source=job.source,
+      board=job.board,
+      company=job.company,
+      job_id=job.job_id,
+      title=job.title,
+      url=job.url,
+      location=job.location,
+      remote=job.remote,
+      posted=job.posted,
+      description=truncated_description,
+    )
+
+
+class EvaluationResult(BaseModel):
+  """The exact JSON schema the LLM must return."""
+
+  reasoning: str = Field(description="A brief 2-3 sentence thought process analyzing the match before scoring.")
+  hard_fail: bool = Field(description="True if the job hits any hard gate or dealbreaker.")
+  hard_fail_reason: str = Field(default="", description="If hard_fail is true, a max 12-word explanation. Otherwise empty.")
+  strengths: list[str] = Field(description="2-3 short items showing requirements explicitly met by the CV.")
+  gaps: list[str] = Field(default_factory=list, description="Missing requirements or weak points compared to the CV.")
+  score: int = Field(description="Final match score (0-100) based on the rubric.")
+  score_explanation: str = Field(description="A 1-2 sentence explanation of exactly why the job passed or failed the score threshold.")
+  pitch: str = Field(default="", description="A short, one-sentence first-person pitch. Empty if score is below threshold.")
+
+
+class EvaluatedCandidate(Candidate):
+  """A candidate that has been evaluated by the AI."""
+
+  evaluation: EvaluationResult

jobhunter/pipeline/evaluate.py

@@ -0,0 +1,284 @@
+import concurrent.futures
+import logging
+import time
+
+import openai
+from openai import OpenAI
+from pydantic import ValidationError
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn
+from rich.table import Column
+
+from jobhunter.core.logger import console
+from jobhunter.core.paths import DATA_PATH, read, write
+from jobhunter.core.settings import settings
+from jobhunter.models import Candidate, EvaluatedCandidate, EvaluationResult
+from jobhunter.tools.prompt import build_system_prompt, build_user_prompt
+
+logger = logging.getLogger(__name__)
+
+
+def setup_llm_client() -> OpenAI:
+  """Initializes the OpenAI client (supports local Ollama/vLLM via base_url)."""
+  logger.info("Initializing LLM client...")
+
+  if not settings.llm_api_key:
+    logger.error("LLM API key is missing. Set LLM_API_KEY in your .env file.")
+    console.print("[bold red]Error: LLM API key is missing. Set LLM_API_KEY in your .env file.[/bold red]")
+    raise ValueError("LLM_API_KEY is empty. Check your .env file.")
+
+  return OpenAI(
+    api_key=settings.llm_api_key,
+    base_url=settings.llm.base_url,
+  )
+
+
+def build_evaluation_tasks(job_uid: str | None = None, limit: int | None = None) -> list[Candidate]:
+  """Loads candidates from disk and filters for those pending evaluation."""
+  logger.info("Building evaluation tasks...")
+
+  raw_candidates = read(DATA_PATH / "candidates.json", list)
+  raw_evals = read(DATA_PATH / "evaluated.json", list)
+
+  evaluated_uids = {item.get("uid") for item in raw_evals if "uid" in item}
+
+  tasks = []
+  for item in raw_candidates:
+    try:
+      c = Candidate(**item)
+
+      if job_uid:
+        if c.uid == job_uid:
+          tasks.append(c)
+          break
+        continue
+
+      if c.uid not in evaluated_uids:
+        tasks.append(c)
+    except Exception as e:
+      logger.error(f"Failed to parse candidate {item.get('uid', 'unknown')}: {e}")
+      console.print(f"  [red]✖ Failed to parse candidate {item.get('uid', 'unknown')}[/red]")
+
+  final_limit = limit or settings.limits.max_candidates_per_run
+  if final_limit and final_limit > 0:
+    tasks = tasks[:final_limit]
+
+  logger.info(f"Generated {len(tasks)} evaluation tasks from {len(raw_candidates)} total candidates.")
+
+  return tasks
+
+
+def evaluate_single_job(client: OpenAI, system_prompt: str, candidate: Candidate, retries: int = 5, backoff: float = 1.5) -> tuple[Candidate, EvaluationResult | None]:
+  """Calls the LLM to evaluate a single job and parses the result with automatic retry and JSON cleanup fallbacks."""
+  user_prompt = build_user_prompt(candidate)
+
+  for attempt in range(retries):
+    raw_json = ""
+
+    try:
+      response = client.chat.completions.create(
+        model=settings.llm.model or "gpt-4o-mini",
+        messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}],
+        response_format={"type": "json_object"},
+        temperature=settings.llm.temperature,
+        timeout=settings.llm.timeout,
+      )
+
+      raw_json = response.choices[0].message.content or ""
+      if not raw_json:
+        raise ValueError("LLM returned empty content instead of JSON.")
+
+      try:
+        eval_result = EvaluationResult.model_validate_json(raw_json)
+        return candidate, eval_result
+
+      except ValidationError:
+        cleaned_json = raw_json.strip()
+        if cleaned_json.startswith("```json"):
+          cleaned_json = cleaned_json[7:]
+        if cleaned_json.endswith("```"):
+          cleaned_json = cleaned_json[:-3]
+        cleaned_json = cleaned_json.strip()
+
+        eval_result = EvaluationResult.model_validate_json(cleaned_json)
+        return candidate, eval_result
+
+    except openai.RateLimitError as rle:
+      if attempt < retries - 1:
+        sleep_time = backoff * (2**attempt)
+        logger.warning(f"Rate limit hit (429) for {candidate.company}. Retrying in {sleep_time}s (Attempt {attempt + 1}/{retries})...")
+        time.sleep(sleep_time)
+      else:
+        logger.error(f"Rate limit exceeded max retries for {candidate.company}: {rle}")
+        console.print(f"  [red]✖ Rate limit exceeded for {candidate.company} after {retries} retries.[/red]")
+        return candidate, None
+
+    except openai.APIStatusError as ase:
+      if ase.status_code >= 500 and attempt < retries - 1:
+        sleep_time = backoff * (2**attempt)
+        time.sleep(sleep_time)
+      else:
+        console.print("\n───────── API ERROR DETAILS ─────────")
+        console.print(ase.response.json() if hasattr(ase, "response") else str(ase))
+        console.print("───────────────────────────────────────\n")
+        return candidate, None
+
+    except ValidationError as ve:
+      logger.error(f"AI returned invalid schema for {candidate.company}: {ve}")
+      console.print(f"  [red]✖ AI returned invalid schema for {candidate.company}[/red]")
+      logger.debug(f"Offending raw JSON for {candidate.company}:\n{raw_json}")
+      return candidate, None
+
+    except Exception as e:
+      logger.error(f"LLM API error evaluating {candidate.company}: {e}")
+      console.print(f"  [red]✖ LLM API error evaluating {candidate.company}: {e}[/red]")
+      return candidate, None
+
+  return candidate, None
+
+
+def execute_evaluation_tasks(client: OpenAI, tasks: list[Candidate]) -> list[tuple[Candidate, EvaluationResult | None]]:
+  """Executes the AI evaluation tasks concurrently with a Rich progress bar."""
+  fetched_evals: list[tuple[Candidate, EvaluationResult | None]] = []
+  system_prompt = build_system_prompt()
+  target_total = len(tasks)
+
+  workers = max(1, min(settings.workers.evaluation_workers, 20))
+
+  logger.info(f"Executing evaluation tasks across {target_total} targets with {workers} workers.")
+  console.print(f"[bold cyan]Evaluating {target_total} jobs with AI...[/bold cyan]")
+
+  with Progress(
+    SpinnerColumn("dots", style="cyan"),
+    TextColumn("{task.description}", table_column=Column(ratio=1)),
+    TextColumn("[dim]{task.completed}/{task.total}[/dim]"),
+    BarColumn(bar_width=24, style="dim cyan", complete_style="green", finished_style="bold green"),
+    TaskProgressColumn(),
+    expand=True,
+    console=console,
+  ) as progress:
+    eval_task = progress.add_task("[cyan]Starting evaluation...", total=target_total)
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
+      future_to_candidate = {executor.submit(evaluate_single_job, client, system_prompt, candidate): candidate for candidate in tasks}
+
+      for future in concurrent.futures.as_completed(future_to_candidate):
+        candidate = future_to_candidate[future]
+        name = candidate.company or "Unknown"
+
+        try:
+          result = future.result(timeout=settings.llm.timeout + 10)
+          fetched_evals.append(result)
+
+          if result[1] is not None:
+            score = result[1].score
+            color = "green" if score >= settings.evaluating.score_threshold else "yellow"
+            progress.update(eval_task, advance=1, description=f"[cyan]Evaluating... [dim](Finished {name} - [{color}]{score}[/{color}][/dim])")
+          else:
+            progress.update(eval_task, advance=1)
+            progress.console.print(f"  [dim red]⚠ API/Validation Error for {name}. Skipping...[/dim red]")
+
+        except concurrent.futures.TimeoutError:
+          logger.error(f"Task for {name} timed out.")
+          console.print(f"  [red]✖ Evaluation for {name} timed out.[/red]")
+          progress.update(eval_task, advance=1)
+
+        except Exception as e:
+          logger.exception(f"Error executing evaluation task for {name}: {e}")
+          console.print(f"  [red]✖ Error evaluating {name}: {e}[/red]")
+          progress.update(eval_task, advance=1)
+
+        if settings.llm.request_delay > 0:
+          time.sleep(settings.llm.request_delay)
+
+    progress.update(eval_task, description="[bold green]Evaluation complete![/bold green]")
+
+  success_count = sum(1 for _, eval_result in fetched_evals if eval_result is not None)
+
+  logger.info(f"Successfully evaluated {success_count} jobs.")
+
+  return fetched_evals
+
+
+def format_evaluation_results(fetched_evals: list[tuple[Candidate, EvaluationResult | None]]) -> tuple[list[EvaluatedCandidate], int, int, int, int]:
+  """Formats the AI results into EvaluatedCandidate models and calculates metrics."""
+  logger.info("Formatting LLM results and calculating statistics...")
+  console.print("[dim cyan]Formatting evaluations...[/dim cyan]")
+
+  passed = hard_failed = low_score = errors = 0
+  final_evaluations: list[EvaluatedCandidate] = []
+
+  for candidate, evaluation in fetched_evals:
+    if not evaluation:
+      errors += 1
+      continue
+
+    candidate.status = "evaluated"
+
+    evaluated_candidate = EvaluatedCandidate(**candidate.model_dump(), evaluation=evaluation)
+
+    if evaluation.hard_fail:
+      hard_failed += 1
+      logger.debug(f"Candidate {candidate.company} hard failed gates.")
+    elif evaluation.score < settings.evaluating.score_threshold:
+      low_score += 1
+      logger.debug(f"Candidate {candidate.company} failed score threshold ({evaluation.score}).")
+    else:
+      passed += 1
+
+    final_evaluations.append(evaluated_candidate)
+
+  logger.info(f"Formatting complete. {passed} passed, {hard_failed} hard failed, {low_score} low score, {errors} errors.")
+
+  return final_evaluations, passed, hard_failed, low_score, errors
+
+
+def save_evaluation_results(final_evaluations: list[EvaluatedCandidate]):
+  """Saves evaluated candidates to disk, preventing duplicate UIDs, and sorts by score."""
+  logger.info("Saving evaluations...")
+  console.print("[dim cyan]Saving evaluations...[/dim cyan]")
+
+  existing_evals = read(DATA_PATH / "evaluated.json", list)
+
+  new_uids = {c.uid for c in final_evaluations}
+  filtered_evals = [e for e in existing_evals if e.get("uid") not in new_uids]
+
+  new_eval_dicts = [c.model_dump(mode="json") for c in final_evaluations]
+
+  filtered_evals.extend(new_eval_dicts)
+  filtered_evals.sort(key=lambda x: x.get("evaluation", {}).get("score", -1), reverse=True)
+
+  write(DATA_PATH / "evaluated.json", filtered_evals)
+
+  logger.info(f"Successfully saved {len(final_evaluations)} evaluations to disk.")
+
+
+def main(job_uid: str | None = None, limit: int | None = None):
+  """Orchestrates the AI evaluation pipeline."""
+  logger.info("Starting AI Evaluation Pipeline run.")
+
+  client = setup_llm_client()
+
+  tasks = build_evaluation_tasks(job_uid, limit)
+  if not tasks:
+    logger.warning("No active candidates found to evaluate.")
+    console.print("[yellow]No active candidates found to evaluate.[/yellow]")
+    return
+
+  fetched_evals = execute_evaluation_tasks(client, tasks)
+  final_evaluations, passed, hard_failed, low_score, errors = format_evaluation_results(fetched_evals)
+
+  if final_evaluations:
+    save_evaluation_results(final_evaluations)
+
+  total_successful = passed + hard_failed + low_score
+  logger.info(f"Pipeline finished. Evaluated: {total_successful} | Passed: {passed} | Hard Failed: {hard_failed} | Low Score: {low_score} | Errors: {errors}")
+
+  console.print("\n[bold]AI Evaluation Summary[/bold]")
+  console.print("───────────────────────────────────────")
+  console.print(f"Total evaluated : [cyan]{total_successful}[/cyan]")
+  console.print(f"Passed          : [bold green]{passed}[/bold green]")
+  console.print(f"Failed (Gates)  : [red]{hard_failed}[/red]")
+  console.print(f"Failed (Score)  : [yellow]{low_score}[/yellow]")
+  if errors:
+    console.print(f"API Errors      : [bold red]{errors}[/bold red]")
+  console.print("───────────────────────────────────────\n")

jobhunter/pipeline/fetch.py

@@ -0,0 +1,233 @@
+import concurrent.futures
+import logging
+
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn
+from rich.table import Column
+
+from jobhunter.core.filters import count_stack_hits, passes_all_filters
+from jobhunter.core.logger import console
+from jobhunter.core.paths import DATA_PATH, read, write
+from jobhunter.core.settings import settings
+from jobhunter.models import Candidate, Job
+from jobhunter.sources import SOURCES
+
+logger = logging.getLogger(__name__)
+
+
+def build_fetch_tasks(source_name: str | None, no_aggregators: bool) -> list[tuple]:
+  """Generates a list of (source, slug) tuples to be scraped."""
+  logger.info("Building fetch tasks...")
+
+  tasks = []
+  for name, source in SOURCES.items():
+    if source_name and name != source_name:
+      continue
+
+    is_aggregator = getattr(source, "is_aggregator", False)
+
+    if is_aggregator and not no_aggregators:
+      tasks.append((source, ""))
+    else:
+      slugs = settings.companies.get(name, [])
+      for slug in slugs:
+        tasks.append((source, slug))
+
+  logger.info(f"Generated {len(tasks)} fetch tasks.")
+
+  return tasks
+
+
+def execute_fetch_tasks(tasks: list[tuple]) -> list[Job]:
+  """Executes the scraping tasks concurrently with a Rich progress bar."""
+  fetched_jobs: list[Job] = []
+  target_total = len(tasks)
+
+  workers = max(1, min(settings.workers.fetch_workers, 20))
+
+  logger.info(f"Executing fetch tasks across {target_total} targets with {workers} workers.")
+  console.print("[bold cyan]Fetching jobs from configured sources...[/bold cyan]")
+
+  with Progress(
+    SpinnerColumn("dots", style="cyan"),
+    TextColumn("{task.description}", table_column=Column(ratio=1)),
+    TextColumn("[dim]{task.completed}/{task.total}[/dim]"),
+    BarColumn(bar_width=24, style="dim cyan", complete_style="green", finished_style="bold green"),
+    TaskProgressColumn(),
+    expand=True,
+    console=console,
+  ) as progress:
+    fetch_task = progress.add_task("[cyan]Starting fetch...", total=target_total)
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
+      future_to_name = {}
+      for source, slug in tasks:
+        name = f"{source.name}:{slug}" if slug else source.name
+        future = executor.submit(source.execute_scraper, slug)
+        future_to_name[future] = name
+
+      for future in concurrent.futures.as_completed(future_to_name):
+        name = future_to_name[future]
+
+        try:
+          result = future.result(timeout=60)
+          if result:
+            fetched_jobs.extend(result)
+
+          progress.update(fetch_task, advance=1, description=f"[cyan]Fetching... [dim](Finished {name})[/dim]")
+
+        except concurrent.futures.TimeoutError:
+          logger.error(f"Task for {name} timed out.")
+          console.print(f"  [red]✖ Task for {name} timed out.[/red]")
+          progress.update(fetch_task, advance=1)
+
+        except Exception as e:
+          logger.exception(f"Error executing fetch task for {name}: {e}")
+          console.print(f"  [red]✖ Error fetching {name}: {e}[/red]")
+          progress.update(fetch_task, advance=1)
+
+    progress.update(fetch_task, description="[bold green]Fetch complete![/bold green]")
+
+  logger.info(f"Successfully fetched {len(fetched_jobs)} raw jobs.")
+
+  return fetched_jobs
+
+
+def filter_fetch_results(jobs: list[Job], ignore_seen: bool) -> tuple[list[Job], int, int, int, int]:
+  """Removes previously seen jobs, cross-source duplicates, and jobs failing filters."""
+  logger.info("Filtering and deduplicating jobs...")
+  console.print("[dim cyan]Filtering and deduplicating jobs...[/dim cyan]")
+
+  raw_candidates = read(DATA_PATH / "candidates.json", list)
+  seen_data = read(DATA_PATH / "seen.json", dict)
+
+  fetched_uids = {item.get("uid") for item in raw_candidates if "uid" in item}
+
+  skipped_pend = skipped_seen = skipped_dupes = skipped_filters = 0
+  run_duped_roles = set()
+  passing_jobs = []
+
+  for job in jobs:
+    if job.uid in fetched_uids:
+      skipped_pend += 1
+      continue
+
+    if job.uid in seen_data and not ignore_seen:
+      skipped_seen += 1
+      continue
+
+    company = (job.company or "Unknown").strip().lower()
+    title = (job.title or "Unknown").strip().lower()
+    location = (job.location or "Unknown").strip().lower()
+    role_key = f"{company}:{title}:{location}"
+
+    if role_key in run_duped_roles:
+      skipped_dupes += 1
+      continue
+
+    run_duped_roles.add(role_key)
+
+    if passes_all_filters(job):
+      passing_jobs.append(job)
+    else:
+      skipped_filters += 1
+
+  logger.info(f"Filtering complete: {len(passing_jobs)} passed, {skipped_pend} skipped (pend), {skipped_seen} skipped (seen), {skipped_dupes} dupes, {skipped_filters} failed filters.")
+
+  return passing_jobs, skipped_pend, skipped_seen, skipped_dupes, skipped_filters
+
+
+def score_fetch_results(jobs: list[Job]) -> list[Candidate]:
+  """Calculates scores, sorts candidates, and converts Jobs into Candidates."""
+  logger.info("Scoring and sorting passing jobs...")
+  console.print("[dim cyan]Scoring and sorting candidates...[/dim cyan]")
+
+  priority_companies = {c.lower() for c in settings.filters.company_priority}
+
+  scored_candidates: list[Candidate] = []
+  for job in jobs:
+    is_priority = (job.company or "").lower() in priority_companies
+    hits = count_stack_hits(job)
+    candidate = Candidate.from_job(job, priority=is_priority, stack_hits=hits)
+    scored_candidates.append(candidate)
+
+  scored_candidates.sort(key=lambda c: (c.priority, c.stack_hits), reverse=True)
+
+  return scored_candidates
+
+
+def limit_fetch_results(scored_candidates: list[Candidate], limit: int | None = None) -> tuple[list[Candidate], int]:
+  """Enforces the max candidate limit."""
+  logger.info("Enforcing limits...")
+  console.print("[dim cyan]Enforcing candidate limits...[/dim cyan]")
+
+  final_limit = limit or settings.limits.max_candidates_per_run
+
+  final_candidates = []
+  non_priority_count = 0
+
+  for candidate in scored_candidates:
+    if not candidate.priority:
+      if non_priority_count >= final_limit:
+        continue
+      non_priority_count += 1
+
+    final_candidates.append(candidate)
+
+  cut_over_cap = len(scored_candidates) - len(final_candidates)
+
+  logger.info(f"Generated {len(final_candidates)} candidates. Cut {cut_over_cap} jobs over the cap.")
+
+  return final_candidates, cut_over_cap
+
+
+def save_fetch_results(final_candidates: list[Candidate]):
+  """Saves finalized candidates into disk, preventing duplicate UIDs."""
+  logger.info("Saving candidates...")
+  console.print("[dim cyan]Saving candidates...[/dim cyan]")
+
+  existing_candidates = read(DATA_PATH / "candidates.json", list)
+
+  new_uids = {c.uid for c in final_candidates}
+  filtered_existing = [c for c in existing_candidates if c.get("uid") not in new_uids]
+
+  new_candidate_dicts = [c.model_dump(mode="json") for c in final_candidates]
+
+  filtered_existing.extend(new_candidate_dicts)
+  filtered_existing.sort(key=lambda x: (x.get("priority", False), x.get("stack_hits", 0)), reverse=True)
+
+  write(DATA_PATH / "candidates.json", filtered_existing)
+
+  logger.info(f"Successfully saved {len(final_candidates)} candidates to disk.")
+
+
+def main(source_name: str | None = None, no_aggregators: bool = False, ignore_seen: bool = False, limit: int | None = None):
+  """Orchestrates the job fetching pipeline."""
+  logger.info("Starting job fetch pipeline run.")
+
+  tasks = build_fetch_tasks(source_name, no_aggregators)
+  if not tasks:
+    logger.warning("No active sources/companies found to scrape.")
+    console.print("[yellow]No active sources/companies found to scrape.[/yellow]")
+    return
+
+  fetched_jobs = execute_fetch_tasks(tasks)
+
+  passing_jobs, skipped_pend, skipped_seen, skipped_dupes, skipped_filters = filter_fetch_results(fetched_jobs, ignore_seen)
+  scored_candidates = score_fetch_results(passing_jobs)
+  final_candidates, cut_over_cap = limit_fetch_results(scored_candidates, limit)
+
+  if final_candidates:
+    save_fetch_results(final_candidates)
+
+  logger.info(f"Pipeline finished. Raw: {len(fetched_jobs)} | Pend: {skipped_pend} | Seen: {skipped_seen} | Dupe: {skipped_dupes} | Failed Filters: {skipped_filters} | Cut: {cut_over_cap} | Candidates: {len(final_candidates)}")
+
+  console.print("\n[bold]Fetch Summary[/bold]")
+  console.print("───────────────────────────────────────")
+  console.print(f"Total raw jobs  : [cyan]{len(fetched_jobs)}[/cyan]")
+  console.print(f"Skipped (pend)  : [yellow]{skipped_pend}[/yellow]")
+  console.print(f"Skipped (seen)  : [yellow]{skipped_seen}[/yellow]")
+  console.print(f"Skipped (dupe)  : [yellow]{skipped_dupes}[/yellow]")
+  console.print(f"Failed filters  : [magenta]{skipped_filters}[/magenta]")
+  console.print(f"Cut over cap    : [yellow]{cut_over_cap}[/yellow]")
+  console.print(f"New candidates  : [bold green]{len(final_candidates)}[/bold green]")
+  console.print("───────────────────────────────────────\n")