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

jobhunter/sources/personio.py

@@ -0,0 +1,124 @@
+import logging
+import re
+import xml.etree.ElementTree as ET
+
+import httpx
+
+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 = "personio"
+  domains = ["personio.de", "personio.com"]
+  url_patterns = [
+    re.compile(r"(?://|https?://)(?!www\.)(?P<slug>[a-zA-Z0-9-]+)\.(?:jobs\.)?personio\.(?:de|com|es|fr|it)"),
+  ]
+
+  def fetch(self, slug: str = "", skip_parsing: bool = False, **kwargs) -> list[Job]:
+    """Fetches job listings from a specific company's Personio XML feed."""
+    if not slug:
+      raise ValueError(f"A company slug must be provided to fetch {self.name} jobs.")
+
+    response = None
+    base_url = ""
+    headers = {"Accept": "application/xml,text/xml,*/*"}
+    last_error = None
+
+    for domain in ("de", "com"):
+      base_url = f"https://{slug}.jobs.personio.{domain}"
+      url = f"{base_url}/xml?language=en"
+
+      try:
+        response = fetch_url(url, headers=headers)
+        break
+      except httpx.HTTPStatusError as e:
+        last_error = e
+        if e.response.status_code == 404:
+          continue
+        raise
+      except httpx.RequestError as e:
+        last_error = e
+        continue
+
+    if not response:
+      if last_error:
+        raise last_error
+      return []
+
+    if skip_parsing:
+      return []
+
+    try:
+      root = ET.fromstring(response.text)
+    except ET.ParseError as exc:
+      logger.error(f"[ {self.name} ] Failed to parse XML for '{slug}': {exc}")
+      console.print(f"  [red]✖ [ {self.name} ] Failed to parse XML for '{slug}'[/red]")
+      return []
+
+    jobs: list[Job] = []
+
+    for position in root.iter("position"):
+
+      def field(tag: str, pos=position) -> str:
+        return (pos.findtext(tag) or "").strip()
+
+      job_id = str(field("id") or "")
+      title = str(field("name") or "")
+      job_url = str(f"{base_url}/job/{job_id}" if job_id else "")
+
+      if not all([job_id, title, job_url]):
+        logger.warning(f"[ {self.name} ] Skipping item with missing required fields: {position.attrib}")
+        console.print(f"  [yellow]⚠ [ {self.name} ] Skipping item with missing required fields.[/yellow]")
+        continue
+
+      try:
+        offices = [field("office")] + [(o.text or "").strip() for o in position.findall("additionalOffices/office")]
+        location = ", ".join(dict.fromkeys(o for o in offices if o))
+
+        sections = []
+        for block in position.findall("jobDescriptions/jobDescription"):
+          name = (block.findtext("name") or "").strip()
+          value = clean_html(block.findtext("value"))
+          if value:
+            sections.append(f"{name}\n{value}" if name else value)
+
+        facts = [
+          f"{label}: {field(tag)}"
+          for label, tag in (
+            ("Seniority", "seniority"),
+            ("Years of experience", "yearsOfExperience"),
+            ("Employment", "employmentType"),
+            ("Schedule", "schedule"),
+          )
+          if field(tag)
+        ]
+
+        description = ("\n".join(facts) + "\n\n" if facts else "") + "\n\n".join(sections)
+
+        jobs.append(
+          Job(
+            source=self.name,
+            board=slug,
+            company=field("subcompany") or slug.replace("-", " ").title(),
+            job_id=job_id,
+            title=title,
+            url=job_url,
+            location=location,
+            remote=None,
+            posted=parse_date(field("createdAt")),
+            description=description,
+          )
+        )
+
+      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/recruitee.py

