async_linkedinlib 0.2.0__py3-none-any.whl

async_linkedinlib/__init__.py

@@ -0,0 +1,187 @@
+"""Async LinkedIn client: sessions, feed, posts, comments, search and jobs (Voyager API)."""
+
+from .client import LinkedIn  # Async client and resource lifecycle.
+from .config import ClientOptions  # Connection settings.
+from .config import ClientProfile  # Versioned app metadata.
+from .exceptions import AuthenticationError  # Rejected or expired credentials.
+from .exceptions import ChallengeRequired  # Verification required in the official app.
+from .exceptions import HTTPError  # Non-authentication HTTP failures.
+from .exceptions import LinkedInError  # Base SDK failure.
+from .exceptions import NetworkError  # Network failure with no automatic retry.
+from .exceptions import OperationRejected  # LinkedIn refused the operation and said why.
+from .exceptions import ProtocolError  # Unsupported response shape or redirect.
+from .exceptions import RateLimited  # Server or persisted cooldown.
+from .exceptions import SessionError  # Invalid persisted state.
+from .exceptions import SessionInUse  # Exclusive session ownership conflict.
+from .exceptions import UnconfirmedWrite  # A write was accepted but its reply unreadable.
+from .models import ApplicationForm  # An Easy Apply form: pages, questions, resumes.
+from .models import ApplicationStatus  # Result of a submitted application.
+from .models import Author  # Member or company shown on a post or comment.
+from .models import Comment  # One comment or reply.
+from .models import CommentScope  # Who may comment on a post.
+from .models import CommentSort  # Most relevant or most recent comments.
+from .models import Commitment  # Employer commitments filter.
+from .models import CompanyContent  # Which company page posts to list.
+from .models import CompanyFilters  # Company search filters.
+from .models import CompanySize  # Company size buckets.
+from .models import ContentType  # Post search content types.
+from .models import CourseFilters  # Course search filters.
+from .models import CourseLength  # Course length buckets.
+from .models import CourseLevel  # Course levels.
+from .models import Cursor  # Continues the request that produced a page.
+from .models import DatePosted  # Post search date ranges.
+from .models import Document  # A document attachment.
+from .models import ExperienceLevel  # Job seniority filter.
+from .models import FeedSort  # Top or recent main feed.
+from .models import FileQuestion  # A file slot such as the resume.
+from .models import Filter  # One available search filter.
+from .models import FilterOption  # One suggested filter value.
+from .models import FormPage  # One page of an Easy Apply form.
+from .models import Image  # An image attachment.
+from .models import Job  # One job posting as a seeker sees it.
+from .models import JobDatePosted  # Job posting date ranges.
+from .models import JobFilters  # Job search filters.
+from .models import JobResult  # One job card in search results.
+from .models import JobSort  # Job search order.
+from .models import JobType  # Full-time, part-time, contract and more.
+from .models import LinkPreview  # A link attachment.
+from .models import MediaKind  # Image, video or document upload.
+from .models import MediaStatus  # Processing state of an upload.
+from .models import Member  # Verified member identity.
+from .models import Mention  # A tagged member inside comment text.
+from .models import Network  # 1st, 2nd and 3rd+ connections.
+from .models import NewPoll  # A poll to publish.
+from .models import Option  # One choice of a question.
+from .models import Page  # One page of results.
+from .models import PeopleFilters  # People search filters.
+from .models import PersonResult  # A person in search results.
+from .models import Poll  # A poll attached to a post.
+from .models import PollDuration  # How long a new poll runs.
+from .models import PollOption  # One poll choice and its vote state.
+from .models import Post  # One feed update.
+from .models import PostedBy  # Post search author scope.
+from .models import PostFilters  # Post search filters.
+from .models import PostSort  # Post search order.
+from .models import ProductFilters  # Product search filters.
+from .models import ProfileActivity  # A member's posts, comments or reactions.
+from .models import Question  # One Easy Apply question.
+from .models import QuestionKind  # Text, number, single choice, dropdown, checkbox.
+from .models import ReactionSort  # Order of a reactions list.
+from .models import ReactionType  # Like, Celebrate, Support, Love, Insightful, Funny.
+from .models import Reactor  # Who reacted to a post, and how.
+from .models import Repost  # An instant repost.
+from .models import ResultGroup  # One block of blended results.
+from .models import Resume  # A resume offered from earlier applications.
+from .models import SavedPost  # One entry of the saved-posts list.
+from .models import ScheduledPost  # One scheduled post.
+from .models import SearchResult  # A company, group, school, event, course or product.
+from .models import ServiceFilters  # Service search filters.
+from .models import SharedPost  # A published or scheduled post.
+from .models import SocialCounts  # Reaction, comment and repost totals.
+from .models import Submission  # A checked application body, not yet sent.
+from .models import Suggestion  # A typeahead match; its id is a filter value.
+from .models import TrackedJob  # One entry of the My jobs lists.
+from .models import TrackedStatus  # Saved, in progress, applied or archived.
+from .models import TypeaheadKind  # What a typeahead looks up.
+from .models import UploadedFile  # A stored file, ready to attach.
+from .models import UploadedMedia  # An uploaded file, ready to attach.
+from .models import Vertical  # Which kind of result a search returns.
+from .models import Video  # A video attachment.
+from .models import Visibility  # Anyone or connections only.
+from .models import WorkplaceType  # On-site, remote or hybrid.
+from .session import Session  # Private cookie state and persistence.
+
+__all__ = [
+    "LinkedIn",
+    "Session",
+    "ClientOptions",
+    "ClientProfile",
+    # Failures
+    "AuthenticationError",
+    "ChallengeRequired",
+    "HTTPError",
+    "LinkedInError",
+    "NetworkError",
+    "OperationRejected",
+    "ProtocolError",
+    "RateLimited",
+    "SessionError",
+    "SessionInUse",
+    "UnconfirmedWrite",
+    # Models
+    "ApplicationForm",
+    "ApplicationStatus",
+    "Author",
+    "Comment",
+    "CommentScope",
+    "CommentSort",
+    "Commitment",
+    "CompanyContent",
+    "CompanyFilters",
+    "CompanySize",
+    "ContentType",
+    "CourseFilters",
+    "CourseLength",
+    "CourseLevel",
+    "Cursor",
+    "DatePosted",
+    "Document",
+    "ExperienceLevel",
+    "FeedSort",
+    "FileQuestion",
+    "Filter",
+    "FilterOption",
+    "FormPage",
+    "Image",
+    "Job",
+    "JobDatePosted",
+    "JobFilters",
+    "JobResult",
+    "JobSort",
+    "JobType",
+    "LinkPreview",
+    "MediaKind",
+    "MediaStatus",
+    "Member",
+    "Mention",
+    "Network",
+    "NewPoll",
+    "Option",
+    "Page",
+    "PeopleFilters",
+    "PersonResult",
+    "Poll",
+    "PollDuration",
+    "PollOption",
+    "Post",
+    "PostFilters",
+    "PostSort",
+    "PostedBy",
+    "ProductFilters",
+    "ProfileActivity",
+    "Question",
+    "QuestionKind",
+    "ReactionSort",
+    "ReactionType",
+    "Reactor",
+    "Repost",
+    "ResultGroup",
+    "Resume",
+    "SavedPost",
+    "ScheduledPost",
+    "SearchResult",
+    "ServiceFilters",
+    "SharedPost",
+    "SocialCounts",
+    "Submission",
+    "Suggestion",
+    "TrackedJob",
+    "TrackedStatus",
+    "TypeaheadKind",
+    "UploadedFile",
+    "UploadedMedia",
+    "Vertical",
+    "Video",
+    "Visibility",
+    "WorkplaceType",
+]

