async_linkedinlib 0.2.0__py3-none-any.whl

async_linkedinlib/resources/posts/media.py

@@ -0,0 +1,173 @@
+"""Files and link cards for posts: upload, processing status, link previews.
+
+An upload is registered with `voyagerVideoDashMediaUploadMetadata?action=upload`; LinkedIn
+answers with the asset URN and a single upload URL on www.linkedin.com (`/dms-uploads/`)
+that takes the bytes in one PUT. Galleries and polls are separate entities that the share
+references; `Posts.create` makes them through the helpers here.
+"""
+
+import asyncio
+import os
+from collections.abc import Sequence
+from pathlib import Path
+from urllib.parse import quote
+from urllib.parse import urlsplit
+
+from ...exceptions import ProtocolError
+from ...exceptions import UnconfirmedWrite
+from ...models._json import dig
+from ...models._json import integer
+from ...models._json import items
+from ...models._json import obj
+from ...models._json import string
+from ...models._json import text
+from ...models.posts import Image
+from ...models.posts import LinkPreview
+from ...models.posts import MediaKind
+from ...models.posts import NewPoll
+from ...models.posts import UploadedMedia
+from ...models.posts_results import MediaStatus
+from ...transport import Transport
+from ...transport.voyager import GraphQLQuery
+from ...transport.voyager import Voyager
+from . import payloads
+
+UPLOAD_METADATA = "voyagerVideoDashMediaUploadMetadata"
+ASSET_STATUS = "voyagerVideoDashMediaAssetStatus"
+MULTI_PHOTOS = "voyagerVideoDashMultiPhotos"
+STATUS_DECORATION = "com.linkedin.voyager.dash.deco.video.MediaAssetStatus-6"
+URL_PREVIEW = GraphQLQuery(
+    "voyagerContentcreationDashUpdateUrlPreview.0891457da461730e024a24803ff8e1e7",
+    "UpdateUrlPreviewByUrl",
+)
+CREATE_POLL = GraphQLQuery(
+    "voyagerFeedDashPollsPollSummary.10244461333ea4d87e8177aa97aebc24", "CreatePoll"
+)
+# The status kind the app asks for per upload use case.
+_STATUS_TYPES = {
+    MediaKind.IMAGE: "IMAGE",
+    MediaKind.VIDEO: "VIDEO",
+    MediaKind.DOCUMENT: "DOCUMENT_PREVIEW",
+}
+
+
+class PostMedia:
+    """Upload files for posts and preview links; nothing here publishes anything."""
+
+    def __init__(self, voyager: Voyager) -> None:
+        self._voyager = voyager
+
+    async def upload(
+        self,
+        file: str | os.PathLike[str] | bytes,
+        kind: MediaKind,
+        *,
+        filename: str | None = None,
+    ) -> UploadedMedia:
+        """Store an image, video or document; attach the result with `Image`, `Video`..."""
+        kind = MediaKind(kind)
+        if isinstance(file, bytes):
+            data, name = file, filename
+        else:
+            path = Path(file)
+            data = await asyncio.to_thread(path.read_bytes)
+            name = filename or path.name
+        if not data:
+            raise ValueError("The file is empty.")
+        body: dict[str, object] = {
+            "mediaUploadType": kind.value,
+            "fileSize": len(data),
+            "hasOverlayImage": False,
+            "uploadMetadataType": "DYNAMIC",
+            "disableSynchronousUploadMechanism": False,
+        }
+        if name:
+            body["filename"] = name
+        reply = await self._voyager.post(UPLOAD_METADATA, body, {"action": "upload"})
+        upload = obj(reply.data.get("value"))
+        urn = string(upload, "urn")
+        if not urn:
+            raise UnconfirmedWrite("LinkedIn did not register the upload.")
+        target = _single_upload_path(upload)
+        headers = {
+            key: value
+            for key, value in obj(upload.get("singleUploadHeaders")).items()
+            if isinstance(value, str)
+        }
+        headers["content-type"] = "application/octet-stream"
+        response = await self._voyager.transport.request(
+            "PUT", target, content=data, headers=headers
+        )
+        if response.status_code not in (200, 201):
+            raise UnconfirmedWrite("LinkedIn did not confirm the upload.")
+        recipes = tuple(r for r in upload.get("recipes") or () if isinstance(r, str))
+        return UploadedMedia(urn, kind, recipes)
+
+    async def status(self, media: UploadedMedia) -> MediaStatus:
+        """Read whether LinkedIn finished processing an upload."""
+        if not isinstance(media, UploadedMedia):
+            raise ValueError("An UploadedMedia from upload() is required.")
+        data = await self._voyager.get(
+            f"{ASSET_STATUS}/{quote(media.urn, safe='')}",
+            {"mediaStatusType": _STATUS_TYPES[media.kind], "decorationId": STATUS_DECORATION},
+        )
+        return MediaStatus(
+            urn=media.urn,
+            state=string(data, "processingStatus"),
+            page_count=integer(data, "documentProcessingResult", "totalPageCount"),
+            raw=data,
+        )
+
+    async def link_preview(self, url: str) -> LinkPreview:
+        """Build the article card for a web address, as the share box does on paste."""
+        parts = urlsplit(url) if isinstance(url, str) else None
+        if parts is None or parts.scheme not in ("http", "https") or not parts.netloc:
+            raise ValueError("An http or https URL is required.")
+        data = await self._voyager.query(URL_PREVIEW, {"url": url})
+        found = items(dig(data, "contentcreationDashUpdateUrlPreviewByUrl", "elements"))
+        preview = found[0] if found else {}
+        update = obj(preview.get("update"))
+        article = string(update, "metadata", "shareMediaUrn")
+        if not article:
+            raise ProtocolError("LinkedIn returned no preview for this URL.")
+        card = obj(dig(update, "content", "articleComponent"))
+        return LinkPreview(
+            url=url,
+            article_urn=article,
+            title=text(card, "title"),
+            subtitle=text(card, "subtitle"),
+            original_url=string(preview, "originalUrl"),
+            raw=preview,
+        )
+
+
+async def create_gallery(voyager: Voyager, images: Sequence[Image], member_id: str) -> str:
+    """Create the multi-photo entity a gallery post references; returns its URN."""
+    body = payloads.multi_photo(images, f"urn:li:member:{member_id}")
+    reply = await voyager.post(MULTI_PHOTOS, body)
+    urn = string(reply.data, "identifierUrn") or reply.created_id
+    if not urn:
+        raise UnconfirmedWrite("LinkedIn did not create the image gallery.")
+    return urn
+
+
+async def create_poll(voyager: Voyager, poll: NewPoll) -> str:
+    """Create the poll entity a poll post references; returns its URN."""
+    data = await voyager.mutate(CREATE_POLL, {"pollInput": payloads.poll(poll)})
+    urn = string(data, "doCreatePollFeedDashPollsPollSummary", "result", "entityUrn")
+    if not urn:
+        raise UnconfirmedWrite("LinkedIn did not create the poll.")
+    return urn
+
+
+def _single_upload_path(upload: dict[str, object]) -> str:
+    """The origin-relative path of a single-request upload on www.linkedin.com."""
+    kind = upload.get("type")
+    url = upload.get("singleUploadUrl")
+    if kind != "SINGLE" or not isinstance(url, str):
+        name = kind if isinstance(kind, str) and kind.isidentifier() else "different"
+        raise ProtocolError(f"LinkedIn asked for a {name} upload, which is not supported.")
+    path = Transport.upload_path(url, "/dms-uploads/")
+    if path is None:
+        raise ProtocolError("LinkedIn offered an upload location this client does not support.")
+    return path

