python-xbox 0.1.0__py3-none-any.whl

pythonxbox/scripts/authenticate.py

@@ -0,0 +1,159 @@
+"""
+Example scripts that performs XBL authentication
+"""
+
+import argparse
+import asyncio
+import http.server
+import os
+import queue
+import socketserver
+import threading
+from urllib.parse import parse_qs, urlparse
+import webbrowser
+
+from pythonxbox.authentication.manager import AuthenticationManager
+from pythonxbox.authentication.models import OAuth2TokenResponse
+from pythonxbox.common.signed_session import SignedSession
+from pythonxbox.scripts import CLIENT_ID, CLIENT_SECRET, REDIRECT_URI, TOKENS_FILE
+
+QUEUE = queue.Queue(1)
+
+
+class AuthCallbackRequestHandler(http.server.BaseHTTPRequestHandler):
+    """
+    Handles the auth callback that's received when Windows Live auth flow completed
+    """
+
+    def do_GET(self) -> None:
+        try:
+            url_path = self.requestline.split(" ")[1]
+            query_params = parse_qs(urlparse(url_path).query)
+        except Exception as e:
+            self.send_error(
+                400,
+                explain=f"Invalid request='{self.requestline}' - Failed to parse URL Path, error={e}",
+            )
+            self.end_headers()
+            return
+
+        if query_params.get("error"):
+            error_description = query_params.get("error_description")
+            self.send_error(
+                400, explain=f"Auth callback failed - Error: {error_description}"
+            )
+            self.end_headers()
+            return
+
+        auth_code = query_params.get("code")
+        if not auth_code:
+            self.send_error(
+                400,
+                explain=f"Auth callback failed - No code received - Original request: {self.requestline}",
+            )
+            self.end_headers()
+            return
+
+        if isinstance(auth_code, list):
+            auth_code = auth_code[0]
+        elif isinstance(auth_code, str):
+            pass
+        else:
+            raise Exception(f"Invalid code query param: {auth_code}")
+
+        # Put auth_code into queue for do_auth to receive
+        QUEUE.put(auth_code)
+        response_body = b"<script>window.close()</script>"
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.send_header("Content-Length", str(len(response_body)))
+        self.end_headers()
+        self.wfile.write(response_body)
+
+
+async def do_auth(
+    client_id: str, client_secret: str, redirect_uri: str, token_filepath: str
+) -> None:
+    async with SignedSession() as session:
+        auth_mgr = AuthenticationManager(
+            session, client_id, client_secret, redirect_uri
+        )
+
+        # Refresh tokens if we have them
+        if os.path.exists(token_filepath):
+            with open(token_filepath) as f:
+                tokens = f.read()
+            auth_mgr.oauth = OAuth2TokenResponse.model_validate_json(tokens)
+            await auth_mgr.refresh_tokens()
+
+        # Request new ones if they are not valid
+        if not (auth_mgr.xsts_token and auth_mgr.xsts_token.is_valid()):
+            auth_url = auth_mgr.generate_authorization_url()
+            webbrowser.open(auth_url)
+            # Wait for auth code from http server thread
+            code = QUEUE.get()
+            await auth_mgr.request_tokens(code)
+
+        with open(token_filepath, mode="w") as f:
+            print(f"Finished authentication, writing tokens to {token_filepath}")
+            f.write(auth_mgr.oauth.model_dump_json())
+
+
+async def async_main() -> None:
+    parser = argparse.ArgumentParser(description="Authenticate with XBL")
+    parser.add_argument(
+        "--tokens",
+        "-t",
+        default=TOKENS_FILE,
+        help=f"Token filepath. Default: '{TOKENS_FILE}'",
+    )
+    parser.add_argument(
+        "--client-id",
+        "-cid",
+        default=os.environ.get("CLIENT_ID", CLIENT_ID),
+        help="OAuth2 Client ID",
+    )
+    parser.add_argument(
+        "--client-secret",
+        "-cs",
+        default=os.environ.get("CLIENT_SECRET", CLIENT_SECRET),
+        help="OAuth2 Client Secret",
+    )
+    parser.add_argument(
+        "--redirect-uri",
+        "-ru",
+        default=os.environ.get("REDIRECT_URI", REDIRECT_URI),
+        help="OAuth2 Redirect URI",
+    )
+    parser.add_argument(
+        "--port",
+        "-p",
+        default=8080,
+        type=int,
+        help="""
+        HTTP Server port for awaiting auth callback
+        * NOTE: Changing this will break default auth flow and requires providing own OAUTH parameters
+        """,
+    )
+    args = parser.parse_args()
+
+    with socketserver.TCPServer(
+        ("0.0.0.0", args.port), AuthCallbackRequestHandler
+    ) as httpd:
+        print(f"Serving HTTP Server for auth callback at port {args.port}")
+        server_thread = threading.Thread(target=httpd.serve_forever)
+        # Exit the server thread when the main thread terminates
+        server_thread.daemon = True
+        server_thread.start()
+
+        await do_auth(
+            args.client_id, args.client_secret, args.redirect_uri, args.tokens
+        )
+
+
+def main() -> None:
+    asyncio.run(async_main())
+
+
+if __name__ == "__main__":
+    main()