async_linkedinlib/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

async_linkedinlib/auth/__init__.py

@@ -0,0 +1,5 @@
+"""Auth public exports."""
+
+from .service import Auth  # Explicit login orchestration and bootstrap.
+
+__all__ = ["Auth"]

async_linkedinlib/auth/service.py

@@ -0,0 +1,77 @@
+"""The recorded Google ID-token exchange; Google token acquisition is caller-owned."""
+
+import asyncio
+import secrets
+
+from ..exceptions import AuthenticationError
+from ..exceptions import ChallengeRequired
+from ..exceptions import ProtocolError
+from ..models import Member
+from ..resources import Account
+from ..session.cookies import SessionCookie
+from ..transport import Transport
+
+
+class Auth:
+    """Bootstrap fresh browser cookies and exchange one caller-supplied Google ID token."""
+
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+        self._lock = asyncio.Lock()
+
+    async def prepare(self) -> None:
+        """Fetch current server cookies; create the mobile CSRF cookie if none was issued."""
+        await self._transport.request("GET", "/mob/tracking")
+        state = self._transport.session
+        if not state.cookie_value("JSESSIONID"):
+            state.cookies.append(
+                SessionCookie(
+                    "JSESSIONID",
+                    f'"ajax:{secrets.randbelow(9 * 10**18) + 10**18}"',
+                    ".www.linkedin.com",
+                )
+            )
+        self._transport.checkpoint()
+
+    async def login_google(self, id_token: str) -> Member:
+        """Exchange a fresh token for the LinkedIn Android audience, then verify the member.
+
+        Tokens are not persisted or automatically retried. Challenges must be completed
+        in the official app. This does not obtain a Google token or accept passwords.
+        """
+        if not isinstance(id_token, str) or not id_token.strip():
+            raise ValueError("A fresh Google ID token is required.")
+        async with self._lock:
+            state = self._transport.session
+            if state.authenticated:
+                raise AuthenticationError(
+                    "A session already exists; use account.me() to verify it."
+                )
+            await self.prepare()
+            form = {
+                "soogleLoginRequestType": "ONE_TAP_AUTO_LOGIN",
+                "googleIdToken": id_token,
+                "client_enabled_features": "ANDROID_NATIVE_CAPTCHA",
+            }
+            for name in ("JSESSIONID", "bcookie", "bscookie", "lang", "lidc"):
+                value = state.cookie_value(name)
+                if value is not None:
+                    form[name] = value.strip('"')
+            try:
+                response = await self._transport.request("POST", "/uas/authenticate", form)
+                result = self._transport.json_object(response)
+                challenge = result.get("challenge_url")
+                if isinstance(challenge, str) and challenge:
+                    raise ChallengeRequired(challenge)
+                if result.get("login_result") != "PASS":
+                    raise AuthenticationError("LinkedIn did not accept the Google sign-in.")
+                if not state.authenticated:
+                    raise ProtocolError("Login succeeded without the required session cookies.")
+            except BaseException:
+                state.clear_authentication()
+                self._transport.checkpoint()
+                raise
+            finally:
+                form.clear()
+            # A temporary verification failure must not discard a successfully issued session.
+            return await Account(self._transport).me()

