warmpath 0.3.2__tar.gz → 0.3.3__tar.gz

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

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

{warmpath-0.3.2 → warmpath-0.3.3}/README.md

@@ -37,7 +37,7 @@ Supported browsers are Chrome, Chromium, Firefox, Edge, Brave, Safari, Arc, Viva
 
 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` fetches and prints the logged-in user's name from LinkedIn, along with the source browser, import time, cookie expiry, and storage location, without displaying cookie values. It requires a connection to LinkedIn and exits with an error if the user lookup fails. If the session expires or LinkedIn stops accepting it, log in again and repeat `auth import`.
+`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
 

{warmpath-0.3.2 → 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.2 → warmpath-0.3.3}/pyproject.toml

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

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

@@ -148,42 +148,41 @@ 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, profile_fetch):
+def test_import_and_status_print_only_the_logged_in_user(reader, capsys, auth_path, profile_fetch):
     cli.main(["auth", "import", "--browser", "Chrome"])
-    profile_fetch.assert_not_called()
+    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 output.out.count("User: Ada Lovelace") == 1
-    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_status_prints_the_logged_in_users_name(profile, expected, reader, profile_fetch, capsys):
+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", "status"])
+    cli.main(["auth", *command])
 
-    assert f"User: {expected}\n" in capsys.readouterr().out
+    output = capsys.readouterr()
+    assert output.out == f"Logged in as {expected}\n"
+    assert output.err == ""
 
 
 @pytest.mark.parametrize("payload", [
@@ -198,11 +197,10 @@ def test_status_rejects_a_profile_without_a_name(payload, reader, profile_fetch,
     with pytest.raises(SystemExit) as error:
         cli.main(["auth", "status"])
 
-    assert error.value.code == 2
+    assert error.value.code == 1
     output = capsys.readouterr()
-    assert "LinkedIn did not return a name" in output.err
-    assert "User:" not in output.out
-    assert "private-linkedin-token" not in output.out + output.err
+    assert output.out == "Not logged in\n"
+    assert output.err == ""
 
 
 @pytest.mark.parametrize("failure", ["connection", "timeout", "http", "json"])
@@ -222,12 +220,10 @@ def test_status_handles_failed_user_lookup_without_exposing_secrets(failure, rea
     with pytest.raises(SystemExit) as error:
         cli.main(["auth", "status"])
 
-    assert error.value.code == 2
+    assert error.value.code == 1
     output = capsys.readouterr()
-    assert "Could not fetch the logged-in LinkedIn user" in output.err
-    assert "warmpath auth import --browser" in output.err
-    assert "User:" not in output.out
-    assert "private-linkedin-token" not in output.out + output.err
+    assert output.out == "Not logged in\n"
+    assert output.err == ""
     assert auth_path.read_bytes() == before
     reader.assert_not_called()
 
@@ -240,14 +236,36 @@ def test_status_reports_rejected_sessions(status_code, reader, profile_fetch, ca
     with pytest.raises(SystemExit) as error:
         cli.main(["auth", "status"])
 
-    assert error.value.code == 2
+    assert error.value.code == 1
     output = capsys.readouterr()
-    assert "LinkedIn rejected the saved session" in output.err
-    assert "warmpath auth import --browser" in output.err
-    assert "User:" not in output.out
+    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()
@@ -309,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):
@@ -326,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
 
 
@@ -369,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()

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

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

{warmpath-0.3.2 → 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.2 → warmpath-0.3.3}/warmpath/cli.py

@@ -100,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)
@@ -1773,23 +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="Show the logged-in user and saved session details.")
+    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)
-        if args.auth_command == "status":
-            print(f"User: {logged_in_user_name(build_api())}")
+        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)
 
 
@@ -1803,7 +1808,7 @@ def parse_main_args(argv: list[str]) -> argparse.Namespace:
     Import your LinkedIn session from a browser.
 
   auth status
-    Show the logged-in user and saved session details.
+    Show whether you are logged in and as whom.
 
   human PROFILE_URL
     Print mutual LinkedIn connections for a profile URL.