mc5-api-client 1.0.17__py3-none-any.whl → 1.0.18__py3-none-any.whl

mc5_api_client/__init__.py

@@ -15,7 +15,7 @@ messaging, and more.
 
 from typing import Optional, Dict, Any
 
-__version__ = "1.0.16"
+__version__ = "1.0.18"
 __author__ = "Chizoba"
 __email__ = "chizoba2026@hotmail.com"
 __license__ = "MIT"
@@ -94,11 +94,185 @@ from .admin_client import (
     quick_add_squad_rating,
     quick_update_player_score
 )
+from .pc_storage_client import PCStorageClient
+from .storage_admin import StorageAdminMixin
+from .easy_mc5 import MC5Easy
 
 # Encrypted token convenience functions
 from .auth import TokenGenerator
 
-def quick_generate_encrypted_token(
+# Convenience functions for global ID operations
+def get_global_id(device_id: str = None, device_type: str = "w10", hdidfv: str = None) -> str:
+    """
+    Get a global device ID from Gameloft's global ID service.
+    
+    Args:
+        device_id: Your device ID (optional, will generate one if not provided)
+        device_type: Device type (w10, android, ios, etc.)
+        hdidfv: Hardware ID fingerprint (optional)
+        
+    Returns:
+        Global device ID string
+    """
+    import requests
+    
+    # Build request parameters
+    params = {
+        "source": "Identifiers_6.0.0",
+        "client_id": "1875:55979:6.0.0a:windows:windows",
+        "device_type": device_type,
+        "global_device_id": device_id or "1364509832654538259",
+        "hdidfv": hdidfv or "76dfc72e-7850-4d9e-b79c-9861c7e3ea20"
+    }
+    
+    headers = {
+        "Accept": "*/*",
+        "Accept-Encoding": "gzip;q=1.0, deflate;q=1.0, identity;q=0.5, *;q=0"
+    }
+    
+    try:
+        response = requests.get(
+            "https://gdid.datalake.gameloft.com/assign_global_id/",
+            params=params,
+            headers=headers,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            return response.text.strip()
+        else:
+            return ""
+    except Exception:
+        return ""
+
+def generate_device_id() -> str:
+    """
+    Generate a unique device ID for the current device.
+    
+    Returns:
+        Generated device ID string
+    """
+    import uuid
+    
+    # Generate a unique device ID
+    device_id = f"mc5_{uuid.uuid4().hex[:16]}"
+    return device_id
+
+def create_federation_session(username: str = None, password: str = None, device_id: str = None) -> Dict[str, Any]:
+    """
+    Create a federation session for MC5 game launch.
+    
+    Args:
+        username: MC5 username (can use MC5_USERNAME env var)
+        password: MC5 password (can use MC5_PASSWORD env var)
+        device_id: Device ID for the session (optional)
+        
+    Returns:
+        Dictionary with session information
+    """
+    import os
+    import requests
+    
+    # Use environment variables if not provided
+    username = username or os.getenv('MC5_USERNAME')
+    password = password or os.getenv('MC5_PASSWORD')
+    
+    if not username or not password:
+        return {"error": "Username and password are required"}
+    
+    try:
+        # Build request parameters
+        params = {
+            "password": password,
+            "device_id": device_id or "1364509832654538259"
+        }
+        
+        headers = {
+            "Accept": "*/*",
+            "Content-Type": "application/x-www-form-urlencoded"
+        }
+        
+        # Build URL with encoded credential
+        encoded_credential = username.replace(":", "%3A")
+        url = f"https://federation-eur.gameloft.com/sessions/1875%3A55979%3A6.0.0a%3Awindows%3Awindows/{encoded_credential}"
+        
+        # Make request
+        response = requests.post(
+            url,
+            data=params,
+            headers=headers,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            return response.json()
+        else:
+            return {"error": f"HTTP {response.status_code}", "response": response.text}
+    
+    except Exception as e:
+        return {"error": str(e)}
+
+def locate_service(service: str) -> str:
+    """
+    Locate a service endpoint for MC5.
+    
+    Args:
+        service: Service name (leaderboard, matchmaker, auth, social, alert, message, lobby, gs, sp)
+        
+    Returns:
+        Service endpoint URL or empty string if not found
+    """
+    import requests
+    
+    try:
+        # Build request parameters
+        params = {
+            "service": service,
+            "client_id": "1875:55979:6.0.0a:windows:windows"
+        }
+        
+        headers = {
+            "Accept": "*/*"
+        }
+        
+        # Make request
+        response = requests.get(
+            "https://vgold-eur.gameloft.com/1875:55979:6.0.0a:windows:windows/locate",
+            params=params,
+            headers=headers,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            return response.text.strip()
+        else:
+            return ""
+    
+    except Exception:
+        return ""
+
+def get_all_services() -> Dict[str, str]:
+    """
+    Get all available service endpoints.
+    
+    Returns:
+        Dictionary mapping service names to endpoints
+    """
+    services = [
+        "leaderboard", "matchmaker", "auth", "social", 
+        "alert", "message", "lobby", "gs", "sp"
+    ]
+    
+    service_endpoints = {}
+    
+    for service in services:
+        endpoint = locate_service(service)
+        if endpoint:
+            service_endpoints[service] = endpoint
+    
+    return service_endpoints
+
+def generate_encrypted_token(
     username: str,
     password: str,
     device_id: Optional[str] = None,
@@ -106,7 +280,7 @@ def quick_generate_encrypted_token(
     nonce: str = "*"
 ) -> Dict[str, Any]:
     """
-    Quick function to generate and encrypt an access token.
+    Generate and encrypt an access token.
     
     Args:
         username: MC5 username
@@ -125,12 +299,12 @@ def quick_generate_encrypted_token(
     finally:
         token_gen.close()
 
-def quick_encrypt_token(
+def encrypt_token(
     access_token: str,
     nonce: str = "*"
 ) -> str:
     """
-    Quick function to encrypt an existing access token.
+    Encrypt an existing access token.
     
     Args:
         access_token: Raw access token string
@@ -216,6 +390,16 @@ __all__ = [
     "help",
     "examples",
     "quick_reference",
-    "quick_generate_encrypted_token",
-    "quick_encrypt_token"
+    "generate_encrypted_token",
+    "encrypt_token",
+    "MC5Easy",
+    "quick_connect",
+    "check_my_daily_tasks",
+    "get_my_mc5_profile",
+    "find_mc5_player",
+    "get_global_id",
+    "generate_device_id",
+    "create_federation_session",
+    "locate_service",
+    "get_all_services"
 ]

mc5_api_client/client.py

@@ -27,6 +27,7 @@ from .alerts import AlertsMixin
 from .account import AccountMixin
 from .transfer import TransferMixin
 from .platform import Platform, get_platform_config, detect_platform_from_client_id
+from .storage_admin import StorageAdminMixin
 from .exceptions import (
     MC5APIError,
     AuthenticationError,
@@ -37,7 +38,7 @@ from .exceptions import (
 )
 
 
-class MC5Client(SquadBattleMixin, FederationMixin, AlertsMixin, AccountMixin, TransferMixin):
+class MC5Client(SquadBattleMixin, FederationMixin, AlertsMixin, AccountMixin, TransferMixin, StorageAdminMixin):
     """
     Comprehensive MC5 API client with support for all major endpoints.
     """
@@ -2271,6 +2272,28 @@ class MC5Client(SquadBattleMixin, FederationMixin, AlertsMixin, AccountMixin, Tr
         response = self._make_request("GET", url, params=params)
         return response if isinstance(response, list) else []
     
+    def get_squad_members(self, squad_id: str, offset: int = 0, limit: int = 100) -> Dict[str, Any]:
+        """
+        Get squad members list.
+        
+        Args:
+            squad_id: Squad ID
+            offset: Offset for pagination
+            limit: Number of members to retrieve
+            
+        Returns:
+            Squad members list
+        """
+        url = f"{self.BASE_URLS['osiris']}/groups/{squad_id}/members"
+        params = {
+            "access_token": self._token_data['access_token'],
+            "group_id": squad_id,
+            "offset": str(offset),
+            "limit": str(limit)
+        }
+        
+        return self._make_request("GET", url, params=params)
+    
     def get_clan_info(self, clan_id: str) -> Dict[str, Any]:
         """
         Get detailed information about a clan.