linkfetch 0.1.0__py3-none-any.whl

linkfetch/parse/recommendations.py

@@ -0,0 +1,64 @@
+"""Parse the Recommendations (received) details page.
+
+Ordered fragments per entry::
+
+    [author, "· 1st", author_title, "<date>, <relationship>",
+     "All LinkedIn members", "On", <body>]
+
+The connection-degree ("· 1st"), visibility ("All LinkedIn members", "On") and
+expand ("… more") fragments are skipped. The relationship is the clause after
+the date; the body is the expandable text box.
+"""
+
+from __future__ import annotations
+
+from linkfetch.models import Recommendation
+from linkfetch.parse.common import description_text, entry_items, ordered_texts
+from linkfetch.text import clean, slugify
+
+_SKIP = {"all linkedin members", "on", "off", "… more", "…", "more"}
+
+
+def parse(html: str) -> list[Recommendation]:
+    out: list[Recommendation] = []
+    for el in entry_items(html):
+        texts = ordered_texts(el)
+        if not texts:
+            continue
+        author = texts[0]
+
+        author_title = relationship = None
+        for frag in texts[1:]:
+            low = frag.lower()
+            if frag.startswith("·") or low in _SKIP:
+                continue
+            if relationship is None and _is_relationship(frag):
+                relationship = _relationship_clause(frag)
+            elif author_title is None:
+                author_title = frag
+
+        out.append(
+            Recommendation(
+                id=slugify(author),
+                author=author,
+                author_title=author_title,
+                relationship=relationship,
+                text=description_text(el),
+            )
+        )
+    return out
+
+
+def _is_relationship(frag: str) -> bool:
+    low = frag.lower()
+    return ("managed" in low or "worked with" in low or "was senior" in low
+            or "studied" in low or "taught" in low or "reported" in low)
+
+
+def _relationship_clause(frag: str) -> str | None:
+    """``"April 4, 2020, John was senior to Jane"`` -> the clause after the date."""
+    # Date prefix ends at the second comma ("Month D, YYYY,"); keep the rest.
+    parts = frag.split(",")
+    if len(parts) >= 3:
+        return clean(",".join(parts[2:]))
+    return clean(frag)

linkfetch/parse/skills.py

@@ -0,0 +1,30 @@
+"""Parse the Skills details page.
+
+Each entry's first visible fragment is the skill name; a second fragment gives
+the context where it was used ("Senior Software Development Engineer at Roche"),
+which we keep as the skill ``summary``. Duplicates are dropped; categorization is
+left to the user in tailor.
+"""
+
+from __future__ import annotations
+
+from linkfetch.models import Skill
+from linkfetch.parse.common import entry_items, ordered_texts
+from linkfetch.text import slugify
+
+
+def parse(html: str) -> list[Skill]:
+    out: list[Skill] = []
+    seen: set[str] = set()
+    for el in entry_items(html):
+        texts = ordered_texts(el)
+        if not texts:
+            continue
+        name = texts[0]
+        key = name.lower()
+        if key in seen:
+            continue
+        seen.add(key)
+        summary = texts[1] if len(texts) > 1 else None
+        out.append(Skill(id=slugify(name), name=name, summary=summary))
+    return out

linkfetch/parse/volunteering.py

@@ -0,0 +1,47 @@
+"""Parse the Volunteering details page.
+
+Ordered fragments per entry::
+
+    [role, org, "date range · duration", cause, <description>]
+"""
+
+from __future__ import annotations
+
+from linkfetch.models import Timeline, Volunteering
+from linkfetch.parse.common import (
+    description_text,
+    entry_items,
+    looks_like_dates,
+    ordered_texts,
+    split_timeline,
+)
+from linkfetch.text import slugify
+
+
+def parse(html: str) -> list[Volunteering]:
+    out: list[Volunteering] = []
+    for el in entry_items(html):
+        texts = ordered_texts(el)
+        if not texts:
+            continue
+        role = texts[0]
+        org = texts[1] if len(texts) > 1 else None
+
+        start = end = cause = None
+        for frag in texts[2:]:
+            if start is None and looks_like_dates(frag):
+                start, end = split_timeline(frag)
+            elif cause is None and not looks_like_dates(frag):
+                cause = frag
+
+        out.append(
+            Volunteering(
+                id=slugify(org, role),
+                org=org or role,
+                role=role,
+                cause=cause,
+                timeline=Timeline(start=start, end=end) if start else None,
+                summary=description_text(el),
+            )
+        )
+    return out

