mc5-api-client 1.0.17__py3-none-any.whl → 1.0.19__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.19"
 __author__ = "Chizoba"
 __email__ = "chizoba2026@hotmail.com"
 __license__ = "MIT"
@@ -87,6 +87,9 @@ from .client import MC5Client
 from .auth import TokenGenerator
 from .exceptions import MC5APIError, AuthenticationError, RateLimitError
 from .help import help, examples, quick_reference
+
+# Add MC5ApiClient as an alias for backward compatibility
+MC5ApiClient = MC5Client
 from .admin_client import (
     AdminMC5Client,
     create_admin_client,
@@ -94,11 +97,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 +283,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 +302,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
@@ -148,6 +325,7 @@ def quick_encrypt_token(
 
 __all__ = [
     "MC5Client",
+    "MC5ApiClient",
     "SimpleMC5Client",
     "AdminMC5Client",
     "batch_search_players",
@@ -216,6 +394,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.
     """
@@ -1572,31 +1573,84 @@ class MC5Client(SquadBattleMixin, FederationMixin, AlertsMixin, AccountMixin, Tr
     
     # Utility Methods
     
-    def get_token_info(self) -> Dict[str, Any]:
+    def close(self):
+        """Close the HTTP session and cleanup resources."""
+        if self.session:
+            self.session.close()
+        if self.token_generator:
+            self.token_generator.close()
+    
+    # Server Status Methods (for compatibility)
+    
+    def get_server_status(self) -> Dict[str, Any]:
         """
-        Get current token information.
+        Get server status information.
         
         Returns:
-            Token data
+            Dictionary with server status
         """
-        self._ensure_valid_token()
-        return self._token_data.copy()
+        try:
+            # Try to get events as a basic connectivity test
+            events = self.get_events()
+            return {
+                "status": "online",
+                "message": "MC5 servers are online",
+                "events_count": len(events),
+                "timestamp": time.time()
+            }
+        except Exception as e:
+            return {
+                "status": "offline",
+                "message": f"Server status check failed: {str(e)}",
+                "timestamp": time.time()
+            }
     
-    def is_authenticated(self) -> bool:
+    def get_online_players(self) -> Dict[str, Any]:
         """
-        Check if client is authenticated with valid token.
+        Get online players information (estimated).
         
         Returns:
-            True if authenticated, False otherwise
+            Dictionary with online player count
         """
-        return self._token_data is not None and self.token_generator.validate_token(self._token_data)
+        try:
+            # Get events as a proxy for activity
+            events = self.get_events()
+            # This is an estimate - actual player count isn't directly available
+            return {
+                "online_players": "Unknown",
+                "active_events": len(events),
+                "message": "Player count not directly available via API",
+                "timestamp": time.time()
+            }
+        except Exception as e:
+            return {
+                "online_players": 0,
+                "error": str(e),
+                "timestamp": time.time()
+            }
     
-    def close(self):
-        """Close the HTTP session and cleanup resources."""
-        if self.session:
-            self.session.close()
-        if self.token_generator:
-            self.token_generator.close()
+    def get_server_info(self) -> Dict[str, Any]:
+        """
+        Get general server information.
+        
+        Returns:
+            Dictionary with server information
+        """
+        try:
+            return {
+                "server": "Modern Combat 5",
+                "region": "Europe",
+                "api_version": "1.0.18",
+                "endpoints": list(self.BASE_URLS.keys()),
+                "client_id": self.client_id,
+                "authenticated": bool(self.access_token),
+                "timestamp": time.time()
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "timestamp": time.time()
+            }
     
     # Events API
     
@@ -2271,6 +2325,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.