pythonxbox/scripts/change_gamertag.py

@@ -0,0 +1,111 @@
+"""
+Example script that enables using your one-time-free gamertag change
+"""
+
+import argparse
+import asyncio
+import os
+import sys
+
+from httpx import HTTPStatusError
+
+from pythonxbox.api.client import XboxLiveClient
+from pythonxbox.api.provider.account.models import (
+    ChangeGamertagResult,
+    ClaimGamertagResult,
+)
+from pythonxbox.authentication.manager import AuthenticationManager
+from pythonxbox.authentication.models import OAuth2TokenResponse
+from pythonxbox.common.signed_session import SignedSession
+from pythonxbox.scripts import CLIENT_ID, CLIENT_SECRET, TOKENS_FILE
+
+
+async def async_main() -> None:
+    parser = argparse.ArgumentParser(description="Change your gamertag")
+    parser.add_argument(
+        "--tokens",
+        "-t",
+        default=TOKENS_FILE,
+        help=f"Token filepath. Default: '{TOKENS_FILE}'",
+    )
+    parser.add_argument(
+        "--client-id",
+        "-cid",
+        default=os.environ.get("CLIENT_ID", CLIENT_ID),
+        help="OAuth2 Client ID",
+    )
+    parser.add_argument(
+        "--client-secret",
+        "-cs",
+        default=os.environ.get("CLIENT_SECRET", CLIENT_SECRET),
+        help="OAuth2 Client Secret",
+    )
+    parser.add_argument("gamertag", help="Desired Gamertag")
+
+    args = parser.parse_args()
+
+    if len(args.gamertag) > 15:
+        print("Desired gamertag exceedes limit of 15 chars")
+        sys.exit(-1)
+
+    if not os.path.exists(args.tokens):
+        print("No token file found, run xbox-authenticate")
+        sys.exit(-1)
+
+    async with SignedSession() as session:
+        auth_mgr = AuthenticationManager(
+            session, args.client_id, args.client_secret, ""
+        )
+
+        with open(args.tokens) as f:
+            tokens = f.read()
+        auth_mgr.oauth = OAuth2TokenResponse.model_validate_json(tokens)
+        try:
+            await auth_mgr.refresh_tokens()
+        except HTTPStatusError:
+            print("Could not refresh tokens")
+            sys.exit(-1)
+
+        with open(args.tokens, mode="w") as f:
+            f.write(auth_mgr.oauth.json())
+
+        xbl_client = XboxLiveClient(auth_mgr)
+
+        print(
+            ":: Trying to change gamertag to '%s' for xuid '%i'..."
+            % (args.gamertag, xbl_client.xuid)
+        )
+
+        print("Claiming gamertag...")
+        try:
+            resp = await xbl_client.account.claim_gamertag(
+                xbl_client.xuid, args.gamertag
+            )
+            if resp == ClaimGamertagResult.NotAvailable:
+                print("Claiming gamertag failed - Desired gamertag is unavailable")
+                sys.exit(-1)
+        except HTTPStatusError:
+            print("Invalid HTTP response from claim")
+            sys.exit(-1)
+
+        print("Changing gamertag...")
+        try:
+            resp = await xbl_client.account.change_gamertag(
+                xbl_client.xuid, args.gamertag
+            )
+            if resp == ChangeGamertagResult.NoFreeChangesAvailable:
+                print("Changing gamertag failed - You are out of free changes")
+                sys.exit(-1)
+        except HTTPStatusError:
+            print("Invalid HTTP response from change")
+            sys.exit(-1)
+
+        print("Gamertag successfully changed to %s" % args.gamertag)
+
+
+def main() -> None:
+    asyncio.run(async_main())
+
+
+if __name__ == "__main__":
+    main()

