python-xbox 0.1.0rc0__py3-none-any.whl

webapi/api/provider/gameclips/__init__.py

@@ -0,0 +1,167 @@
+"""
+Gameclips - Get gameclip info
+"""
+
+from xbox.webapi.api.provider.baseprovider import BaseProvider
+from xbox.webapi.api.provider.gameclips.models import GameclipsResponse
+
+
+class GameclipProvider(BaseProvider):
+    GAMECLIPS_METADATA_URL = "https://gameclipsmetadata.xboxlive.com"
+    HEADERS_GAMECLIPS_METADATA = {"x-xbl-contract-version": "1"}
+
+    async def get_recent_community_clips_by_title_id(
+        self, title_id: str, **kwargs
+    ) -> GameclipsResponse:
+        """
+        Get recent community clips by Title Id
+
+        Args:
+            title_id: Title Id to get clips for
+
+        Returns:
+            :class:`GameclipsResponse`: Game clip Response
+        """
+        url = self.GAMECLIPS_METADATA_URL + f"/public/titles/{title_id}/clips"
+        params = {"qualifier": "created"}
+        resp = await self.client.session.get(
+            url, params=params, headers=self.HEADERS_GAMECLIPS_METADATA, **kwargs
+        )
+        resp.raise_for_status()
+        return GameclipsResponse(**resp.json())
+
+    async def get_recent_own_clips(
+        self, title_id: str = None, skip_items: int = 0, max_items: int = 25, **kwargs
+    ) -> GameclipsResponse:
+        """
+        Get own recent clips, optionally filter for title Id
+
+        Args:
+            title_id: Title ID to filter
+            skip_items: Item count to skip
+            max_items: Maximum item count to load
+
+        Returns:
+            :class:`GameclipsResponse`: Game clip Response
+        """
+        url = self.GAMECLIPS_METADATA_URL + "/users/me"
+        if title_id:
+            url += f"/titles/{title_id}"
+        url += "/clips"
+
+        params = {"skipItems": skip_items, "maxItems": max_items}
+        resp = await self.client.session.get(
+            url, params=params, headers=self.HEADERS_GAMECLIPS_METADATA, **kwargs
+        )
+        resp.raise_for_status()
+        return GameclipsResponse(**resp.json())
+
+    async def get_recent_clips_by_xuid(
+        self,
+        xuid: str,
+        title_id: str = None,
+        skip_items: int = 0,
+        max_items: int = 25,
+        **kwargs,
+    ) -> GameclipsResponse:
+        """
+        Get clips by XUID, optionally filter for title Id
+
+        Args:
+            xuid: XUID of user to get clips from
+            title_id: Optional title id filter
+            skip_items: Item count to skip
+            max_items: Maximum item count to load
+
+        Returns:
+            :class:`GameclipsResponse`: Game clip Response
+        """
+        url = self.GAMECLIPS_METADATA_URL + f"/users/xuid({xuid})"
+        if title_id:
+            url += f"/titles/{title_id}"
+        url += "/clips"
+
+        params = {"skipItems": skip_items, "maxItems": max_items}
+        resp = await self.client.session.get(
+            url, params=params, headers=self.HEADERS_GAMECLIPS_METADATA, **kwargs
+        )
+        resp.raise_for_status()
+        return GameclipsResponse(**resp.json())
+
+    async def get_saved_community_clips_by_title_id(
+        self, title_id: str, **kwargs
+    ) -> GameclipsResponse:
+        """
+        Get saved community clips by Title Id
+
+        Args:
+            title_id: Title Id to get screenshots for
+
+        Returns:
+            :class:`GameclipsResponse`: Game clip Response
+        """
+        url = self.GAMECLIPS_METADATA_URL + f"/public/titles/{title_id}/clips/saved"
+        params = {"qualifier": "created"}
+        resp = await self.client.session.get(
+            url, params=params, headers=self.HEADERS_GAMECLIPS_METADATA, **kwargs
+        )
+        resp.raise_for_status()
+        return GameclipsResponse(**resp.json())
+
+    async def get_saved_own_clips(
+        self, title_id: str = None, skip_items: int = 0, max_items: int = 25, **kwargs
+    ) -> GameclipsResponse:
+        """
+        Get own saved clips, optionally filter for title Id an
+
+        Args:
+            title_id: Optional Title ID to filter
+            skip_items: Item count to skip
+            max_items: Maximum item count to load
+
+        Returns:
+            :class:`GameclipsResponse`: Game clip Response
+        """
+        url = self.GAMECLIPS_METADATA_URL + "/users/me"
+        if title_id:
+            url += f"/titles/{title_id}"
+        url += "/clips/saved"
+
+        params = {"skipItems": skip_items, "maxItems": max_items}
+        resp = await self.client.session.get(
+            url, params=params, headers=self.HEADERS_GAMECLIPS_METADATA, **kwargs
+        )
+        resp.raise_for_status()
+        return GameclipsResponse(**resp.json())
+
+    async def get_saved_clips_by_xuid(
+        self,
+        xuid: str,
+        title_id: str = None,
+        skip_items: int = 0,
+        max_items: int = 25,
+        **kwargs,
+    ) -> GameclipsResponse:
+        """
+        Get saved clips by XUID, optionally filter for title Id
+
+        Args:
+            xuid: XUID of user to get screenshots from
+            title_id: Optional title id filter
+            skip_items: Item count to skip
+            max_items: Maximum item count to load
+
+        Returns:
+            :class:`GameclipsResponse`: Game clip Response
+        """
+        url = self.GAMECLIPS_METADATA_URL + f"/users/xuid({xuid})"
+        if title_id:
+            url += f"/titles/{title_id}"
+        url += "/clips/saved"
+
+        params = {"skipItems": skip_items, "maxItems": max_items}
+        resp = await self.client.session.get(
+            url, params=params, headers=self.HEADERS_GAMECLIPS_METADATA, **kwargs
+        )
+        resp.raise_for_status()
+        return GameclipsResponse(**resp.json())

