async_linkedinlib 0.2.0__py3-none-any.whl

async_linkedinlib/resources/comments/resource.py

@@ -0,0 +1,227 @@
+"""Read, write and react to comments with the app's Voyager comment operations.
+
+Reads are the conversations GraphQL finders; comments are created with the GraphQL
+`CreateComment` mutation the app uses on threaded posts, edited and deleted through the
+`voyagerSocialDashNormComments` rest.li resource. Every write is sent once.
+"""
+
+from collections.abc import Sequence
+from typing import TypeVar
+
+from ...exceptions import ProtocolError
+from ...exceptions import UnconfirmedWrite
+from ...models._json import dig
+from ...models._json import items
+from ...models._json import obj
+from ...models.comments import Comment
+from ...models.comments import CommentSort
+from ...models.comments import Mention
+from ...models.content import ReactionType
+from ...models.feed import ReactionSort
+from ...models.feed import Reactor
+from ...models.pagination import Cursor
+from ...models.pagination import Page
+from ...transport.voyager import GraphQLQuery
+from ...transport.voyager import Voyager
+from .. import paging
+from .. import threads
+from ..mentions import attributes as mention_attributes
+from ..reactions import Reactions
+from .urns import CommentUrn
+
+LIST = GraphQLQuery(
+    "voyagerSocialDashComments.b3ab21bfb7ad22b2f1bcb3b38149a0cb", "FetchCommentsWithReplySortOrder"
+)
+# The comment-detail finder: given a comment's social detail it lists that comment's replies.
+REPLIES = GraphQLQuery(
+    "voyagerSocialDashComments.59bca422f480a4cc0ce56ccd81181488", "FetchComments"
+)
+SINGLE = GraphQLQuery(
+    "voyagerSocialDashComments.8033a0107cfe3b64ffebc9eef95f2f37", "FetchSingleComment"
+)
+CREATE = GraphQLQuery(
+    "voyagerSocialDashNormComments.cd3d2a3fd6c9b2881c7cac32847ec05e", "CreateComment"
+)
+HIDE = GraphQLQuery(
+    "voyagerSocialDashHideCommentAction.42dde3771a51671edde117e558ab9d46", "HideCommentAction"
+)
+UNHIDE = GraphQLQuery(
+    "voyagerSocialDashHideCommentAction.e0b625699dc0ad3e093ac92a0b53dfc0", "UndoHideCommentAction"
+)
+NORM_COMMENTS = "voyagerSocialDashNormComments"
+DECORATION = "com.linkedin.voyager.dash.deco.social.NormComment-38"
+# Replies always come oldest first in the app.
+REPLY_ORDER = "CHRONOLOGICAL"
+
+T = TypeVar("T")
+
+
+class Comments:
+    """Comments on any post the account can see; editing and deleting only its own."""
+
+    def __init__(self, voyager: Voyager) -> None:
+        self._voyager = voyager
+        self._reactions = Reactions(voyager)
+
+    async def list(
+        self,
+        post_urn: str,
+        *,
+        sort: CommentSort = CommentSort.RELEVANCE,
+        count: int = 10,
+        cursor: Cursor | None = None,
+    ) -> Page[Comment]:
+        """Read one page of a post's top-level comments, each with its reply preview."""
+        thread, order = threads.post(post_urn), CommentSort(sort)
+        scope = f"{thread}|{order.value}"
+        start, token = paging.resume(cursor, "comments.list", scope, self._voyager.owner)
+        size = _count(count)
+        variables = {
+            "socialDetailUrn": threads.social_detail(thread),
+            "start": start,
+            "count": size,
+            "paginationToken": token,
+            "sortOrder": order.value,
+            "replySortOrder": REPLY_ORDER,
+        }
+        data = await self._voyager.query(LIST, variables)
+        found = paging.collection(data, "socialDashCommentsBySocialDetail")
+        return paging.page(
+            found, Comment.from_json, "comments.list", scope, start, size, self._voyager.owner
+        )
+
+    async def replies(
+        self, comment_urn: str, *, count: int = 10, cursor: Cursor | None = None
+    ) -> Page[Comment]:
+        """Read one page of a comment's replies, oldest first."""
+        comment = CommentUrn.parse(comment_urn)
+        start, token = paging.resume(cursor, "comments.replies", comment.urn, self._voyager.owner)
+        size = _count(count)
+        variables = {
+            "socialDetailUrn": threads.social_detail(comment.urn),
+            "start": start,
+            "count": size,
+            "paginationToken": token,
+            "sortOrder": REPLY_ORDER,
+        }
+        data = await self._voyager.query(REPLIES, variables)
+        found = paging.collection(data, "socialDashCommentsBySocialDetail")
+        return paging.page(
+            found,
+            Comment.from_json,
+            "comments.replies",
+            comment.urn,
+            start,
+            size,
+            self._voyager.owner,
+        )
+
+    async def get(self, comment_urn: str) -> Comment:
+        """Read one comment or reply; a deleted one raises `OperationRejected`."""
+        comment = CommentUrn.parse(comment_urn)
+        data = await self._voyager.query(
+            SINGLE, {"commentUrn": comment.entity_urn, "updateThreadUrn": comment.post_urn}
+        )
+        elements = items(dig(data, "socialDashCommentsBySingleComment", "elements"))
+        return _comment(elements[0] if elements else None)
+
+    async def create(
+        self, post_urn: str, text: str, *, mentions: Sequence[Mention] = ()
+    ) -> Comment:
+        """Comment on a post; `mentions` tag members inside `text`."""
+        return await self._create(threads.post(post_urn), text, mentions)
+
+    async def reply(
+        self, comment_urn: str, text: str, *, mentions: Sequence[Mention] = ()
+    ) -> Comment:
+        """Reply to a top-level comment."""
+        return await self._create(CommentUrn.parse(comment_urn).urn, text, mentions)
+
+    async def edit(
+        self, comment_urn: str, text: str, *, mentions: Sequence[Mention] = ()
+    ) -> Comment:
+        """Replace the text of the account's own comment or reply."""
+        comment = CommentUrn.parse(comment_urn)
+        patch = {"patch": {"$set": {"commentary": _commentary(text, mentions)}}}
+        reply = await self._voyager.post(
+            f"{NORM_COMMENTS}/{comment.entity_urn}", patch, {"decorationId": DECORATION}
+        )
+        elements = items(dig(reply.data, "singleComment", "elements"))
+        return _comment(elements[0] if elements else None, written=True)
+
+    async def delete(self, comment_urn: str) -> None:
+        """Delete the account's own comment (with its replies) or reply."""
+        comment = CommentUrn.parse(comment_urn)
+        await self._voyager.delete(f"{NORM_COMMENTS}/{comment.entity_urn}")
+
+    async def react(self, comment_urn: str, reaction: ReactionType = ReactionType.LIKE) -> None:
+        """React to a comment or reply."""
+        await self._reactions.add(CommentUrn.parse(comment_urn).urn, reaction)
+
+    async def change_reaction(self, comment_urn: str, reaction: ReactionType) -> None:
+        """Change the account's existing reaction on a comment or reply."""
+        await self._reactions.change(CommentUrn.parse(comment_urn).urn, reaction)
+
+    async def unreact(self, comment_urn: str) -> None:
+        """Remove the account's reaction from a comment or reply."""
+        await self._reactions.remove(CommentUrn.parse(comment_urn).urn)
+
+    async def reactions(
+        self,
+        comment_urn: str,
+        *,
+        reaction: ReactionType | None = None,
+        sort: ReactionSort = ReactionSort.RELEVANCE,
+        count: int = 10,
+        cursor: Cursor | None = None,
+    ) -> Page[Reactor]:
+        """Who reacted to a comment, optionally only one reaction type."""
+        thread = CommentUrn.parse(comment_urn).urn
+        return await self._reactions.list(
+            thread, reaction=reaction, sort=sort, count=count, cursor=cursor
+        )
+
+    async def hide(self, comment: Comment) -> None:
+        """Hide someone's comment on the account's own post via its `hide_action_urn`."""
+        await self._voyager.mutate(HIDE, {"hideCommentActionUrn": _hide_action(comment)})
+
+    async def unhide(self, comment: Comment) -> None:
+        """Show a comment hidden with `hide()` again."""
+        await self._voyager.mutate(UNHIDE, {"hideCommentActionUrn": _hide_action(comment)})
+
+    async def _create(self, thread_urn: str, text: str, mentions: Sequence[Mention]) -> Comment:
+        entity = {"commentary": _commentary(text, mentions), "threadUrn": thread_urn}
+        data = await self._voyager.mutate(CREATE, {"entity": entity})
+        return _comment(
+            dig(data, "createSocialDashNormComments", "entity", "comment"), written=True
+        )
+
+
+def _commentary(text: str, mentions: Sequence[Mention]) -> dict[str, object]:
+    """The app's comment `TextViewModel`: plain text plus one attribute per member mention."""
+    if not isinstance(text, str) or not text.strip():
+        raise ValueError("Comment text must not be empty.")
+    written = mention_attributes(text, mentions, companies=False)
+    return {"text": text, "attributesV2": written, "textDirection": "FIRST_STRONG"}
+
+
+def _comment(value: object, *, written: bool = False) -> Comment:
+    comment = Comment.from_json(obj(value))
+    if comment is None:
+        failure = UnconfirmedWrite if written else ProtocolError
+        raise failure("LinkedIn's reply did not contain the comment.")
+    return comment
+
+
+def _hide_action(comment: Comment) -> str:
+    if not isinstance(comment, Comment):
+        raise ValueError("A Comment read from LinkedIn is required.")
+    if not comment.hide_action_urn:
+        raise ValueError("LinkedIn offers no hide action for this comment.")
+    return comment.hide_action_urn
+
+
+def _count(count: int) -> int:
+    if type(count) is not int or not 1 <= count <= 100:
+        raise ValueError("count must be an integer from 1 to 100.")
+    return count

