warmpath 0.3.1__tar.gz → 0.3.3__tar.gz

{warmpath-0.3.1 → warmpath-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: warmpath
-Version: 0.3.1
+Version: 0.3.3
 Summary: Local LinkedIn visible-connections scraper.
 Requires-Python: >=3.10
 Requires-Dist: browser-cookie3>=0.20.1

warmpath-0.3.3/README.md

@@ -0,0 +1,55 @@
+![Warmpath banner](warmpath.jpg)
+
+# Warmpath
+
+Find LinkedIn mutuals and warm paths using your logged-in browser session.
+
+## Usage
+
+Log in to LinkedIn in a regular browser window, then import that session. Replace `chrome` with your browser's name if needed.
+
+```sh
+# Import and check your browser session
+uvx warmpath auth import --browser chrome
+uvx warmpath auth status
+
+# Find people who can introduce you to a company
+uvx warmpath company HashiCorp
+uvx warmpath company https://www.linkedin.com/company/hashicorp/ --max-degree 2 --limit 5
+
+# Find reachable people with a skill
+uvx warmpath skill Flutter
+uvx warmpath skill Leadership --max-depth 2
+
+# Find mutual connections with a person
+uvx warmpath human https://www.linkedin.com/in/mitchellh/
+
+# Refresh cached results
+uvx warmpath human https://www.linkedin.com/in/mitchellh/ --refresh-cache
+
+# Show options for a command; also works with auth, skill, and human
+uvx warmpath company --help
+```
+
+## Browser sessions
+
+Supported browsers are Chrome, Chromium, Firefox, Edge, Brave, Safari, Arc, Vivaldi, Opera, Opera GX (`opera-gx`), and LibreWolf; availability depends on your operating system. Your OS may ask for keychain/keyring access. If the cookie store is locked, close the browser and retry. Private-window sessions cannot be imported.
+
+Warmpath imports only LinkedIn's `li_at` and `JSESSIONID` cookies and manages the saved session automatically. `company`, `skill`, and `human` use it on subsequent runs. Failed imports preserve the previous session.
+
+`auth import` and `auth status` print only `Logged in as <name>` after confirming your session with LinkedIn. If `auth status` cannot confirm a login, it prints `Not logged in` and exits with status 1. Both commands require a connection to LinkedIn. If the session expires or LinkedIn stops accepting it, log in again and repeat `auth import`.
+
+## Development
+
+Browser cookie import uses [browser-cookie3](https://github.com/borisbabic/browser_cookie3).
+
+[go-task](https://taskfile.dev/) runs the repository checks. Install it with Homebrew on macOS, or follow the [installation guide](https://taskfile.dev/docs/installation) for other platforms. Then verify the tool, install the Python development dependencies, and run the checks:
+
+```sh
+# macOS
+brew install go-task
+
+task --version
+uv sync
+task check
+```

{warmpath-0.3.1 → warmpath-0.3.3}/docs/skill.md

@@ -18,7 +18,7 @@ For the `skill` subcommand, the call path is:
 4. `find_skill_connections(...)`
 5. `render_skill_connections_result(result)`
 
-`run_skill_command` builds a LinkedIn API client from the session saved by `warmpath auth import --browser <browser>`, resolves the cache directory, calls the skill search pipeline, and prints the rendered result. Use `warmpath auth status` to check the saved session's expiry locally.
+`run_skill_command` builds a LinkedIn API client from the session saved by `warmpath auth import --browser <browser>`, resolves the cache directory, calls the skill search pipeline, and prints the rendered result. Use `warmpath auth status` to check whether you are logged in and as whom.
 
 ## Defaults
 

{warmpath-0.3.1 → warmpath-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "warmpath"
-version = "0.3.1"
+version = "0.3.3"
 description = "Local LinkedIn visible-connections scraper."
 requires-python = ">=3.10"
 dependencies = [

{warmpath-0.3.1 → warmpath-0.3.3}/tests/test_auth.py

@@ -6,6 +6,7 @@ from unittest.mock import Mock
 import pytest
 from requests import Request
 from requests.cookies import RequestsCookieJar
+from requests.exceptions import ConnectionError, HTTPError, Timeout
 
 from warmpath import auth, cli
 
@@ -17,6 +18,17 @@ def auth_path(tmp_path, monkeypatch):
     return path
 
 
+@pytest.fixture(autouse=True)
+def profile_fetch(monkeypatch):
+    response = Mock()
+    response.json.return_value = {
+        "miniProfile": {"firstName": "Ada", "lastName": "Lovelace"},
+    }
+    fetch = Mock(return_value=response)
+    monkeypatch.setattr(cli.Linkedin, "_fetch", fetch)
+    return fetch
+
+
 @pytest.fixture
 def browser_cookies():
     jar = RequestsCookieJar()
@@ -136,26 +148,124 @@ def test_imported_session_reaches_linkedin_with_csrf_and_cookie_attributes(reade
     assert "Cookie" not in session.prepare_request(Request("GET", "http://www.linkedin.com/")).headers
 
 
-def test_import_and_status_report_metadata_without_cookie_values(reader, capsys, auth_path):
+def test_import_and_status_print_only_the_logged_in_user(reader, capsys, auth_path, profile_fetch):
     cli.main(["auth", "import", "--browser", "Chrome"])
+    output = capsys.readouterr()
+    assert output.out == "Logged in as Ada Lovelace\n"
+    assert output.err == ""
+    profile_fetch.assert_called_once_with("/me", timeout=15, evade=cli.no_delay)
+    profile_fetch.reset_mock()
     before = auth_path.read_bytes()
     reader.reset_mock()
     cli.main(["auth", "status"])
 
     output = capsys.readouterr()
     assert output.err == ""
-    assert output.out.count("Status: ready (local expiry check)") == 2
-    assert "Browser: chrome" in output.out
-    assert "Imported:" in output.out
-    assert str(auth_path) in output.out
-    assert "Cookie: JSESSIONID; expires: session" in output.out
-    assert "Cookie: li_at; expires: 2100-01-01T00:00:00+00:00" in output.out
-    assert "private-linkedin-token" not in output.out
-    assert "private-csrf-token" not in output.out
+    assert output.out == "Logged in as Ada Lovelace\n"
+    assert auth_path.read_bytes() == before
+    reader.assert_not_called()
+    profile_fetch.assert_called_once_with("/me", timeout=15, evade=cli.no_delay)
+
+
+@pytest.mark.parametrize("command", [["status"], ["import", "--browser", "chrome"]])
+@pytest.mark.parametrize("profile,expected", [
+    ({"firstName": "  Ada ", "lastName": " Lovelace  "}, "Ada Lovelace"),
+    ({"firstName": "Адель", "lastName": "Низамутдинов"}, "Адель Низамутдинов"),
+    ({"firstName": "Ada"}, "Ada"),
+    ({"lastName": "Lovelace"}, "Lovelace"),
+])
+def test_auth_prints_the_logged_in_users_name(command, profile, expected, reader, profile_fetch, capsys):
+    auth.import_browser("chrome")
+    profile_fetch.return_value.json.return_value = {"miniProfile": profile}
+
+    cli.main(["auth", *command])
+
+    output = capsys.readouterr()
+    assert output.out == f"Logged in as {expected}\n"
+    assert output.err == ""
+
+
+@pytest.mark.parametrize("payload", [
+    {}, None, [], {"miniProfile": None}, {"miniProfile": "private-linkedin-token"},
+    {"miniProfile": {"firstName": " ", "lastName": None}},
+    {"miniProfile": {"firstName": ["private-linkedin-token"], "lastName": 123}},
+])
+def test_status_rejects_a_profile_without_a_name(payload, reader, profile_fetch, capsys):
+    auth.import_browser("chrome")
+    profile_fetch.return_value.json.return_value = payload
+
+    with pytest.raises(SystemExit) as error:
+        cli.main(["auth", "status"])
+
+    assert error.value.code == 1
+    output = capsys.readouterr()
+    assert output.out == "Not logged in\n"
+    assert output.err == ""
+
+
+@pytest.mark.parametrize("failure", ["connection", "timeout", "http", "json"])
+def test_status_handles_failed_user_lookup_without_exposing_secrets(failure, reader, profile_fetch, capsys, auth_path):
+    auth.import_browser("chrome")
+    before = auth_path.read_bytes()
+    reader.reset_mock()
+    if failure == "connection":
+        profile_fetch.side_effect = ConnectionError("private-linkedin-token")
+    elif failure == "timeout":
+        profile_fetch.side_effect = Timeout("private-linkedin-token")
+    elif failure == "http":
+        profile_fetch.return_value.raise_for_status.side_effect = HTTPError("private-linkedin-token")
+    else:
+        profile_fetch.return_value.json.side_effect = ValueError("private-linkedin-token")
+
+    with pytest.raises(SystemExit) as error:
+        cli.main(["auth", "status"])
+
+    assert error.value.code == 1
+    output = capsys.readouterr()
+    assert output.out == "Not logged in\n"
+    assert output.err == ""
     assert auth_path.read_bytes() == before
     reader.assert_not_called()
 
 
+@pytest.mark.parametrize("status_code", [401, 403])
+def test_status_reports_rejected_sessions(status_code, reader, profile_fetch, capsys):
+    auth.import_browser("chrome")
+    profile_fetch.return_value.status_code = status_code
+
+    with pytest.raises(SystemExit) as error:
+        cli.main(["auth", "status"])
+
+    assert error.value.code == 1
+    output = capsys.readouterr()
+    assert output.out == "Not logged in\n"
+    assert output.err == ""
+    profile_fetch.return_value.json.assert_not_called()
+
+
+@pytest.mark.parametrize("failure", ["rejected", "connection", "missing_name"])
+def test_failed_import_lookup_preserves_previous_session(failure, reader, browser_cookies, auth_path, profile_fetch, capsys):
+    auth.import_browser("chrome")
+    before = auth_path.read_bytes()
+    next(cookie for cookie in browser_cookies if cookie.name == "li_at").value = "new-private-token"
+    if failure == "rejected":
+        profile_fetch.return_value.status_code = 401
+    elif failure == "connection":
+        profile_fetch.side_effect = ConnectionError("new-private-token")
+    else:
+        profile_fetch.return_value.json.return_value = {}
+
+    with pytest.raises(SystemExit) as error:
+        cli.main(["auth", "import", "--browser", "chrome"])
+
+    assert error.value.code == 2
+    output = capsys.readouterr()
+    assert output.out == ""
+    assert output.err
+    assert "new-private-token" not in output.err
+    assert auth_path.read_bytes() == before
+
+
 @pytest.mark.skipif(os.name != "posix", reason="Unix file permissions")
 def test_auth_store_is_private_even_when_replacing_an_existing_file(reader, auth_path):
     auth_path.parent.mkdir()
@@ -217,7 +327,7 @@ def test_failed_save_preserves_previous_session_and_cleans_up(reader, auth_path,
 
 
 @pytest.mark.parametrize("command", [
-    ["auth", "status"], ["company", "Acme"], ["skill", "Python"],
+    ["company", "Acme"], ["skill", "Python"],
     ["human", "https://www.linkedin.com/in/example/"],
 ])
 def test_missing_auth_has_import_guidance_without_browser_or_api_access(command, reader, monkeypatch, capsys, auth_path):
@@ -234,19 +344,34 @@ def test_missing_auth_has_import_guidance_without_browser_or_api_access(command,
     linkedin.assert_not_called()
 
 
+def test_missing_auth_status_prints_not_logged_in(reader, monkeypatch, capsys, auth_path):
+    linkedin = Mock()
+    monkeypatch.setattr(cli, "Linkedin", linkedin)
+
+    with pytest.raises(SystemExit) as error:
+        cli.main(["auth", "status"])
+
+    assert error.value.code == 1
+    output = capsys.readouterr()
+    assert output.out == "Not logged in\n"
+    assert output.err == ""
+    assert not auth_path.exists()
+    reader.assert_not_called()
+    linkedin.assert_not_called()
+
+
 @pytest.mark.parametrize("content", [b"", b"[]", b"{}", b"private-token", b"\xff"])
-def test_corrupt_store_has_reimport_guidance(content, auth_path, capsys):
+def test_corrupt_store_status_prints_not_logged_in(content, auth_path, capsys):
     auth_path.parent.mkdir()
     auth_path.write_bytes(content)
 
     with pytest.raises(SystemExit) as error:
         cli.main(["auth", "status"])
 
-    assert error.value.code == 2
+    assert error.value.code == 1
     output = capsys.readouterr()
-    assert "saved LinkedIn session is invalid" in output.err
-    assert "warmpath auth import --browser" in output.err
-    assert "private-token" not in output.out + output.err
+    assert output.out == "Not logged in\n"
+    assert output.err == ""
     assert auth_path.read_bytes() == content
 
 
@@ -266,7 +391,7 @@ def test_invalid_stored_cookie_is_rejected(field, value, reader, auth_path):
         auth.load_cookies()
 
 
-def test_expired_session_is_reported_and_rejected_without_reimport(reader, capsys):
+def test_expired_session_is_reported_and_rejected_without_reimport(reader, capsys, profile_fetch):
     session = auth.import_browser("chrome")
     next(cookie for cookie in session.cookies if cookie.name == "li_at").expires = 1
     auth.save_auth(session)
@@ -277,9 +402,8 @@ def test_expired_session_is_reported_and_rejected_without_reimport(reader, capsy
 
     assert status_error.value.code == 1
     output = capsys.readouterr()
-    assert "Status: expired or incomplete" in output.out
-    assert "Missing or expired: li_at" in output.out
-    assert "warmpath auth import --browser chrome" in output.out
+    assert output.out == "Not logged in\n"
+    assert output.err == ""
 
     with pytest.raises(SystemExit) as api_error:
         cli.build_api()
@@ -287,6 +411,7 @@ def test_expired_session_is_reported_and_rejected_without_reimport(reader, capsy
     assert api_error.value.code == 2
     assert "warmpath auth import --browser chrome" in capsys.readouterr().err
     reader.assert_not_called()
+    profile_fetch.assert_not_called()
 
 
 @pytest.mark.parametrize("arguments", [[], ["import"], ["import", "--browser", "unknown"], ["login"]])

{warmpath-0.3.1 → warmpath-0.3.3}/uv.lock

@@ -616,7 +616,7 @@ wheels = [
 
 [[package]]
 name = "warmpath"
-version = "0.3.1"
+version = "0.3.3"
 source = { editable = "." }
 dependencies = [
     { name = "browser-cookie3" },

{warmpath-0.3.1 → warmpath-0.3.3}/warmpath/auth.py

@@ -125,7 +125,7 @@ def save_auth(session: AuthSession) -> None:
             temporary.unlink(missing_ok=True)
 
 
-def import_browser(browser: str) -> AuthSession:
+def import_browser(browser: str, *, save: bool = True) -> AuthSession:
     if browser not in BROWSERS:
         raise AuthError(f"Unsupported browser. Choose from: {', '.join(BROWSERS)}.")
     try:
@@ -147,7 +147,8 @@ def import_browser(browser: str) -> AuthSession:
             f"{', '.join(missing)}. Sign in to LinkedIn in a regular browser window, "
             f"then run warmpath auth import --browser {browser} again."
         )
-    save_auth(session)
+    if save:
+        save_auth(session)
     return session
 
 
@@ -213,22 +214,3 @@ def load_cookies() -> RequestsCookieJar:
             f"Sign in to LinkedIn, then run warmpath auth import --browser {session.browser}."
         )
     return select_cookies(session.cookies)
-
-
-def render_status(session: AuthSession) -> str:
-    missing = session.missing_cookies()
-    lines = [
-        f"Status: {'expired or incomplete' if missing else 'ready'} (local expiry check)",
-        f"Browser: {session.browser}",
-        f"Imported: {session.imported_at.isoformat()}",
-        f"Store: {auth_store_path()}",
-    ]
-    for cookie in sorted(session.cookies, key=lambda cookie: cookie.name):
-        expiry = "session"
-        if cookie.expires is not None:
-            expiry = datetime.fromtimestamp(cookie.expires, timezone.utc).isoformat()
-        lines.append(f"Cookie: {cookie.name}; expires: {expiry}")
-    if missing:
-        lines.append(f"Missing or expired: {', '.join(missing)}")
-        lines.append(f"Run warmpath auth import --browser {session.browser} again.")
-    return "\n".join(lines)

{warmpath-0.3.1 → warmpath-0.3.3}/warmpath/cli.py

@@ -9,6 +9,7 @@ from typing import Any, Callable, NoReturn
 from urllib.parse import unquote, urlparse
 
 from open_linkedin_api import Linkedin
+from requests.exceptions import RequestException
 
 from warmpath import auth
 
@@ -99,9 +100,9 @@ def use_fast_fetches(api: Any) -> None:
     api._post = fast_post
 
 
-def build_api() -> Any:
+def build_api(session: auth.AuthSession | None = None) -> Any:
     try:
-        cookies = auth.load_cookies()
+        cookies = auth.select_cookies(session.cookies) if session is not None else auth.load_cookies()
     except auth.AuthError as exc:
         fail(str(exc), 2)
     api = Linkedin("", "", cookies=cookies)
@@ -109,6 +110,35 @@ def build_api() -> Any:
     return api
 
 
+def logged_in_user_name(api: Any) -> str:
+    try:
+        response = api._fetch("/me", timeout=15)
+        if response.status_code in (401, 403):
+            raise auth.AuthError(
+                "LinkedIn rejected the saved session. Sign in to LinkedIn, "
+                f"then reimport your session. {auth.IMPORT_HINT}"
+            )
+        response.raise_for_status()
+        data = response.json()
+    except (RequestException, ValueError) as exc:
+        raise auth.AuthError(
+            "Could not fetch the logged-in LinkedIn user. Check your connection "
+            f"and try again, or reimport your session. {auth.IMPORT_HINT}"
+        ) from exc
+
+    profile = data.get("miniProfile") if isinstance(data, dict) else None
+    name = ""
+    if isinstance(profile, dict):
+        name = " ".join(
+            value.strip()
+            for key in ("firstName", "lastName")
+            if isinstance(value := profile.get(key), str) and value.strip()
+        )
+    if not name:
+        raise auth.AuthError("LinkedIn did not return a name for the logged-in user.")
+    return name
+
+
 def profile_urn_id(api: Any, public_id: str) -> str:
     urn_id = profile_urn_id_from_html(api, public_id)
     if urn_id:
@@ -1743,21 +1773,28 @@ def parse_auth_args(argv: list[str]) -> argparse.Namespace:
         choices=auth.BROWSERS,
         help="Browser where you are logged in to LinkedIn.",
     )
-    commands.add_parser("status", help="Check the saved session and cookie expiry locally.")
+    commands.add_parser("status", help="Show whether you are logged in and as whom.")
     return parser.parse_args(argv)
 
 
 def run_auth_command(args: argparse.Namespace) -> None:
     try:
         session = (
-            auth.import_browser(args.browser)
+            auth.import_browser(args.browser, save=False)
             if args.auth_command == "import"
             else auth.load_auth()
         )
-        print(auth.render_status(session))
         if session.missing_cookies():
+            print("Not logged in")
             raise SystemExit(1)
+        name = logged_in_user_name(build_api(session))
+        if args.auth_command == "import":
+            auth.save_auth(session)
+        print(f"Logged in as {name}")
     except auth.AuthError as exc:
+        if args.auth_command == "status":
+            print("Not logged in")
+            raise SystemExit(1)
         fail(str(exc), 2)
 
 
@@ -1771,7 +1808,7 @@ def parse_main_args(argv: list[str]) -> argparse.Namespace:
     Import your LinkedIn session from a browser.
 
   auth status
-    Check the saved session and cookie expiry locally.
+    Show whether you are logged in and as whom.
 
   human PROFILE_URL
     Print mutual LinkedIn connections for a profile URL.

warmpath-0.3.1/README.md

@@ -1,80 +0,0 @@
-![Warmpath banner](warmpath.jpg)
-
-# Warmpath
-
-Find LinkedIn mutuals and warm paths using your logged-in browser session.
-
-## Setup
-
-Log in to LinkedIn in a regular browser window, then import that session:
-
-```sh
-uvx warmpath auth import --browser chrome
-uvx warmpath auth status
-```
-
-Import uses [browser-cookie3](https://github.com/borisbabic/browser_cookie3) to read your browser's local cookie store. Supported browsers are Chrome, Chromium, Firefox, Edge, Brave, Safari, Arc, Vivaldi, Opera, Opera GX (`opera-gx`), and LibreWolf; availability depends on your operating system. Your OS may ask for keychain/keyring access. If the cookie store is locked, close the browser and retry. Private-window sessions cannot be imported.
-
-Warmpath imports only LinkedIn's `li_at` and `JSESSIONID` cookies and manages the saved session automatically. `company`, `skill`, and `human` use it on subsequent runs. Failed imports preserve the previous session.
-
-`auth status` shows the source browser, import time, cookie expiry, and storage location without displaying cookie values. It checks the saved session locally; LinkedIn may revoke a session before its cookies expire. If the session expires or LinkedIn stops accepting it, log in again and repeat `auth import`.
-
-## Development
-
-[go-task](https://taskfile.dev/) is required to run the repository checks. Install it with Homebrew on macOS:
-
-```sh
-brew install go-task
-```
-
-For other platforms, follow the [go-task installation guide](https://taskfile.dev/docs/installation). Verify that the `task` command is available before running any checks:
-
-```sh
-task --version
-```
-
-Then install the Python development dependencies and run the full check suite:
-
-```sh
-uv sync
-task check
-```
-
-## Usage
-
-### Company
-
-Who can introduce me into this company?
-
-```sh
-uvx warmpath company HashiCorp
-```
-
-### Skill
-
-Which reachable people match this recruiting need?
-
-```sh
-uvx warmpath skill Flutter
-```
-
-### Human
-
-Can I reach this exact person, and through whom?
-
-```sh
-uvx warmpath human https://www.linkedin.com/in/mitchellh/
-```
-
-## More Examples
-
-```sh
-uvx warmpath company "HashiCorp" --max-degree 2 --limit 5
-uvx warmpath auth import --browser firefox
-uvx warmpath company https://www.linkedin.com/company/hashicorp/
-uvx warmpath skill Leadership --max-depth 2
-uvx warmpath human https://www.linkedin.com/in/mitchellh/ --refresh-cache
-uvx warmpath company --help
-uvx warmpath skill --help
-uvx warmpath human --help
-```