async_linkedinlib/cli.py

@@ -0,0 +1,37 @@
+"""Interactive credentials; never put tokens in command arguments or shell history."""
+
+import argparse
+import asyncio
+from getpass import getpass
+from pathlib import Path
+
+from .client import LinkedIn
+from .exceptions import LinkedInError
+from .session import Session
+
+
+async def run(command: str, path: Path) -> None:
+    async with LinkedIn.from_session_file(path) as client:
+        if command == "import-session":
+            if client.session.cookies:
+                raise LinkedInError("Session file already contains cookies; choose a new file.")
+            imported = Session.from_cookies(getpass("li_at: "), getpass("JSESSIONID: "))
+            client.session.cookies = imported.cookies
+            member = await client.account.me()
+        elif command == "login-google" and not client.session.authenticated:
+            member = await client.auth.login_google(getpass("Fresh Google ID token: "))
+        else:
+            member = await client.account.me()
+        print(f"Verified {member.full_name} (member {member.id}).")
+        print(f"Session saved to {path}.")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("command", choices=("import-session", "login-google", "me"))
+    parser.add_argument("--session", type=Path, required=True)
+    args = parser.parse_args()
+    try:
+        asyncio.run(run(args.command, args.session.expanduser()))
+    except (LinkedInError, OSError, ValueError) as error:
+        parser.exit(1, f"{error}\n")