async_linkedinlib/resources/comments/urns.py

@@ -0,0 +1,43 @@
+"""The URN forms of posts and comments that the comment operations exchange.
+
+A comment has two spellings, both seen in every comment the server returns:
+`urn:li:comment:(activity:<post>,<id>)` (its social thread, for reactions and replies) and
+`urn:li:fsd_comment:(<id>,urn:li:activity:<post>)` (the entity that is edited or deleted).
+Replies use the post as their thread too, never the parent comment.
+"""
+
+import re
+from dataclasses import dataclass
+
+_COMMENT = re.compile(r"urn:li:comment:\(([A-Za-z]+:[0-9]+),([0-9]+)\)")
+_ENTITY = re.compile(r"urn:li:fsd_comment:\(([0-9]+),urn:li:([A-Za-z]+:[0-9]+)\)")
+
+
+@dataclass(frozen=True, slots=True)
+class CommentUrn:
+    """A comment identified by its post thread (`activity:<id>`) and its own ID."""
+
+    thread: str
+    id: str
+
+    @classmethod
+    def parse(cls, urn: str) -> "CommentUrn":
+        """Accept either spelling of a comment URN."""
+        if isinstance(urn, str):
+            if found := _COMMENT.fullmatch(urn):
+                return cls(found[1], found[2])
+            if found := _ENTITY.fullmatch(urn):
+                return cls(found[2], found[1])
+        raise ValueError("A comment URN such as urn:li:comment:(activity:<id>,<id>) is required.")
+
+    @property
+    def urn(self) -> str:
+        return f"urn:li:comment:({self.thread},{self.id})"
+
+    @property
+    def entity_urn(self) -> str:
+        return f"urn:li:fsd_comment:({self.id},urn:li:{self.thread})"
+
+    @property
+    def post_urn(self) -> str:
+        return f"urn:li:{self.thread}"