webapi/api/provider/gameclips/models.py

@@ -0,0 +1,59 @@
+from datetime import datetime
+from typing import List, Optional
+
+from xbox.webapi.common.models import CamelCaseModel
+
+
+class Thumbnail(CamelCaseModel):
+    uri: str
+    file_size: int
+    thumbnail_type: int
+
+
+class GameClipUri(CamelCaseModel):
+    uri: str
+    file_size: int
+    uri_type: int
+    expiration: str
+
+
+class GameClip(CamelCaseModel):
+    game_clip_id: str
+    state: int
+    date_published: datetime
+    date_recorded: datetime
+    last_modified: datetime
+    user_caption: str
+    type: int
+    duration_in_seconds: int
+    scid: str
+    title_id: int
+    rating: float
+    rating_count: int
+    views: int
+    title_data: str
+    system_properties: str
+    saved_by_user: bool
+    achievement_id: str
+    greatest_moment_id: str
+    thumbnails: List[Thumbnail]
+    game_clip_uris: List[GameClipUri]
+    xuid: str
+    clip_name: str
+    title_name: str
+    game_clip_locale: str
+    clip_content_attributes: int
+    device_type: str
+    comment_count: int
+    like_count: int
+    share_count: int
+    partial_views: int
+
+
+class PagingInfo(CamelCaseModel):
+    continuation_token: Optional[str] = None
+
+
+class GameclipsResponse(CamelCaseModel):
+    game_clips: List[GameClip]
+    paging_info: PagingInfo

webapi/api/provider/lists/__init__.py