pythonxbox/scripts/friends.py

@@ -0,0 +1,80 @@
+"""
+Example script that enables using your one-time-free gamertag change
+"""
+
+import argparse
+import asyncio
+import os
+from pprint import pprint
+import sys
+
+from httpx import HTTPStatusError
+
+from pythonxbox.api.client import XboxLiveClient
+from pythonxbox.authentication.manager import AuthenticationManager
+from pythonxbox.authentication.models import OAuth2TokenResponse
+from pythonxbox.common.signed_session import SignedSession
+from pythonxbox.scripts import CLIENT_ID, CLIENT_SECRET, TOKENS_FILE
+
+
+async def async_main() -> None:
+    parser = argparse.ArgumentParser(description="Change your gamertag")
+    parser.add_argument(
+        "--tokens",
+        "-t",
+        default=TOKENS_FILE,
+        help=f"Token filepath. Default: '{TOKENS_FILE}'",
+    )
+    parser.add_argument(
+        "--client-id",
+        "-cid",
+        default=os.environ.get("CLIENT_ID", CLIENT_ID),
+        help="OAuth2 Client ID",
+    )
+    parser.add_argument(
+        "--client-secret",
+        "-cs",
+        default=os.environ.get("CLIENT_SECRET", CLIENT_SECRET),
+        help="OAuth2 Client Secret",
+    )
+
+    args = parser.parse_args()
+
+    if not os.path.exists(args.tokens):
+        print("No token file found, run xbox-authenticate")
+        sys.exit(-1)
+
+    async with SignedSession() as session:
+        auth_mgr = AuthenticationManager(
+            session, args.client_id, args.client_secret, ""
+        )
+
+        with open(args.tokens) as f:
+            tokens = f.read()
+        auth_mgr.oauth = OAuth2TokenResponse.model_validate_json(tokens)
+        try:
+            await auth_mgr.refresh_tokens()
+        except HTTPStatusError:
+            print("Could not refresh tokens")
+            sys.exit(-1)
+
+        with open(args.tokens, mode="w") as f:
+            f.write(auth_mgr.oauth.json())
+
+        xbl_client = XboxLiveClient(auth_mgr)
+
+        try:
+            resp = await xbl_client.people.get_friends_own()
+        except HTTPStatusError:
+            print("Invalid HTTP response")
+            sys.exit(-1)
+
+        pprint(resp.dict())
+
+
+def main() -> None:
+    asyncio.run(async_main())
+
+
+if __name__ == "__main__":
+    main()

pythonxbox/scripts/search.py