async_linkedinlib/resources/feed/__init__.py

@@ -0,0 +1,5 @@
+"""Feed resource exports."""
+
+from .resource import Feed  # Feed reads and explicit post actions.
+
+__all__ = ["Feed"]

async_linkedinlib/resources/feed/queries.py

@@ -0,0 +1,57 @@
+"""The app's persisted feed operations, with where each is built in LinkedIn Android 4.1.1267."""
+
+from ...transport.voyager import GraphQLQuery
+
+# feed/pages/main/MainFeedUpdatesConfigFactory.createGraphQLRequest
+MAIN_FEED = GraphQLQuery("voyagerFeedDashMainFeed.8a3a2fc70646e2b7462e79e23cee3935", "MainFeed")
+
+# feed/framework/graphql/FeedFrameworkGraphQLClient.feedSingleUpdateByBackendUrnOrNss
+UPDATE = GraphQLQuery(
+    "voyagerFeedDashUpdates.5f0daf4e88c68281f1fac9d328bc386e", "FeedSingleUpdateByBackendUrnOrNss"
+)
+
+# learning/LearningRepository$$ExternalSyntheticLambda0 (CreatorProfileFeedUpdateRepository)
+PROFILE_POSTS = GraphQLQuery(
+    "voyagerFeedDashProfileUpdates.8f803ebb60ca03b522e43c9a46dd539b",
+    "CreatorFeedDashProfileUpdatesByMemberShareFeed",
+)
+PROFILE_COMMENTS = GraphQLQuery(
+    "voyagerFeedDashProfileUpdates.6d854fab352bd47d28325b6abb93c6e8",
+    "FeedDashProfileUpdatesByMemberComments",
+)
+PROFILE_REACTIONS = GraphQLQuery(
+    "voyagerFeedDashProfileUpdates.1d5b78d08a87d2367604ab284efe1f1a",
+    "FeedDashProfileUpdatesByMemberReactions",
+)
+# pages/graphql/PagesGraphQLClient.organizationalPageMemberPosts (PagesMemberPostsFeature)
+COMPANY_POSTS = GraphQLQuery(
+    "voyagerFeedDashOrganizationalPageUpdates.def294ef4d8d43b7b53324bf739d00d3",
+    "OrganizationalPageMemberPosts",
+)
+
+# feed/framework/action/savestate/SaveStateManager.getSaveStateRequester
+SAVE_STATE = GraphQLQuery(
+    "voyagerFeedDashSaveStates.26886775a6d430481be84c4ca2eb1a5f", "UpdateSaveStateBySaveStateUrn"
+)
+
+
+# feed/framework/action/updateaction/UpdateActionPublisher.publish(Undo)FeedbackAction
+HIDE = GraphQLQuery(
+    "voyagerFeedDashUpdateFeedback.46392e3c45b16ecca40508fabcb2b9ab", "FeedbackAction"
+)
+UNDO_HIDE = GraphQLQuery(
+    "voyagerFeedDashUpdateFeedback.27ec6f4a27da65e6f4a9338f8195f37d", "UndoFeedbackAction"
+)
+
+# feed/framework/plugin/poll/PollManager.performVote
+VOTE = GraphQLQuery(
+    "voyagerSocialDashPollVotes.3f3a224fe4f900d90add90c8095a4eb7", "VoteByPollOptionUrn"
+)
+UNVOTE = GraphQLQuery(
+    "voyagerSocialDashPollVotes.686cdba82be7dc6f851fea7ab0a963d8", "UnVoteByPollOptionUrn"
+)
+
+# Module keys: FeedModuleKeyUtils.getModuleKey for the post detail page, and the constant
+# PagesGraphQLClient.organizationalPageMemberPosts always sends.
+DETAIL_MODULE = "feed-item:phone"
+COMPANY_MODULE = "ORGANIZATION_MEMBER_FEED_PHONE"