@@ -0,0 +1,71 @@
+"""
+EPLists - Mainly used for XBL Pins
+"""
+
+from xbox.webapi.api.provider.baseprovider import BaseProvider
+from xbox.webapi.api.provider.lists.models import ListMetadata, ListsResponse
+
+
+class ListsProvider(BaseProvider):
+    LISTS_URL = "https://eplists.xboxlive.com"
+    HEADERS_LISTS = {"Content-Type": "application/json", "x-xbl-contract-version": "2"}
+
+    SEPERATOR = "."
+
+    async def remove_items(
+        self, xuid: str, post_body: dict, listname: str = "XBLPins", **kwargs
+    ) -> ListMetadata:
+        """
+        Remove items from specific list, defaults to "XBLPins"
+
+        Args:
+            xuid (str/int): Xbox User Id
+            listname (str): Name of list to edit
+
+        Returns:
+            :class:`ListMetadata`: List Metadata Response
+        """
+        url = self.LISTS_URL + f"/users/xuid({xuid})/lists/PINS/{listname}"
+        resp = await self.client.session.delete(
+            url, json=post_body, headers=self.HEADERS_LISTS, **kwargs
+        )
+        resp.raise_for_status()
+        return ListMetadata(**resp.json())
+
+    async def get_items(
+        self, xuid: str, listname: str = "XBLPins", **kwargs
+    ) -> ListsResponse:
+        """
+        Get items from specific list, defaults to "XBLPins"
+
+        Args:
+            xuid (str/int): Xbox User Id
+            listname (str): Name of list to edit
+
+        Returns:
+            :class:`ListsResponse`: List Response
+        """
+        url = self.LISTS_URL + f"/users/xuid({xuid})/lists/PINS/{listname}"
+        resp = await self.client.session.get(url, headers=self.HEADERS_LISTS, **kwargs)
+        resp.raise_for_status()
+        return ListsResponse(**resp.json())
+
+    async def insert_items(
+        self, xuid: str, post_body: dict, listname: str = "XBLPins", **kwargs
+    ) -> ListMetadata:
+        """
+        Insert items to specific list, defaults to "XBLPins"
+
+        Args:
+            xuid (str/int): Xbox User Id
+            listname (str): Name of list to edit
+
+        Returns:
+            :class:`ListMetadata`: List Metadata Response
+        """
+        url = self.LISTS_URL + f"/users/xuid({xuid})/lists/PINS/{listname}"
+        resp = await self.client.session.post(
+            url, json=post_body, headers=self.HEADERS_LISTS, **kwargs
+        )
+        resp.raise_for_status()
+        return ListMetadata(**resp.json())

webapi/api/provider/lists/models.py

@@ -0,0 +1,35 @@
+from typing import List, Optional
+
+from xbox.webapi.common.models import PascalCaseModel
+
+
+class Item(PascalCaseModel):
+    item_id: str
+    content_type: str
+    title: Optional[str] = None
+    device_type: str
+    provider: Optional[str] = None
+    provider_id: Optional[str] = None
+
+
+class ListItem(PascalCaseModel):
+    date_added: str
+    date_modified: str
+    index: int
+    k_value: int
+    item: Item
+
+
+class ListMetadata(PascalCaseModel):
+    list_title: str
+    list_version: int
+    list_count: int
+    allow_duplicates: bool
+    max_list_size: int
+    access_setting: str
+
+
+class ListsResponse(PascalCaseModel):
+    impression_id: str
+    list_items: List[ListItem]
+    list_metadata: ListMetadata

webapi/api/provider/mediahub/__init__.py