async_linkedinlib/client.py

@@ -0,0 +1,93 @@
+"""Public client lifecycle and exclusive session-file ownership."""
+
+import asyncio
+from pathlib import Path
+from types import TracebackType
+from typing import Self
+
+import httpx
+
+from .auth import Auth
+from .config import ClientOptions
+from .resources import Account
+from .resources import Comments
+from .resources import Feed
+from .resources import Jobs
+from .resources import Posts
+from .resources import Search
+from .session import Session
+from .session.lease import SessionLease
+from .transport import Transport
+from .transport import Voyager
+
+
+class LinkedIn:
+    """One account per async context; closing saves state without logging out."""
+
+    def __init__(
+        self,
+        session: Session | None = None,
+        options: ClientOptions | None = None,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ) -> None:
+        self.session = session if session is not None else Session()
+        self._transport = Transport(self.session, options or ClientOptions(), transport)
+        self.auth = Auth(self._transport)
+        self.account = Account(self._transport)
+        voyager = Voyager(self._transport)
+        self.feed = Feed(voyager)
+        self.posts = Posts(voyager)
+        self.comments = Comments(voyager)
+        self.search = Search(voyager)
+        self.jobs = Jobs(voyager)
+        self._lease: SessionLease | None = None
+        self._closed = False
+        self._close_lock = asyncio.Lock()
+
+    @classmethod
+    def from_session_file(
+        cls,
+        path: str | Path,
+        options: ClientOptions | None = None,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ) -> Self:
+        destination = Path(path).expanduser().resolve()
+        lease = SessionLease(destination)
+        try:
+            session = Session.load(destination) if destination.exists() else Session()
+            if not destination.exists():
+                session.save(destination)
+            client = cls(session, options, transport)
+            client._lease = lease
+            client._transport.session_file = destination
+            return client
+        except BaseException:
+            lease.close()
+            raise
+
+    async def __aenter__(self) -> Self:
+        if self._closed:
+            raise RuntimeError("LinkedIn client is closed.")
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        async with self._close_lock:
+            if self._closed:
+                return
+            try:
+                await self._transport.aclose()
+            finally:
+                try:
+                    self._transport.checkpoint()
+                finally:
+                    self._closed = True
+                    if self._lease is not None:
+                        self._lease.close()

async_linkedinlib/config/__init__.py

@@ -0,0 +1,6 @@
+"""Config public exports."""
+
+from .options import ClientOptions  # HTTP connection settings.
+from .profile import ClientProfile  # Versioned app metadata.
+
+__all__ = ["ClientOptions", "ClientProfile"]

async_linkedinlib/config/options.py