async_linkedinlib/resources/feed/resource.py

@@ -0,0 +1,225 @@
+"""Feed reads and the viewer's explicit actions on posts.
+
+Unset GraphQL variables are None, which rest.li encoding leaves out, as the app does.
+"""
+
+from ...exceptions import ProtocolError
+from ...exceptions import UnconfirmedWrite
+from ...models._json import items
+from ...models.content import Post
+from ...models.content import ReactionType
+from ...models.feed import CompanyContent
+from ...models.feed import FeedSort
+from ...models.feed import ProfileActivity
+from ...models.feed import ReactionSort
+from ...models.feed import Reactor
+from ...models.feed import SavedPost
+from ...models.pagination import Cursor
+from ...models.pagination import Page
+from ...transport.voyager import GraphQLQuery
+from ...transport.voyager import Voyager
+from .. import paging
+from ..reactions import Reactions
+from . import queries
+from . import saved
+from . import urns
+
+_PROFILE_QUERIES = {
+    ProfileActivity.POSTS: (queries.PROFILE_POSTS, "feedDashProfileUpdatesByMemberShareFeed"),
+    ProfileActivity.COMMENTS: (queries.PROFILE_COMMENTS, "feedDashProfileUpdatesByMemberComments"),
+    ProfileActivity.REACTIONS: (
+        queries.PROFILE_REACTIONS,
+        "feedDashProfileUpdatesByMemberReactions",
+    ),
+}
+
+
+class Feed:
+    """Read feeds, posts, reactors and saved posts; act on posts only when asked.
+
+    Reads never write. Each write is sent once and never retried; a timeout leaves its
+    outcome unknown.
+    """
+
+    def __init__(self, voyager: Voyager) -> None:
+        self._voyager = voyager
+        self._reactions = Reactions(voyager)
+
+    async def home(
+        self, *, count: int = 10, sort: FeedSort | None = None, cursor: Cursor | None = None
+    ) -> Page[Post]:
+        """One page of the main feed; recommendation modules are left out of `items`.
+
+        Without `sort` the server uses the member's preference. A sort applies to this
+        request only; it does not change the saved preference.
+        """
+        size = urns.count(count)
+        order = FeedSort(sort) if sort is not None else None
+        scope = order.value if order else ""
+        start, token = paging.resume(cursor, "feed.home", scope, self._voyager.owner)
+        variables = {
+            "paginationToken": token,
+            "start": start,
+            "count": size,
+            "sortOrder": order.value if order else None,
+        }
+        data = await self._voyager.query(queries.MAIN_FEED, variables)
+        found = paging.collection(data, "feedDashMainFeedByMainFeed")
+        return paging.page(
+            found, Post.from_update, "feed.home", scope, start, size, self._voyager.owner
+        )
+
+    async def get(self, urn: str) -> Post:
+        """One post by its activity, ugcPost or share URN.
+
+        The server refuses a missing or deleted post (`OperationRejected`).
+        """
+        data = await self._voyager.query(
+            queries.UPDATE,
+            {
+                "urnOrNss": urns.backend(urn),
+                "commentsCount": 10,
+                "likesCount": 10,
+                "moduleKey": queries.DETAIL_MODULE,
+            },
+        )
+        found = paging.collection(data, "feedDashUpdatesByBackendUrnOrNss")
+        for update in items(found.get("elements")):
+            post = Post.from_update(update)
+            if post is not None:
+                return post
+        raise ProtocolError("LinkedIn returned no post for this URN.")
+
+    async def profile(
+        self,
+        profile_urn: str,
+        activity: ProfileActivity = ProfileActivity.POSTS,
+        *,
+        count: int = 10,
+        cursor: Cursor | None = None,
+    ) -> Page[Post]:
+        """A member's posts, or the posts they commented on or reacted to, newest first.
+
+        For comments and reactions, `Post.context` says what the member did.
+        """
+        kind = ProfileActivity(activity)
+        query, field = _PROFILE_QUERIES[kind]
+        profile = urns.profile(profile_urn)
+        size = urns.count(count)
+        scope = f"{kind.value}:{profile}"
+        start, token = paging.resume(cursor, "feed.profile", scope, self._voyager.owner)
+        variables = {
+            "profileUrn": profile,
+            "count": size,
+            "paginationToken": token,
+            "start": start,
+        }
+        data = await self._voyager.query(query, variables)
+        found = paging.collection(data, field)
+        return paging.page(
+            found, Post.from_update, "feed.profile", scope, start, size, self._voyager.owner
+        )
+
+    async def company(
+        self,
+        company_urn: str,
+        content: CompanyContent = CompanyContent.ALL,
+        *,
+        count: int = 10,
+        cursor: Cursor | None = None,
+    ) -> Page[Post]:
+        """A company page's posts, optionally only images, videos, documents or articles."""
+        page_urn = urns.company_page(company_urn)
+        kind = CompanyContent(content)
+        size = urns.count(count)
+        scope = f"{kind.value}:{page_urn}"
+        start, token = paging.resume(cursor, "feed.company", scope, self._voyager.owner)
+        variables = {
+            "organizationalPageUrn": page_urn,
+            "count": size,
+            "filter": kind.value,
+            "moduleKey": queries.COMPANY_MODULE,
+            "paginationToken": token,
+            "start": start,
+        }
+        data = await self._voyager.query(queries.COMPANY_POSTS, variables)
+        found = paging.collection(data, "feedDashOrganizationalPageUpdatesByOrganizationalPageFeed")
+        return paging.page(
+            found, Post.from_update, "feed.company", scope, start, size, self._voyager.owner
+        )
+
+    async def reactions(
+        self,
+        urn: str,
+        *,
+        reaction: ReactionType | None = None,
+        sort: ReactionSort = ReactionSort.RELEVANCE,
+        count: int = 10,
+        cursor: Cursor | None = None,
+    ) -> Page[Reactor]:
+        """Who reacted to a post or comment, optionally only one reaction type."""
+        return await self._reactions.list(
+            urn, reaction=reaction, sort=sort, count=count, cursor=cursor
+        )
+
+    async def react(self, urn: str, reaction: ReactionType = ReactionType.LIKE) -> None:
+        """Add the viewer's reaction to a post's thread (`Post.urn`)."""
+        await self._reactions.add(urn, reaction)
+
+    async def change_reaction(self, urn: str, reaction: ReactionType) -> None:
+        """Replace the viewer's existing reaction on a post's thread."""
+        await self._reactions.change(urn, reaction)
+
+    async def unreact(self, urn: str) -> None:
+        """Remove the viewer's reaction from a post's thread."""
+        await self._reactions.remove(urn)
+
+    async def save(self, activity_urn: str) -> None:
+        """Save a post for later.
+
+        `activity_urn` is the post's own activity: `Post.urn` when it is an activity URN,
+        otherwise `Post.activity_urn` of the post as `get()` returns it.
+        """
+        await self._set_saved(activity_urn, True)
+
+    async def unsave(self, activity_urn: str) -> None:
+        """Remove a post from the saved items; takes the same URN as `save`."""
+        await self._set_saved(activity_urn, False)
+
+    async def saved(self, *, count: int = 10, cursor: Cursor | None = None) -> Page[SavedPost]:
+        """One page of the viewer's saved posts, most recently saved first."""
+        return await saved.read(self._voyager, count, cursor)
+
+    async def hide(self, update_urn: str) -> None:
+        """Hide a feed update (`Post.update_urn`) from the viewer's feed, like the app's Hide."""
+        await self._send(queries.HIDE, {"updateUrn": urns.update(update_urn)})
+
+    async def undo_hide(self, update_urn: str) -> None:
+        """Undo `hide` for the same update URN."""
+        await self._send(queries.UNDO_HIDE, {"updateUrn": urns.update(update_urn)})
+
+    async def vote(self, poll_option_urn: str) -> None:
+        """Vote for a poll option (`PollOption.urn`)."""
+        await self._send(queries.VOTE, {"pollOptionUrn": urns.poll_option(poll_option_urn)})
+
+    async def unvote(self, poll_option_urn: str) -> None:
+        """Withdraw the viewer's vote for a poll option."""
+        await self._send(queries.UNVOTE, {"pollOptionUrn": urns.poll_option(poll_option_urn)})
+
+    async def _set_saved(self, activity_urn: str, is_saved: bool) -> None:
+        # The save state is keyed on the post's activity, as the app's update actions and
+        # the saved-posts list name it.
+        activity = urns.activity(activity_urn)
+        entity = {
+            "entity": {
+                "saved": is_saved,
+                "preDashEntityUrn": f"urn:li:fs_saveAction:(SAVE,{activity})",
+            },
+            "resourceKey": f"urn:li:fsd_saveState:(SAVE,{activity})",
+        }
+        await self._send(queries.SAVE_STATE, {"entity": entity})
+
+    async def _send(self, query: GraphQLQuery, variables: dict[str, object]) -> None:
+        data = await self._voyager.mutate(query, variables)
+        if not data:
+            raise UnconfirmedWrite("LinkedIn's reply to the action had no result.")