@@ -0,0 +1,80 @@
+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 = "recruitee"
+  domains = ["recruitee.com"]
+  url_patterns = [
+    re.compile(r"(?://|https?://)?(?:www\.)?(?P<slug>[a-zA-Z0-9-]+)\.recruitee\.com"),
+  ]
+
+  def fetch(self, slug: str = "", skip_parsing: bool = False, **kwargs) -> list[Job]:
+    """Fetches job listings from a specific company's Recruitee API."""
+    if not slug:
+      raise ValueError(f"A company slug must be provided to fetch {self.name} jobs.")
+
+    url = f"https://{slug}.recruitee.com/api/offers/"
+    data = fetch_url(url, expected_type=dict)
+
+    if skip_parsing:
+      return []
+
+    jobs: list[Job] = []
+
+    for item in data.get("offers", []):
+      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 item.get("guid") or item.get("slug") or "")
+      title = str(item.get("title") or "")
+      job_url = str(item.get("careers_url") or 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:
+        location = item.get("location") or ", ".join(x for x in (item.get("city"), item.get("country")) if x)
+
+        description = "\n\n".join(
+          x
+          for x in (
+            clean_html(item.get("description")),
+            clean_html(item.get("requirements")),
+          )
+          if x
+        )
+
+        jobs.append(
+          Job(
+            source=self.name,
+            board=slug,
+            company=item.get("company_name") or slug.replace("-", " ").title(),
+            job_id=job_id,
+            title=title,
+            url=job_url,
+            location=location or "",
+            remote=True if item.get("remote") else None,
+            posted=parse_date(item.get("published_at") or item.get("created_at")),
+            description=description,
+          )
+        )
+
+      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/remoteok.py

@@ -0,0 +1,69 @@
+import logging
+
+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 = "remoteok"
+  domains = ["remoteok.com"]
+  is_aggregator = True
+
+  def fetch(self, slug: str = "", skip_parsing: bool = False, **kwargs) -> list[Job]:
+    """Fetches job listings from a specific company's RemoteOK API."""
+    url = "https://remoteok.com/api"
+    data = fetch_url(url, expected_type=list)
+    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
+
+      if "legal" in item:
+        continue
+
+      job_id = str(item.get("id") or item.get("slug") or "")
+      title = str(item.get("position") or "")
+      job_url = str(item.get("url") or item.get("apply_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}"
+
+        jobs.append(
+          Job(
+            source=self.name,
+            board=self.name,
+            company=item.get("company") or "Unknown",
+            job_id=job_id,
+            title=title,
+            url=job_url,
+            location=item.get("location") or "Remote",
+            remote=True,
+            posted=parse_date(item.get("date")),
+            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
+
+    return jobs

jobhunter/sources/remotive.py

@@ -0,0 +1,61 @@
+import logging
+
+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 = "remotive"
+  domains = ["remotive.com", "remotive.io"]
+  is_aggregator = True
+
+  def fetch(self, slug: str = "", skip_parsing: bool = False, **kwargs) -> list[Job]:
+    """Fetches job listings from Remotive API."""
+    category = self.board_config.get("category", "software-dev") if isinstance(self.board_config, dict) else "software-dev"
+
+    url = f"https://remotive.com/api/remote-jobs?category={category}"
+    data = fetch_url(url, expected_type=dict)
+    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("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:
+        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("candidate_required_location") or "Remote",
+            remote=True,
+            posted=parse_date(item.get("publication_date")),
+            description=clean_html(item.get("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
+
+    return jobs

jobhunter/sources/workable.py

@@ -0,0 +1,94 @@
+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 = "workable"
+  domains = ["apply.workable.com"]
+  url_patterns = [
+    re.compile(r"apply\.workable\.com/(?P<slug>[^/?#]+)"),
+  ]
+
+  @staticmethod
+  def _parse_location(item: dict, location_obj: dict) -> str:
+    """Extracts and formats location data from Workable's messy location fields."""
+    parts = [
+      item.get("city") or location_obj.get("city"),
+      item.get("state") or location_obj.get("region"),
+      item.get("country") or location_obj.get("country"),
+    ]
+    text = ", ".join(p for p in parts if p)
+
+    if text:
+      return text
+
+    names = []
+
+    for entry in item.get("locations") or []:
+      if isinstance(entry, dict):
+        names.append(", ".join(x for x in (entry.get("city"), entry.get("region"), entry.get("country")) if x))
+
+    return " / ".join(n for n in names if n)
+
+  def fetch(self, slug: str = "", skip_parsing: bool = False, **kwargs) -> list[Job]:
+    """Fetches job listings from a specific company's Workable API."""
+    if not slug:
+      raise ValueError(f"A company slug must be provided to fetch {self.name} jobs.")
+
+    url = f"https://apply.workable.com/api/v1/widget/accounts/{slug}?details=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("shortcode") or item.get("id") or item.get("code") or "")
+      title = str(item.get("title") or "")
+      job_url = str(item.get("url") or item.get("shortlink") or item.get("application_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:
+        loc_val = item.get("location")
+        location_obj = loc_val if isinstance(loc_val, dict) else {}
+        is_remote = bool(item.get("telecommuting")) or bool(location_obj.get("telecommuting"))
+
+        jobs.append(
+          Job(
+            source=self.name,
+            board=slug,
+            company=data.get("name") or slug.replace("-", " ").title(),
+            job_id=job_id,
+            title=title,
+            url=job_url,
+            location=self._parse_location(item, location_obj),
+            remote=True if is_remote else None,
+            posted=parse_date(item.get("published_on") or item.get("created_at")),
+            description=clean_html(item.get("description") or item.get("full_description") or ""),
+          )
+        )
+
+      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