async_linkedinlib/resources/posts/payloads.py

@@ -0,0 +1,98 @@
+"""JSON bodies for the app's share models: commentary, share media, multi-photo and poll input.
+
+Field names come from the pegasus `contentcreation` "ForCreate" models; unions are written
+as `{"<member>": value}` and text attributes count Unicode code points, as the app does.
+"""
+
+from collections.abc import Sequence
+from datetime import datetime
+from typing import Any
+
+from ...models.comments import Mention
+from ...models.posts import Document
+from ...models.posts import Image
+from ...models.posts import NewPoll
+from ...models.posts import Video
+from ..mentions import attributes
+
+# The composer marks files picked from the device this way (camera captures differ).
+_PICKED = "PRE_RECORDED"
+
+
+def commentary(text: str, mentions: Sequence[Mention] = ()) -> dict[str, Any]:
+    """A `TextViewModelForCreate` with one attribute per mention, in text order."""
+    if not isinstance(text, str):
+        raise ValueError("Post text must be a string.")
+    return {"text": text, "attributesV2": attributes(text, mentions)}
+
+
+def image(item: Image) -> dict[str, Any]:
+    body = {
+        "category": "IMAGE",
+        "mediaUrn": item.media.urn,
+        "recipes": list(item.media.recipes),
+        "tapTargets": [],
+        "nativeMediaSource": _PICKED,
+    }
+    if item.alt_text:
+        body["altText"] = item.alt_text
+    return body
+
+
+def video(item: Video) -> dict[str, Any]:
+    return {
+        "category": "VIDEO",
+        "mediaUrn": item.media.urn,
+        "recipes": list(item.media.recipes),
+        "tapTargets": [],
+        "nativeMediaSource": _PICKED,
+    }
+
+
+def document(item: Document) -> dict[str, Any]:
+    return {
+        "category": "NATIVE_DOCUMENT",
+        "mediaUrn": item.media.urn,
+        "recipes": list(item.media.recipes),
+        "title": item.title,
+    }
+
+
+def reference(urn: str, original_url: str | None = None) -> dict[str, Any]:
+    """Share media pointing at another entity: a multi-photo, a poll or an article."""
+    body = {"category": "URN_REFERENCE", "mediaUrn": urn}
+    if original_url:
+        body["originalUrl"] = original_url
+    return body
+
+
+def multi_photo(images: Sequence[Image], author_urn: str) -> dict[str, Any]:
+    """A `MultiPhoto` gallery that one share references."""
+    entities = []
+    for item in images:
+        entity: dict[str, Any] = {
+            "mediaUrn": item.media.urn,
+            "tapTargets": [],
+            "mediaSource": _PICKED,
+        }
+        if item.alt_text:
+            entity["altText"] = item.alt_text
+        entities.append(entity)
+    return {"authorUrn": author_urn, "entities": entities}
+
+
+def poll(item: NewPoll) -> dict[str, Any]:
+    return {
+        "question": item.question,
+        "options": list(item.options),
+        "duration": item.duration.value,
+    }
+
+
+def epoch_millis(when: datetime) -> int:
+    """A future, timezone-aware time as epoch milliseconds."""
+    if not isinstance(when, datetime) or when.tzinfo is None:
+        raise ValueError("A timezone-aware datetime is required.")
+    if when.timestamp() <= datetime.now(when.tzinfo).timestamp():
+        raise ValueError("The publish time must be in the future.")
+    return int(when.timestamp() * 1000)