async_linkedinlib/resources/feed/saved.py

@@ -0,0 +1,49 @@
+"""The viewer's saved posts, which the app lists as "My items" search results.
+
+Every reply to this list carries a GraphQL error beside complete data: the server reports a
+null in `metadata.entityResultAttributes`, a field the list does not use, so the read accepts
+null-field errors and nothing else.
+"""
+
+from ...models._json import items
+from ...models._json import obj
+from ...models.feed import SavedPost
+from ...models.pagination import Cursor
+from ...models.pagination import Page
+from ...transport.voyager import Voyager
+from .. import paging
+from ..search.queries import CLUSTERS
+from . import urns
+
+FIELD = "searchDashClustersByAll"
+_INTENT = "SEARCH_MY_ITEMS_SAVED_POSTS"
+
+
+async def read(voyager: Voyager, count: int, cursor: Cursor | None) -> Page[SavedPost]:
+    """One page of saved posts, most recently saved first."""
+    size = urns.count(count)
+    start, token = paging.resume(cursor, "feed.saved", "", voyager.owner)
+    variables = {
+        "query": {"flagshipSearchIntent": _INTENT},
+        "count": size,
+        "paginationToken": token,
+        "start": start,
+    }
+    data = await voyager.query(CLUSTERS, variables, ignore_null_field_errors=True)
+    found = paging.collection(data, FIELD)
+    # Each search cluster lists entity results; saved posts are those results.
+    results = [
+        obj(entry.get("item")).get("entityResult")
+        for cluster in items(found.get("elements"))
+        for entry in items(cluster.get("items"))
+    ]
+    return paging.page(
+        found,
+        SavedPost.from_result,
+        "feed.saved",
+        "",
+        start,
+        size,
+        voyager.owner,
+        elements=[result for result in results if isinstance(result, dict)],
+    )