@@ -0,0 +1,43 @@
+"""
+Example script that utilizes EDSProvider to search XBL marketplace
+"""
+
+import argparse
+import asyncio
+from pprint import pprint
+import sys
+
+from httpx import HTTPStatusError
+
+from pythonxbox.api.client import XboxLiveClient
+from pythonxbox.authentication.manager import AuthenticationManager
+from pythonxbox.common.signed_session import SignedSession
+
+
+async def async_main() -> None:
+    parser = argparse.ArgumentParser(description="Search for Content on XBL")
+    parser.add_argument("search_query", help="Name to search for")
+
+    args = parser.parse_args()
+
+    async with SignedSession() as session:
+        auth_mgr = AuthenticationManager(session, "", "", "")
+
+        # No Auth necessary for catalog searches
+        xbl_client = XboxLiveClient(auth_mgr)
+
+        try:
+            resp = await xbl_client.catalog.product_search(args.search_query)
+        except HTTPStatusError:
+            print("Search failed")
+            sys.exit(-1)
+
+        pprint(resp.dict())
+
+
+def main() -> None:
+    asyncio.run(async_main())
+
+
+if __name__ == "__main__":
+    main()

pythonxbox/scripts/xal.py

@@ -0,0 +1,113 @@
+"""
+Example scripts that performs XBL authentication via XAL
+"""
+
+import argparse
+import asyncio
+import json
+import os
+import uuid
+
+from pydantic import BaseModel
+from pydantic.json import pydantic_encoder
+
+from pythonxbox.authentication.models import (
+    SisuAuthorizationResponse,
+    XalAppParameters,
+    XalClientParameters,
+)
+from pythonxbox.authentication.xal import (
+    APP_PARAMS_GAMEPASS_BETA,
+    CLIENT_PARAMS_ANDROID,
+    XALManager,
+)
+from pythonxbox.common.signed_session import SignedSession
+from pythonxbox.scripts import XAL_TOKENS_FILE
+
+
+class XALStore(BaseModel):
+    """Used to store/load authorization data"""
+
+    sisu: SisuAuthorizationResponse
+    device_id: uuid.UUID
+    app_params: XalAppParameters
+    client_params: XalClientParameters
+
+
+def user_prompt_authentication(auth_url: str) -> str:
+    """
+    Handles the auth callback when user is prompted to authenticate via URL
+    in webbrowser
+
+    Takes the redirect URL from stdin
+    """
+
+    redirect_url = input(
+        f"Continue auth with the following URL:\n\n"
+        f"URL: {auth_url}\n\n"
+        f"Provide redirect URI: "
+    )
+    return redirect_url
+
+
+async def do_auth(device_id: uuid.UUID, token_filepath: str) -> None:
+    async with SignedSession() as session:
+        app_params = APP_PARAMS_GAMEPASS_BETA
+        client_params = CLIENT_PARAMS_ANDROID
+
+        store = None
+        # Load existing sisu authorization data, if it exists
+        if os.path.exists(token_filepath):
+            with open(token_filepath) as f:
+                store = json.load(f)
+
+            # Convert SISU authorization data
+            store = XALStore(**store)
+
+        if store:
+            raise NotImplementedError("Token refreshing")
+
+        # Do authentication
+        xal = XALManager(session, device_id, app_params, client_params)
+        response = await xal.auth_flow(user_prompt_authentication)
+        print(f"Sisu auth finished:\n\n{response}")
+
+        # Save authorization data
+        store = XALStore(
+            sisu=response,
+            device_id=device_id,
+            app_params=app_params,
+            client_params=client_params,
+        )
+
+        with open(token_filepath, mode="w") as f:
+            print(f"Finished authentication, writing tokens to {token_filepath}")
+            json.dump(store, f, default=pydantic_encoder)
+
+
+async def async_main() -> None:
+    parser = argparse.ArgumentParser(description="Authenticate with XBL via XAL")
+    parser.add_argument(
+        "--tokens",
+        "-t",
+        default=XAL_TOKENS_FILE,
+        help=f"Token filepath. Default: '{XAL_TOKENS_FILE}'",
+    )
+    parser.add_argument(
+        "--device-id",
+        "-did",
+        default=uuid.uuid4(),
+        type=uuid.UUID,
+        help="Device ID (for device auth)",
+    )
+    args = parser.parse_args()
+
+    await do_auth(args.device_id, args.tokens)
+
+
+def main() -> None:
+    asyncio.run(async_main())
+
+
+if __name__ == "__main__":
+    main()