@@ -0,0 +1,64 @@
+"""
+Mediahub - Fetch screenshots and gameclips
+"""
+
+from xbox.webapi.api.provider.baseprovider import BaseProvider
+from xbox.webapi.api.provider.mediahub.models import (
+    MediahubGameclips,
+    MediahubScreenshots,
+)
+
+
+class MediahubProvider(BaseProvider):
+    MEDIAHUB_URL = "https://mediahub.xboxlive.com"
+    HEADERS = {"x-xbl-contract-version": "3"}
+
+    async def fetch_own_clips(
+        self, skip: int = 0, count: int = 500, **kwargs
+    ) -> MediahubGameclips:
+        """
+        Fetch own clips
+
+        Args:
+            skip: Number of items to skip
+            count: Max entries to fetch
+
+        Returns:
+            :class:`MediahubGameclips`: Gameclips
+        """
+        url = f"{self.MEDIAHUB_URL}/gameclips/search"
+        post_data = {
+            "max": count,
+            "query": f"OwnerXuid eq {self.client.xuid}",
+            "skip": skip,
+        }
+        resp = await self.client.session.post(
+            url, json=post_data, headers=self.HEADERS, **kwargs
+        )
+        resp.raise_for_status()
+        return MediahubGameclips(**resp.json())
+
+    async def fetch_own_screenshots(
+        self, skip: int = 0, count: int = 500, **kwargs
+    ) -> MediahubScreenshots:
+        """
+        Fetch own screenshots
+
+        Args:
+            skip: Number of items to skip
+            count: Max entries to fetch
+
+        Returns:
+            :class:`MediahubScreenshots`: Screenshots
+        """
+        url = f"{self.MEDIAHUB_URL}/screenshots/search"
+        post_data = {
+            "max": count,
+            "query": f"OwnerXuid eq {self.client.xuid}",
+            "skip": skip,
+        }
+        resp = await self.client.session.post(
+            url, json=post_data, headers=self.HEADERS, **kwargs
+        )
+        resp.raise_for_status()
+        return MediahubScreenshots(**resp.json())

webapi/api/provider/mediahub/models.py

@@ -0,0 +1,84 @@
+from typing import List, Optional
+
+from xbox.webapi.common.models import CamelCaseModel
+
+
+class ContentSegment(CamelCaseModel):
+    segment_id: int
+    creation_type: str
+    creator_channel_id: Optional[str] = None
+    creator_xuid: int
+    record_date: str
+    duration_in_seconds: int
+    offset: int
+    secondary_title_id: Optional[int] = None
+    title_id: int
+
+
+class ContentLocator(CamelCaseModel):
+    expiration: Optional[str] = None
+    file_size: Optional[int] = None
+    locator_type: str
+    uri: str
+
+
+class GameclipContent(CamelCaseModel):
+    content_id: str
+    content_locators: List[ContentLocator]
+    content_segments: List[ContentSegment]
+    creation_type: str
+    duration_in_seconds: int
+    local_id: str
+    owner_xuid: int
+    sandbox_id: str
+    shared_to: List[int]
+    title_id: int
+    title_name: str
+    upload_date: str
+    upload_language: str
+    upload_region: str
+    upload_title_id: int
+    upload_device_type: str
+    comment_count: int
+    like_count: int
+    share_count: int
+    view_count: int
+    content_state: str
+    enforcement_state: str
+    sessions: List[str]
+    tournaments: List[str]
+
+
+class MediahubGameclips(CamelCaseModel):
+    values: List[GameclipContent]
+
+
+class ScreenshotContent(CamelCaseModel):
+    content_id: str
+    capture_date: str
+    content_locators: List[ContentLocator]
+    local_id: str
+    owner_xuid: int
+    resolution_height: int
+    resolution_width: int
+    date_uploaded: str
+    sandbox_id: str
+    shared_to: List[int]
+    title_id: int
+    title_name: str
+    upload_language: str
+    upload_region: str
+    upload_title_id: int
+    upload_device_type: str
+    comment_count: int
+    like_count: int
+    share_count: int
+    view_count: int
+    content_state: str
+    enforcement_state: str
+    sessions: List[str]
+    tournaments: List[str]
+
+
+class MediahubScreenshots(CamelCaseModel):
+    values: List[ScreenshotContent]

webapi/api/provider/message/__init__.py