async_linkedinlib/resources/feed/urns.py

@@ -0,0 +1,68 @@
+"""Input checks for feed operations; each raises ValueError with the expected form."""
+
+import re
+
+_BACKEND = re.compile(r"urn:li:(activity|ugcPost|share):\d+")
+_ACTIVITY = re.compile(r"urn:li:activity:\d+")
+_UPDATE = re.compile(r"urn:li:fsd_update:\(.+\)")
+_PROFILE = re.compile(r"urn:li:fsd_profile:[A-Za-z0-9_-]+")
+_COMPANY = re.compile(r"urn:li:(company|fsd_company|fsd_organizationalPage):(\d+)")
+
+# The app asks for 3 to 10 items at a time; this keeps requests in a modest range.
+MAX_COUNT = 50
+
+
+def backend(urn: str) -> str:
+    """A post to read: its activity, ugcPost or share URN."""
+    if not isinstance(urn, str) or not _BACKEND.fullmatch(urn):
+        raise ValueError(
+            "A post URN such as urn:li:activity:<id>, urn:li:ugcPost:<id> or urn:li:share:<id>"
+            " is needed."
+        )
+    return urn
+
+
+def activity(urn: str) -> str:
+    """A post's own activity URN, which its save state is keyed on."""
+    if not isinstance(urn, str) or not _ACTIVITY.fullmatch(urn):
+        raise ValueError(
+            "Saving takes the post's activity URN (urn:li:activity:<id>): Post.urn when it is "
+            "an activity, otherwise Post.activity_urn."
+        )
+    return urn
+
+
+def update(urn: str) -> str:
+    """A feed update URN, as `Post.update_urn` reads it."""
+    if not isinstance(urn, str) or not _UPDATE.fullmatch(urn):
+        raise ValueError("A feed update URN (urn:li:fsd_update:(...), Post.update_urn) is needed.")
+    return urn
+
+
+def profile(urn: str) -> str:
+    """A member profile URN, as `Author.profile_urn` reads it."""
+    if not isinstance(urn, str) or not _PROFILE.fullmatch(urn):
+        raise ValueError("A profile URN such as urn:li:fsd_profile:<id> is needed.")
+    return urn
+
+
+def company_page(urn: str) -> str:
+    """The company's page URN; a company URN names the page with the same ID."""
+    match = _COMPANY.fullmatch(urn) if isinstance(urn, str) else None
+    if not match:
+        raise ValueError("A company URN such as urn:li:company:<id> is needed.")
+    return f"urn:li:fsd_organizationalPage:{match.group(2)}"
+
+
+def poll_option(urn: str) -> str:
+    """A poll option URN, as `PollOption.urn` reads it."""
+    if not isinstance(urn, str) or not urn.startswith("urn:li:") or len(urn) <= 7:
+        raise ValueError("A poll option URN (PollOption.urn) is needed.")
+    return urn
+
+
+def count(value: int) -> int:
+    """A page size from 1 to MAX_COUNT."""
+    if type(value) is not int or not 1 <= value <= MAX_COUNT:
+        raise ValueError(f"count must be an integer from 1 to {MAX_COUNT}.")
+    return value

async_linkedinlib/resources/jobs/__init__.py

@@ -0,0 +1,5 @@
+"""Jobs resource exports."""
+
+from .resource import Jobs  # Job details, saved jobs, the tracker and Easy Apply.
+
+__all__ = ["Jobs"]