async_linkedinlib/resources/posts/resource.py

@@ -0,0 +1,254 @@
+"""Publish and manage the account's own posts with the app's content-creation operations.
+
+Posts are shares: GraphQL `ContentCreationShares` creates one (now or scheduled),
+`UpdateContentCreationShares` edits it and `DeleteContentcreationSharesByUrn` deletes it.
+Instant reposts are the `voyagerFeedDashReposts` rest.li resource; comment control is the
+social detail's `updateCommentsRestrictions` action. Every write is sent once.
+"""
+
+import re
+from collections.abc import Sequence
+from datetime import datetime
+from typing import Any
+
+from ...exceptions import UnconfirmedWrite
+from ...models._json import obj
+from ...models._json import string
+from ...models.comments import Mention
+from ...models.pagination import Cursor
+from ...models.pagination import Page
+from ...models.posts import CommentScope
+from ...models.posts import Document
+from ...models.posts import Image
+from ...models.posts import LinkPreview
+from ...models.posts import NewPoll
+from ...models.posts import Video
+from ...models.posts import Visibility
+from ...models.posts_results import Repost
+from ...models.posts_results import ScheduledPost
+from ...models.posts_results import SharedPost
+from ...transport.voyager import GraphQLQuery
+from ...transport.voyager import Voyager
+from .. import paging
+from .. import threads
+from . import payloads
+from .media import PostMedia
+from .media import create_gallery
+from .media import create_poll
+
+CREATE = GraphQLQuery(
+    "voyagerContentcreationDashShares.b204104430581f83625ea92a74bf7aa4", "ContentCreationShares"
+)
+UPDATE = GraphQLQuery(
+    "voyagerContentcreationDashShares.14eb3970f345c9c1128e0d57197cbf55",
+    "UpdateContentCreationShares",
+)
+DELETE = GraphQLQuery(
+    "voyagerContentcreationDashShares.3f82a2271a8c6a93dae7661d0e57ed26",
+    "DeleteContentcreationSharesByUrn",
+)
+SCHEDULED = GraphQLQuery(
+    "voyagerContentcreationDashSharePreviews.272c771715d3b231b34514af90ead86b",
+    "ContentCreationSharePreviewsByShareLifeCycleState",
+)
+REPOSTS = "voyagerFeedDashReposts"
+REPOST_DECORATION = "com.linkedin.voyager.dash.deco.feed.repost.Repost-3"
+SOCIAL_DETAILS = "voyagerSocialDashSocialDetails"
+
+_SHARE = re.compile(r"urn:li:(share|ugcPost):[0-9]+")
+_REPOST = re.compile(r"urn:li:fsd_repost:urn:li:[A-Za-z]+:\(urn:li:[A-Za-z]+:[0-9]+,[0-9]+\)")
+
+# What one post can carry: an image or a gallery, a video, a document, a poll or a link card.
+Attachment = Image | Sequence[Image] | Video | Document | NewPoll | LinkPreview
+
+
+class Posts:
+    """Create, edit, delete, schedule and repost the account's posts.
+
+    `media` uploads files and previews links for attachments.
+    """
+
+    def __init__(self, voyager: Voyager) -> None:
+        self._voyager = voyager
+        self.media = PostMedia(voyager)
+
+    async def create(
+        self,
+        text: str = "",
+        *,
+        visibility: Visibility = Visibility.ANYONE,
+        comments: CommentScope = CommentScope.ANYONE,
+        mentions: Sequence[Mention] = (),
+        media: Attachment | None = None,
+        publish_at: datetime | None = None,
+    ) -> SharedPost:
+        """Publish a post now, or schedule it for `publish_at`.
+
+        `media` attaches one thing: one or more `Image`s, a `Video`, a `Document`, a
+        `NewPoll` or a `LinkPreview`. Several images first create a gallery, and a poll its
+        poll entity; those stay behind if the post itself is then refused.
+        """
+        entity = _share(text, visibility, comments, mentions, publish_at)
+        if media is None and not text.strip():
+            raise ValueError("A post needs text or media.")
+        if media is not None:
+            entity["media"] = await self._attach(media)
+        return await self._create(entity)
+
+    async def repost_with_thoughts(
+        self,
+        share_urn: str,
+        text: str,
+        *,
+        visibility: Visibility = Visibility.ANYONE,
+        comments: CommentScope = CommentScope.ANYONE,
+        mentions: Sequence[Mention] = (),
+    ) -> SharedPost:
+        """Share someone's post with your own text above it (the original's share URN)."""
+        parent = _share_urn(share_urn)
+        if not isinstance(text, str) or not text.strip():
+            raise ValueError("Repost with thoughts needs text; use repost() otherwise.")
+        entity = _share(text, visibility, comments, mentions, None, origin="RESHARE")
+        entity["parentUrn"] = parent
+        return await self._create(entity)
+
+    async def edit(
+        self, share_urn: str, text: str, *, mentions: Sequence[Mention] = ()
+    ) -> SharedPost:
+        """Replace a post's text and mentions; the app edits nothing else after publishing."""
+        if not isinstance(text, str) or not text.strip():
+            raise ValueError("Edited text must not be empty.")
+        changes = {"commentary": payloads.commentary(text, mentions)}
+        return await self._update(share_urn, changes)
+
+    async def delete(self, share_urn: str) -> None:
+        """Delete a published post."""
+        await self._voyager.mutate(DELETE, {"resourceKey": _share_urn(share_urn)})
+
+    async def set_comment_scope(self, post_urn: str, scope: CommentScope) -> None:
+        """Change who can comment on a published post (its activity or ugcPost thread)."""
+        detail = threads.social_detail(threads.post(post_urn))
+        await self._voyager.post(
+            f"{SOCIAL_DETAILS}/{detail}",
+            {"allowedCommentersScope": CommentScope(scope).value},
+            {"action": "updateCommentsRestrictions"},
+        )
+
+    async def repost(self, share_urn: str) -> Repost:
+        """Repost a post instantly, without text; keep the result to undo it."""
+        reply = await self._voyager.post(
+            REPOSTS, {"rootContentUrn": _share_urn(share_urn)}, {"decorationId": REPOST_DECORATION}
+        )
+        urn = string(reply.data, "entityUrn") or reply.created_id
+        if not urn:
+            raise UnconfirmedWrite("LinkedIn's repost reply did not name the repost.")
+        return Repost(
+            urn=urn,
+            root_urn=string(reply.data, "rootContentUrn"),
+            message=string(reply.data, "toastMainText"),
+            raw=reply.data,
+        )
+
+    async def undo_repost(self, repost_urn: str) -> None:
+        """Remove an instant repost by its `Repost.urn`."""
+        if not isinstance(repost_urn, str) or not _REPOST.fullmatch(repost_urn):
+            raise ValueError("A Repost.urn (urn:li:fsd_repost:...) is required.")
+        await self._voyager.delete(f"{REPOSTS}/{repost_urn}")
+
+    async def scheduled(
+        self, *, count: int = 10, cursor: Cursor | None = None
+    ) -> Page[ScheduledPost]:
+        """Read one page of the account's scheduled posts, soonest first."""
+        if type(count) is not int or not 1 <= count <= 100:
+            raise ValueError("count must be between 1 and 100.")
+        start, _token = paging.resume(cursor, "posts.scheduled", "SCHEDULED", self._voyager.owner)
+        data = await self._voyager.query(
+            SCHEDULED, {"shareLifeCycleState": "SCHEDULED", "start": start, "count": count}
+        )
+        found = paging.collection(data, "contentcreationDashSharePreviewsByShareLifeCycleState")
+        return paging.page(
+            found,
+            ScheduledPost.from_preview,
+            "posts.scheduled",
+            "SCHEDULED",
+            start,
+            count,
+            self._voyager.owner,
+        )
+
+    async def reschedule(self, share_urn: str, publish_at: datetime) -> SharedPost:
+        """Move a scheduled post to a new future time."""
+        return await self._update(share_urn, {"scheduledAt": payloads.epoch_millis(publish_at)})
+
+    async def cancel_scheduled(self, share_urn: str) -> None:
+        """Delete a scheduled post before it is published."""
+        await self._voyager.mutate(
+            # The app's delete spells it shareLifecycleState; its list uses shareLifeCycleState.
+            DELETE,
+            {"resourceKey": _share_urn(share_urn), "shareLifecycleState": "SCHEDULED"},
+        )
+
+    async def _create(self, entity: dict[str, Any]) -> SharedPost:
+        data = await self._voyager.mutate(CREATE, {"entity": entity})
+        return _shared(data, "createContentcreationDashShares")
+
+    async def _update(self, share_urn: str, changes: dict[str, Any]) -> SharedPost:
+        variables = {"entity": {"resourceKey": _share_urn(share_urn), "entity": changes}}
+        data = await self._voyager.mutate(UPDATE, variables)
+        return _shared(data, "updateContentcreationDashShares")
+
+    async def _attach(self, media: Attachment) -> dict[str, Any]:
+        """The share's media; galleries and polls are created first, as the app does."""
+        if isinstance(media, Video):
+            return payloads.video(media)
+        if isinstance(media, Document):
+            return payloads.document(media)
+        if isinstance(media, LinkPreview):
+            return payloads.reference(media.article_urn, media.original_url)
+        if isinstance(media, NewPoll):
+            return payloads.reference(await create_poll(self._voyager, media))
+        images = (media,) if isinstance(media, Image) else media
+        if isinstance(images, Sequence) and images and all(isinstance(i, Image) for i in images):
+            if len(images) == 1:
+                return payloads.image(images[0])
+            member_id = self._voyager.transport.session.member_id
+            if not member_id:
+                raise ValueError("Call account.me() first so the session knows its member.")
+            return payloads.reference(await create_gallery(self._voyager, images, member_id))
+        raise ValueError("media must be Image(s), a Video, a Document, a NewPoll or a LinkPreview.")
+
+
+def _share(
+    text: str,
+    visibility: Visibility,
+    comments: CommentScope,
+    mentions: Sequence[Mention],
+    publish_at: datetime | None,
+    origin: str = "FEED",
+) -> dict[str, Any]:
+    """A `ShareForCreate` as the share box builds it from the feed."""
+    entity: dict[str, Any] = {
+        "allowedCommentersScope": CommentScope(comments).value,
+        "origin": origin,
+        "visibilityDataUnion": {"visibilityType": Visibility(visibility).value},
+        "commentary": payloads.commentary(text, mentions),
+    }
+    if publish_at is not None:
+        entity["scheduledAt"] = payloads.epoch_millis(publish_at)
+        entity["intendedShareLifeCycleState"] = "SCHEDULED"
+    return entity
+
+
+def _shared(data: dict[str, Any], field: str) -> SharedPost:
+    shared = SharedPost.from_reply(obj(data.get(field)))
+    if shared is None:
+        raise UnconfirmedWrite("LinkedIn's reply did not name the share.")
+    return shared
+
+
+def _share_urn(urn: str) -> str:
+    if not isinstance(urn, str) or not _SHARE.fullmatch(urn):
+        raise ValueError(
+            "A share URN such as urn:li:share:<id> or urn:li:ugcPost:<id> is required."
+        )
+    return urn