linkfetch/sections.py

@@ -0,0 +1,84 @@
+"""Section registry — the single source of truth for what linkfetch handles.
+
+Each Section ties together:
+  - ``slug``: the linkfetch identifier (used on the CLI and as the capture filename)
+  - ``detail_path``: LinkedIn details-page path template ('{vanity}' filled in);
+    None for ``basics`` which comes from the main profile page
+  - ``parser``: the pure ``parse(html)`` callable
+  - ``out_file`` / ``top_key``: where parsed YAML is written and under what key
+  - ``mapped``: True if the output file is one of the profile files THRIVE and
+    tailor read (``data/profile/<name>.yaml``); ``honors`` is an extra,
+    richer copy of awards and is not
+
+Note ``honors`` and ``awards`` share the same source page ('honors') but produce
+two different output files (the trimmed tailor Award + the richer extra Honor).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from linkfetch.parse import (
+    awards,
+    basics,
+    certifications,
+    courses,
+    education,
+    experience,
+    honors,
+    languages,
+    patents,
+    projects,
+    recommendations,
+    skills,
+    volunteering,
+)
+
+
+@dataclass(frozen=True)
+class Section:
+    slug: str
+    detail_path: str | None  # '{vanity}' placeholder; None => main profile page
+    parser: Callable[[str], object]
+    out_file: str
+    top_key: str
+    mapped: bool
+    source: str | None = None  # capture filename to reuse; defaults to slug
+
+    @property
+    def capture_name(self) -> str:
+        return self.source or self.slug
+
+
+# Ordered for a sensible run sequence (identity first).
+SECTIONS: list[Section] = [
+    Section("basics", None, basics.parse, "basics.yaml", "basics", True),
+    Section("experience", "/in/{vanity}/details/experience/", experience.parse, "experiences.yaml", "experiences", True),
+    Section("education", "/in/{vanity}/details/education/", education.parse, "education.yaml", "education", True),
+    Section("skills", "/in/{vanity}/details/skills/", skills.parse, "skills.yaml", "skills", True),
+    Section("projects", "/in/{vanity}/details/projects/", projects.parse, "projects.yaml", "projects", True),
+    Section("certifications", "/in/{vanity}/details/certifications/", certifications.parse, "certifications.yaml", "certifications", True),
+    Section("awards", "/in/{vanity}/details/honors/", awards.parse, "awards.yaml", "awards", True, source="honors"),
+    Section("honors", "/in/{vanity}/details/honors/", honors.parse, "honors.yaml", "honors", False),
+    Section("volunteering", "/in/{vanity}/details/volunteering-experiences/", volunteering.parse, "volunteering.yaml", "volunteering", True),
+    Section("recommendations", "/in/{vanity}/details/recommendations/", recommendations.parse, "recommendations.yaml", "recommendations", True),
+    Section("patents", "/in/{vanity}/details/patents/", patents.parse, "patents.yaml", "patents", True),
+    Section("courses", "/in/{vanity}/details/courses/", courses.parse, "courses.yaml", "courses", True),
+    Section("languages", "/in/{vanity}/details/languages/", languages.parse, "languages.yaml", "languages", True),
+]
+
+BY_SLUG: dict[str, Section] = {s.slug: s for s in SECTIONS}
+
+
+def resolve(slugs: list[str] | None) -> list[Section]:
+    """Return the requested sections (all if ``slugs`` is None/empty)."""
+    if not slugs:
+        return list(SECTIONS)
+    unknown = [s for s in slugs if s not in BY_SLUG]
+    if unknown:
+        raise ValueError(
+            f"Unknown section(s): {', '.join(unknown)}. "
+            f"Valid: {', '.join(BY_SLUG)}"
+        )
+    return [BY_SLUG[s] for s in slugs]

linkfetch/text.py

@@ -0,0 +1,78 @@
+"""Small text helpers shared across parsers."""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+
+def slugify(*parts: str | None) -> str:
+    """Build a stable, filesystem/YAML-friendly slug from one or more parts.
+
+    Used for model ``id`` fields so re-running the scrape yields diffable YAML.
+    Empty/None parts are dropped. Falls back to ``item`` if nothing usable.
+    """
+    joined = " ".join(p for p in parts if p)
+    norm = unicodedata.normalize("NFKD", joined)
+    norm = norm.encode("ascii", "ignore").decode("ascii")
+    norm = norm.lower()
+    norm = re.sub(r"[^a-z0-9]+", "-", norm).strip("-")
+    return norm or "item"
+
+
+def clean(text: str | None) -> str | None:
+    """Collapse whitespace; return None for empty results."""
+    if text is None:
+        return None
+    collapsed = re.sub(r"[ \t ]+", " ", text)
+    lines = [ln.strip() for ln in collapsed.splitlines()]
+    result = "\n".join(ln for ln in lines if ln).strip()
+    return result or None
+
+
+_BULLET_GLYPH = re.compile(r"[•‣◦]")
+_LEADING_PUNCT = re.compile(r"^[\-\*·]+\s*")
+
+
+def split_bullets(text: str | None) -> list[str]:
+    """Split a description blob into bullets.
+
+    A LinkedIn description mixes two things, sometimes in the same blob:
+
+    * Plain ``<br/>``-separated lines with no bullet glyph — often short
+      headers an author writes before their real bullet list starts (``Role:
+      …``, ``What it is:``, ``Highlights:``), or the entire description when
+      it never uses glyphs at all. Each line here is its own bullet.
+    * ``•``/``‣``/``◦``-prefixed bullets, which are **not** reliably
+      one-per-line: a long bullet is often wrapped across two or more
+      ``<br/>``-separated lines by the author (the wrap is not a second
+      bullet), and two short bullets can sit on the very same line with no
+      break between them at all (the glyph, not the line break, is the
+      boundary).
+
+    So: text up to the first glyph is split one bullet per line, same as a
+    glyph-free description; everything from the first glyph onward is split
+    on the glyph instead, with any line break inside one glyph bullet
+    collapsed back into a space rather than read as a second bullet.
+
+    Deterministic: no AI. Returns [] for empty input.
+    """
+    if not text:
+        return []
+
+    head, *glyph_bullets = _BULLET_GLYPH.split(text)
+    out: list[str] = _plain_lines(head)
+    for part in glyph_bullets:
+        line = " ".join(part.split())
+        if line:
+            out.append(line)
+    return out
+
+
+def _plain_lines(text: str) -> list[str]:
+    out: list[str] = []
+    for raw in text.splitlines():
+        line = _LEADING_PUNCT.sub("", raw.strip()).strip()
+        if line:
+            out.append(line)
+    return out

linkfetch-0.1.0.dist-info/METADATA

@@ -0,0 +1,174 @@
+Metadata-Version: 2.5
+Name: linkfetch
+Version: 0.1.0
+Summary: Capture your own LinkedIn profile on your own computer and turn it into structured profile files
+Project-URL: Homepage, https://github.com/Prosperis/linkfetch
+Project-URL: Issues, https://github.com/Prosperis/linkfetch/issues
+Author: Prosperis
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cv,export,linkedin,playwright,profile,resume
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.10
+Requires-Dist: lxml>=5.0
+Requires-Dist: playwright>=1.44
+Requires-Dist: pydantic>=2.6
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Requires-Dist: typer>=0.12
+Provides-Extra: browser
+Provides-Extra: dev
+Requires-Dist: pytest-mock>=3.12; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# linkfetch
+
+Capture **your own** LinkedIn profile on **your own computer** and turn it into
+structured profile files — every role, description, skill, project,
+certification and more — ready to import into
+[THRIVE](https://prosperis-thrive.vercel.app) or any tool that reads YAML.
+
+LinkedIn's official data export leaves out details the profile page shows.
+linkfetch reads the rendered pages instead, in a real browser window that you
+log into yourself.
+
+## What it does and does not do
+
+- **Runs only on your machine.** linkfetch is not a website or a service. It
+  sends your data nowhere; the files it writes stay in a folder on your
+  computer until you choose to upload them.
+- **Reads only your own profile**, in a browser you log into. It never sees
+  your password: you type it into LinkedIn's own login page.
+- **Deterministic, no AI.** Every field comes straight from the page.
+- **Open source** (MIT), so you can read exactly what it does.
+
+## Install
+
+You need Python 3.10 or newer and [uv](https://docs.astral.sh/uv/) (or
+[pipx](https://pipx.pypa.io/)).
+
+```bash
+uv tool install linkfetch        # or: pipx install linkfetch
+linkfetch doctor                 # shows where data is kept and whether Playwright and a login exist
+playwright install chromium      # one-time download of the browser linkfetch drives
+```
+
+## Use
+
+```bash
+linkfetch login                       # a browser window opens: log in to LinkedIn, then close it
+linkfetch run --vanity your-name      # capture your profile and build the files
+```
+
+`your-name` is the part after `/in/` in your profile address:
+`linkedin.com/in/your-name`.
+
+`run` visits each section of your profile (experience, education, skills, …),
+expands every "see more", saves the pages, and turns them into one YAML file
+per section plus **`linkfetch-profile.zip`**. `linkfetch` prints where they
+are.
+
+### Import into THRIVE
+
+In THRIVE, open **Tailor → Profile → Import** and choose
+`linkfetch-profile.zip`. Review each section before saving.
+
+## Where your data is kept
+
+Installed with `uv tool` or `pipx`, linkfetch keeps everything in your user
+data folder:
+
+| OS | Folder |
+|---|---|
+| Windows | `%LOCALAPPDATA%\linkfetch` |
+| macOS | `~/Library/Application Support/linkfetch` |
+| Linux | `$XDG_DATA_HOME/linkfetch` (usually `~/.local/share/linkfetch`) |
+
+Set `LINKFETCH_HOME` to use a different folder. Inside it:
+
+- `data/browser/` — the browser profile that keeps you logged in to LinkedIn.
+  Treat it like a password; delete it to log out.
+- `data/captures/` — the saved profile pages.
+- `data/output/` — the YAML files and `linkfetch-profile.zip`.
+
+Delete the folder to remove everything linkfetch stored.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `linkfetch doctor` | Show the data folders and check Playwright and your login |
+| `linkfetch login` | Open a browser window to log in to LinkedIn once |
+| `linkfetch capture --vanity <you>` | Save your profile pages (needs the browser) |
+| `linkfetch parse` | Turn saved pages into YAML and the ZIP (no browser; re-runnable) |
+| `linkfetch run --vanity <you>` | `capture` then `parse` |
+
+Use `--section experience --section skills` to limit a run to some sections,
+and `parse --no-zip` to skip the ZIP.
+
+## Output
+
+One file per section, each a list under a top-level key:
+`basics.yaml`, `experiences.yaml`, `education.yaml`, `skills.yaml`,
+`projects.yaml`, `certifications.yaml`, `awards.yaml`, `languages.yaml`,
+`courses.yaml`, `patents.yaml`, `recommendations.yaml`, `volunteering.yaml`,
+plus `honors.yaml` (a richer copy of awards, not included in the ZIP).
+Experiences keep their full description as a summary plus bullets, and roles
+at the same company stay grouped.
+
+## How it works
+
+1. **Capture** (needs the browser, runs rarely): a persistent Chromium profile
+   you logged into visits each section's details page
+   (`/in/<you>/details/experience/`, …), expands collapsed content, and saves
+   the rendered HTML.
+2. **Parse** (pure, offline): reads the saved HTML with `lxml` and writes YAML.
+   If LinkedIn changes its pages, a parser fix plus `linkfetch parse` is enough
+   — no need to capture again.
+
+## Development
+
+```bash
+git clone https://github.com/Prosperis/linkfetch
+cd linkfetch
+uv venv && uv pip install -e ".[dev]"
+playwright install chromium
+uv run pytest
+```
+
+A checkout keeps its data in `data/` next to `config.toml`, which also holds
+browser settings (headless mode, timeouts, scroll pacing). Test fixtures are
+anonymized excerpts of LinkedIn's page structure.
+
+## Releasing
+
+Bump `version` in `pyproject.toml`, commit, then push a matching tag:
+
+```bash
+git tag v0.1.1 && git push origin v0.1.1
+```
+
+The Release workflow tests, builds and publishes to PyPI through trusted
+publishing (no stored token), then creates the GitHub release.
+
+## Legal note
+
+LinkedIn's User Agreement restricts automated access. linkfetch is meant for
+**personal use on your own profile**: it uses a browser you logged into, moves
+at a human pace, reads only your own data and stores nothing remotely. Use it
+on your own account and at your own discretion.
+
+## License
+
+[MIT](LICENSE) © Prosperis

linkfetch-0.1.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+linkfetch/__init__.py,sha256=9gf-qPA4WRfBjcbdAvhTSEmhTASb8VYYM3KwwNI6YTE,107
+linkfetch/cli.py,sha256=TUJ7EIC83Jm_bkW1aZmFKExPzo-qsO-6qI7IYX1Lkjk,9797
+linkfetch/config.py,sha256=lrpZmwYFcpLirc4qcAjkw6Q-Q4YBudZjScQ4VRsyA5Y,3436
+linkfetch/emit.py,sha256=PoKfOHgeqM-wDC0q2JrUOnew1dNtlkYD9HWceCnSNFk,1856
+linkfetch/models.py,sha256=QWOEFik9HP0NARwo26lTYCS4cPEsY4-1fqdwR-H0Qg4,5355
+linkfetch/sections.py,sha256=DdL9wwB7CM3weftkgco5UFCJdawy6J6Rd7d1S67pjjM,3601
+linkfetch/text.py,sha256=dyzenT4CqDLbY9KBECMzV-0NrtkO00OyIa-ZW-c5j38,2770
+linkfetch/capture/__init__.py,sha256=rZMoqGlSznk4wbaOPn7iYgIz8q5IXaoUVa5bWDWLpRk,79
+linkfetch/capture/browser.py,sha256=NW_-XWgzRnRvtG8iyam5bSuRmc3yV9QC4dQMeMaUwMQ,3865
+linkfetch/capture/expand.py,sha256=38fsTiKztiaNxRWfafhHHGRVVu7r_Pqik9jzw7Rt4bQ,2571
+linkfetch/parse/__init__.py,sha256=UNL-bykW3Lb2Gq25zgOZX64Fw7IsJlR4X-zewaUWuU4,1005
+linkfetch/parse/awards.py,sha256=bj59lqNrh2rMzyxbVvBDOHNXRLyW5fcXg8FnV-WImyM,1779
+linkfetch/parse/basics.py,sha256=qSSeqtTNM21yHGlYJ7BK_drNI3c5RMpKvuipmGU1Rn0,2924
+linkfetch/parse/certifications.py,sha256=fg05AEjmgNBfRLj9keu7JML4HrfDVKUNQA0yK-RZ9vU,2157
+linkfetch/parse/common.py,sha256=jJ-FXZHLsevJV8sNVWP5acu8PqA94wAN9O3JC44SNh8,9766
+linkfetch/parse/courses.py,sha256=Uci0wnUssXB5Sl1fGs7HxZ3PrBOzBKBnj8-FYEaPi8A,1059
+linkfetch/parse/education.py,sha256=ur7RkyNl1YYP9vFl8vQht7IHQnzkOi3qdIPNpm8FxBw,1557
+linkfetch/parse/experience.py,sha256=4cVExE5D3DOVGP249q4JGGRXOwpKT_QrDuNbNE1eh2w,3843
+linkfetch/parse/honors.py,sha256=F_PnXumIMbjggSUHz0_FMZQlmOyWWzrXcoGK9TeSr_Y,968
+linkfetch/parse/languages.py,sha256=R6j1KZLbHKGtBZ5HMvt_1vpP9DAB32bCZlQI2Bs7n3A,697
+linkfetch/parse/patents.py,sha256=bNME4AilwMX6GVqaIpzjTLqsNg7KRIFE-914yZq0_Nk,1974
+linkfetch/parse/projects.py,sha256=UTO7vLsy4QtH1N2Kv1wxwWVlwg1aJJzbQR-TWVRTU-I,1952
+linkfetch/parse/recommendations.py,sha256=pWsGELNIzmnMqQUQW-Wzzddipafi8MV7tY4jkSCDpd8,2114
+linkfetch/parse/skills.py,sha256=Z5YtfCgmq80L17D60ss-Uq1NC-LoUHcbdHWHUxn7Zkc,940
+linkfetch/parse/volunteering.py,sha256=43BbC_mPttys-zCFirf-0jHhQaLBLoHzV4djhgdopPE,1269
+linkfetch-0.1.0.dist-info/METADATA,sha256=eJLJy5MMimoMxmPMFS5NCsu8ZvRqiR3yzhFtLM16s7A,6441
+linkfetch-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+linkfetch-0.1.0.dist-info/entry_points.txt,sha256=qDUzht2Wb4BB4Fenz7HghIUn8gIW6twu4DZviJA-5EY,48
+linkfetch-0.1.0.dist-info/licenses/LICENSE,sha256=LykqJy8VKC9CS8l0vtqS6LZhkQ0fWdUI302VkOARMs4,1066
+linkfetch-0.1.0.dist-info/RECORD,,

linkfetch-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

linkfetch-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+linkfetch = linkfetch.cli:app

linkfetch-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prosperis
+
+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.