@@ -0,0 +1,135 @@
+"""
+Message - Read and send messages
+
+TODO: Support group messaging
+"""
+
+from xbox.webapi.api.provider.baseprovider import BaseProvider
+from xbox.webapi.api.provider.message.models import (
+    ConversationResponse,
+    InboxResponse,
+    SendMessageResponse,
+)
+
+
+class MessageProvider(BaseProvider):
+    MSG_URL = "https://xblmessaging.xboxlive.com"
+    HEADERS_MESSAGE = {"x-xbl-contract-version": "1"}
+    HEADERS_HORIZON = {"x-xbl-contract-version": "2"}
+
+    async def get_inbox(self, max_items: int = 100, **kwargs) -> InboxResponse:
+        """
+        Get messages
+
+        Returns:
+            :class:`InboxResponse`: Inbox Response
+        """
+        url = f"{self.MSG_URL}/network/Xbox/users/me/inbox"
+        params = {"maxItems": max_items}
+        resp = await self.client.session.get(
+            url, params=params, headers=self.HEADERS_MESSAGE, **kwargs
+        )
+        resp.raise_for_status()
+        return InboxResponse(**resp.json())
+
+    async def get_conversation(
+        self, xuid: str, max_items: int = 100, **kwargs
+    ) -> ConversationResponse:
+        """
+        Get detailed conversation info
+
+        Args:
+            xuid: Xuid of user having a conversation with
+
+        Returns:
+            :class:`ConversationResponse`: Conversation Response
+        """
+        url = f"{self.MSG_URL}/network/Xbox/users/me/conversations/users/xuid({xuid})"
+        params = {"maxItems": max_items}
+        resp = await self.client.session.get(
+            url, params=params, headers=self.HEADERS_MESSAGE, **kwargs
+        )
+        resp.raise_for_status()
+        return ConversationResponse(**resp.json())
+
+    async def delete_conversation(
+        self, conversation_id: str, horizon: str, **kwargs
+    ) -> bool:
+        """
+        Delete message
+
+        **NOTE**: Returns HTTP Status Code **200** on success
+
+        Args:
+            conversation_id: Message Id
+            horizon: Delete horizon from get conversation response
+
+        Returns: True on success, False otherwise
+        """
+        url = f"{self.MSG_URL}/network/Xbox/users/me/conversations/horizon"
+        post_data = {
+            "conversations": [
+                {
+                    "conversationId": conversation_id,
+                    "conversationType": "OneToOne",
+                    "horizonType": "Delete",
+                    "horizon": horizon,
+                }
+            ]
+        }
+        resp = await self.client.session.put(
+            url, json=post_data, headers=self.HEADERS_HORIZON, **kwargs
+        )
+        return resp.status_code == 200
+
+    async def delete_message(
+        self, conversation_id: str, message_id: str, **kwargs
+    ) -> bool:
+        """
+        Delete message
+
+        **NOTE**: Returns HTTP Status Code **200** on success
+
+        Args:
+            conversation_id: Conversation Id
+            message_id: Message Id
+
+        Returns: True on success, False otherwise
+        """
+        url = f"{self.MSG_URL}/network/Xbox/users/me/conversations/{conversation_id}/messages/{message_id}"
+        resp = await self.client.session.delete(
+            url, headers=self.HEADERS_MESSAGE, **kwargs
+        )
+        return resp.status_code == 200
+
+    async def send_message(
+        self, xuid: str, message_text: str, **kwargs
+    ) -> SendMessageResponse:
+        """
+        Send message to an xuid
+
+        Args:
+            xuid: Xuid
+            message_text: Message text
+
+        Returns:
+            :class:`SendMessageResponse`: Send Message Response
+        """
+        if len(message_text) > 256:
+            raise ValueError("Message text exceeds max length of 256 chars")
+
+        url = f"{self.MSG_URL}/network/Xbox/users/me/conversations/users/xuid({xuid})"
+        post_data = {
+            "parts": [
+                {
+                    "contentType": "text",
+                    "version": 0,
+                    "text": message_text,
+                }
+            ]
+        }
+        resp = await self.client.session.post(
+            url, json=post_data, headers=self.HEADERS_MESSAGE, **kwargs
+        )
+        resp.raise_for_status()
+        return SendMessageResponse(**resp.json())