async_linkedinlib/resources/reactions.py

@@ -0,0 +1,89 @@
+"""Reactions on any social thread: a post's activity or ugcPost URN, or a comment URN."""
+
+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
+
+CREATE = GraphQLQuery(
+    "voyagerSocialDashReactions.fd68eadaf15da416b0d839e21399b763", "CreateSocialDashReaction"
+)
+UPDATE = GraphQLQuery(
+    "voyagerSocialDashReactions.846a42c007e6a1741763e9f23956ea0b", "UpdateSocialDashReaction"
+)
+DELETE = GraphQLQuery(
+    "voyagerSocialDashReactions.315cef4773de8e3a0ddad7655cc1685f", "DeleteSocialDashReaction"
+)
+# conversations/reactionsdetail/ReactionsDetailRepository$$ExternalSyntheticLambda0
+LIST = GraphQLQuery(
+    "voyagerSocialDashReactions.e996ddaa8544fdbec4f17d40ad2d089a",
+    "FetchSocialDashReactionsByReactionType",
+)
+# The reactions screen pages 10 at a time; larger pages were verified up to 50.
+MAX_COUNT = 50
+
+
+class Reactions:
+    """The viewer's reaction on one thread, and who reacted; each write is sent once."""
+
+    def __init__(self, voyager: Voyager) -> None:
+        self._voyager = voyager
+
+    async def add(self, thread_urn: str, reaction: ReactionType = ReactionType.LIKE) -> None:
+        await self._voyager.mutate(
+            CREATE,
+            {
+                "threadUrn": threads.thread(thread_urn),
+                "entity": {"reactionType": ReactionType(reaction).value},
+            },
+        )
+
+    async def change(self, thread_urn: str, reaction: ReactionType) -> None:
+        await self._voyager.mutate(
+            UPDATE,
+            {
+                "threadUrn": threads.thread(thread_urn),
+                "newReactionType": ReactionType(reaction).value,
+            },
+        )
+
+    async def remove(self, thread_urn: str) -> None:
+        await self._voyager.mutate(DELETE, {"threadUrn": threads.thread(thread_urn)})
+
+    async def list(
+        self,
+        thread_urn: str,
+        *,
+        reaction: ReactionType | None = None,
+        sort: ReactionSort = ReactionSort.RELEVANCE,
+        count: int = 10,
+        cursor: Cursor | None = None,
+    ) -> Page[Reactor]:
+        """One page of who reacted to a post or comment, optionally of one reaction type."""
+        thread = threads.thread(thread_urn)
+        kind = ReactionType(reaction).value if reaction is not None else None
+        order = ReactionSort(sort)
+        if type(count) is not int or not 1 <= count <= MAX_COUNT:
+            raise ValueError(f"count must be an integer from 1 to {MAX_COUNT}.")
+        # A pagination token pins its query, so the type and order belong to the scope.
+        scope = f"{thread}|{kind or ''}|{order.value}"
+        owner = self._voyager.owner
+        start, token = paging.resume(cursor, "reactions.list", scope, owner)
+        variables = {
+            "threadUrn": thread,
+            "count": count,
+            "paginationToken": token,
+            "reactionType": kind,
+            "sortOrder": order.value,
+            "start": start,
+        }
+        data = await self._voyager.query(LIST, variables)
+        found = paging.collection(data, "socialDashReactionsByReactionType")
+        return paging.page(
+            found, Reactor.from_reaction, "reactions.list", scope, start, count, owner
+        )

async_linkedinlib/resources/search/__init__.py

@@ -0,0 +1,5 @@
+"""Search resource exports."""
+
+from .search import Search  # People, posts, companies, jobs and more; filters and typeahead.
+
+__all__ = ["Search"]