@@ -0,0 +1,15 @@
+"""Caller-controlled connection settings."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class ClientOptions:
+    """Connection settings; one client owns one connection pool."""
+
+    timeout: float = 30.0
+    max_connections: int = 1
+
+    def __post_init__(self) -> None:
+        if self.timeout <= 0 or self.max_connections < 1:
+            raise ValueError("Timeout and connection count must be positive.")

async_linkedinlib/config/profile.py

@@ -0,0 +1,56 @@
+"""Versioned Android client metadata observed in the local login capture."""
+
+import json
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class ClientProfile:
+    """App metadata, separate from per-account cookies and device identity."""
+
+    app_version: str = "4.1.1267"
+    version_code: int = 217500
+    locale: str = "en_US"
+    timezone: str = "Asia/Kolkata"
+    timezone_offset: float = 5.5
+
+    @property
+    def user_agent(self) -> str:
+        return (
+            f"com.linkedin.android/{self.version_code} (Linux; U; Android 13; {self.locale}; "
+            "sdk_gphone64_arm64; Build/TE1A.240213.009; Cronet/151.0.7922.47)"
+        )
+
+    def auth_headers(self, device_id: str) -> dict[str, str]:
+        track = {
+            "osName": "Android OS",
+            "osVersion": "33",
+            "clientVersion": self.app_version,
+            "clientMinorVersion": self.version_code,
+            "model": "Google_sdk_gphone64_arm64",
+            "displayDensity": 2.625,
+            "displayWidth": 1080,
+            "displayHeight": 2209,
+            "dpi": "xhdpi",
+            "deviceType": "android",
+            "appId": "com.linkedin.android",
+            "deviceId": device_id,
+            "timezoneOffset": self.timezone_offset,
+            "timezone": self.timezone,
+            "storeId": "us_googleplay",
+            "isAdTrackingLimited": False,
+            "mpName": "voyager-android",
+            "mpVersion": "2.344.49",
+        }
+        return {
+            "user-agent": "ANDROID OS",
+            "x-udid": device_id,
+            "x-restli-protocol-version": "2.0.0",
+            "accept-language": self.locale.replace("_", "-"),
+            "x-li-lang": self.locale,
+            "x-li-track": json.dumps(track, separators=(",", ":")),
+            "x-li-user-agent": (
+                f"LIAuthLibrary:0.0.3 com.linkedin.android:{self.app_version} "
+                "Google_sdk_gphone64_arm64:android_13"
+            ),
+        }

async_linkedinlib/exceptions.py

@@ -0,0 +1,75 @@
+"""Public failures with messages that never include credentials or response bodies."""
+
+
+class LinkedInError(Exception):
+    """Base class for expected client failures."""
+
+
+class SessionError(LinkedInError):
+    """The session file is invalid or cannot be used."""
+
+
+class SessionInUse(SessionError):
+    """Another client owns this session file."""
+
+
+class AuthenticationError(LinkedInError):
+    """Credentials were rejected or the session expired."""
+
+
+class ChallengeRequired(AuthenticationError):
+    """Complete verification in the official app; no automatic continuation occurs."""
+
+    def __init__(self, challenge_url: str | None = None) -> None:
+        super().__init__("LinkedIn requires verification in the official app.")
+        # The URL can contain private state, so it is never part of the message or repr.
+        self.challenge_url = challenge_url
+
+
+class RateLimited(LinkedInError):
+    """No retry occurs; retry_after is the remaining cooldown in seconds."""
+
+    def __init__(self, retry_after: float) -> None:
+        super().__init__("LinkedIn rate limit reached; wait before another request.")
+        self.retry_after = retry_after
+
+
+class ProtocolError(LinkedInError):
+    """The response does not match the supported protocol."""
+
+
+class UnconfirmedWrite(ProtocolError):
+    """LinkedIn accepted a write, but its reply could not be read.
+
+    The change may have been applied. Read the state back before sending it again; the
+    client never retries a write.
+    """
+
+
+class HTTPError(LinkedInError):
+    """An HTTP failure, without attaching the credential-bearing HTTPX response.
+
+    `reason` is rest.li's one-line client-error message when the reply carried one.
+    """
+
+    def __init__(self, status_code: int, reason: str | None = None) -> None:
+        detail = f": {reason}" if reason else "."
+        super().__init__(f"LinkedIn returned HTTP {status_code}{detail}")
+        self.status_code = status_code
+        self.reason = reason
+
+
+class OperationRejected(LinkedInError):
+    """LinkedIn answered but refused the operation, for example a GraphQL validation error.
+
+    `reasons` holds the server's messages; nothing was retried.
+    """
+
+    def __init__(self, reasons: tuple[str, ...]) -> None:
+        summary = reasons[0] if reasons else "no reason given"
+        super().__init__(f"LinkedIn rejected the operation: {summary}")
+        self.reasons = reasons
+
+
+class NetworkError(LinkedInError):
+    """The exchange failed; its outcome may be unknown and it was not retried."""