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

mc5_api_client/pc_storage_quick.py

@@ -0,0 +1,234 @@
+# ────────────[ CHIZOBA ]────────────────────────────
+# | Email    : chizoba2026@hotmail.com
+# | File     : pc_storage_quick.py
+# | License  : MIT License © 2026 Chizoba
+# | Brief    | Quick functions for PC storage admin
+# ────────────────★─────────────────────────────────
+
+"""
+Quick functions for PC Storage Admin operations.
+Provides simple one-liner functions for common storage admin tasks.
+"""
+
+from typing import Optional, Dict, Any, List
+from .pc_storage_client import PCStorageClient
+
+
+def quick_get_squad_storage_info(squad_id: str) -> Optional[Dict[str, Any]]:
+    """
+    Quick function to get squad storage information.
+    
+    Args:
+        squad_id: Squad ID to retrieve
+        
+    Returns:
+        Squad storage information or None if failed
+    """
+    try:
+        client = PCStorageClient()
+        client.authenticate()
+        return client.get_squad_storage_info(squad_id)
+    except Exception:
+        return None
+
+
+def quick_update_squad_storage(
+    squad_id: str,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    rating: Optional[int] = None,
+    member_limit: Optional[int] = None,
+    privacy: Optional[str] = None
+) -> bool:
+    """
+    Quick function to update squad storage information.
+    
+    Args:
+        squad_id: Squad ID to update
+        name: New squad name
+        description: New squad description
+        rating: New squad rating
+        member_limit: New member limit
+        privacy: Privacy settings
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        client = PCStorageClient()
+        client.authenticate()
+        result = client.update_squad_storage(
+            squad_id=squad_id,
+            name=name,
+            description=description,
+            rating=rating,
+            member_limit=member_limit,
+            privacy=privacy
+        )
+        return True
+    except Exception:
+        return False
+
+
+def quick_delete_squad(squad_id: str) -> bool:
+    """
+    Quick function to delete a squad (requires storage_admin scope).
+    
+    Args:
+        squad_id: Squad ID to delete
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        client = PCStorageClient()
+        client.authenticate()
+        result = client.delete_squad(squad_id)
+        return True
+    except Exception:
+        return False
+
+
+def quick_get_all_squads(limit: int = 50) -> Optional[List[Dict[str, Any]]]:
+    """
+    Quick function to get all squads.
+    
+    Args:
+        limit: Number of squads to retrieve
+        
+    Returns:
+        List of squads or None if failed
+    """
+    try:
+        client = PCStorageClient()
+        client.authenticate()
+        result = client.get_all_squads(limit=limit)
+        return result.get('squads', []) if isinstance(result, dict) else result
+    except Exception:
+        return None
+
+
+def quick_batch_delete_squads(squad_ids: List[str]) -> Dict[str, Any]:
+    """
+    Quick function to delete multiple squads.
+    
+    Args:
+        squad_ids: List of squad IDs to delete
+        
+    Returns:
+        Batch deletion results
+    """
+    try:
+        client = PCStorageClient()
+        client.authenticate()
+        return client.batch_delete_squads(squad_ids)
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def quick_transfer_squad_ownership(
+    squad_id: str,
+    new_owner_credential: str
+) -> bool:
+    """
+    Quick function to transfer squad ownership.
+    
+    Args:
+        squad_id: Squad ID to transfer
+        new_owner_credential: New owner's credential
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        client = PCStorageClient()
+        client.authenticate()
+        result = client.transfer_squad_ownership(squad_id, new_owner_credential)
+        return True
+    except Exception:
+        return False
+
+
+def quick_get_squad_audit_log(squad_id: str, limit: int = 20) -> Optional[List[Dict[str, Any]]]:
+    """
+    Quick function to get squad audit log.
+    
+    Args:
+        squad_id: Squad ID to get audit log for
+        limit: Number of audit entries to retrieve
+        
+    Returns:
+        Audit log entries or None if failed
+    """
+    try:
+        client = PCStorageClient()
+        client.authenticate()
+        result = client.get_squad_audit_log(squad_id, limit=limit)
+        return result.get('entries', []) if isinstance(result, dict) else result
+    except Exception:
+        return None
+
+
+def quick_squad_management_report(squad_id: str) -> Optional[Dict[str, Any]]:
+    """
+    Quick function to generate comprehensive squad management report.
+    
+    Args:
+        squad_id: Squad ID to analyze
+        
+    Returns:
+        Comprehensive squad report or None if failed
+    """
+    try:
+        client = PCStorageClient()
+        client.authenticate()
+        return client.quick_squad_management_report(squad_id)
+    except Exception:
+        return None
+
+
+def quick_check_storage_capabilities() -> Optional[Dict[str, Any]]:
+    """
+    Quick function to check current storage capabilities.
+    
+    Returns:
+        Storage capabilities information or None if failed
+    """
+    try:
+        client = PCStorageClient()
+        client.authenticate()
+        return client.get_storage_info()
+    except Exception:
+        return None
+
+
+def quick_analyze_squad(squad_id: str) -> Optional[Dict[str, Any]]:
+    """
+    Quick function to analyze squad with all available storage data.
+    
+    Args:
+        squad_id: Squad ID to analyze
+        
+    Returns:
+        Squad analysis results or None if failed
+    """
+    try:
+        client = PCStorageClient()
+        client.authenticate()
+        
+        # Get comprehensive squad data
+        squad_info = client.get_squad_storage_info(squad_id)
+        audit_log = client.get_squad_audit_log(squad_id, limit=10)
+        
+        return {
+            "squad_id": squad_id,
+            "squad_info": squad_info,
+            "audit_log": audit_log,
+            "analysis": {
+                "has_data": bool(squad_info),
+                "has_audit_log": bool(audit_log),
+                "available_actions": client._get_available_actions(squad_id)
+            }
+        }
+    except Exception:
+        return None

mc5_api_client/platform.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# ────────────[ CHIZOBA ]────────────────────────────
+# | Email    : chizoba2026@hotmail.com
+# | File     : platform.py
+# | License  : MIT License  2026 Chizoba
+# | Brief    : Platform support for MC5 API Client (PC & Android)
+# ────────────────★─────────────────────────────────
+
+from enum import Enum
+from typing import Dict, Any, Optional
+import random
+import string
+
+class Platform(Enum):
+    """Supported platforms for MC5 API."""
+    PC = "pc"
+    ANDROID = "android"
+
+class PlatformConfig:
+    """Configuration for different platforms."""
+    
+    def __init__(self, platform: Platform):
+        self.platform = platform
+        self._config = self._get_platform_config()
+    
+    def _get_platform_config(self) -> Dict[str, Any]:
+        """Get platform-specific configuration."""
+        configs = {
+            Platform.PC: {
+                "client_id": "1924:56128:6.0.6a:pc:steam",
+                "device_model": "Windows PC",
+                "device_resolution": "1920x1080",
+                "device_country": "US",
+                "device_language": "en",
+                "user_agent": "MC5-PC-Client/1.0.16",
+                "platform_id": "pc"
+            },
+            Platform.ANDROID: {
+                "client_id": "1924:56128:6.0.6a:android:googleplay",
+                "device_model": "SM-S931B",  # Samsung Galaxy S23 Ultra
+                "device_resolution": "2340x1080",
+                "device_country": "FR",
+                "device_language": "en",
+                "user_agent": "MC5-Android-Client/1.0.16",
+                "platform_id": "android"
+            }
+        }
+        return configs.get(self.platform, configs[Platform.PC])
+    
+    def get_client_id(self) -> str:
+        """Get platform-specific client ID."""
+        return self._config["client_id"]
+    
+    def get_device_info(self) -> Dict[str, str]:
+        """Get platform-specific device information."""
+        return {
+            "device_model": self._config["device_model"],
+            "device_resolution": self._config["device_resolution"],
+            "device_country": self._config["device_country"],
+            "device_language": self._config["device_language"]
+        }
+    
+    def get_user_agent(self) -> str:
+        """Get platform-specific user agent."""
+        return self._config["user_agent"]
+    
+    def get_platform_id(self) -> str:
+        """Get platform identifier."""
+        return self._config["platform_id"]
+    
+    def generate_device_id(self) -> str:
+        """Generate a platform-appropriate device ID."""
+        if self.platform == Platform.PC:
+            # PC: Generate a 16-digit numeric device ID
+            return ''.join(random.choices(string.digits, k=16))
+        else:
+            # Android: Generate a longer device ID (like Android device IDs)
+            return ''.join(random.choices(string.digits, k=19))
+    
+    def generate_android_credential(self) -> str:
+        """Generate Android-specific anonymous credential."""
+        # Android anonymous credential format: android_v2_ANMP.GloftM5HM_<encoded_data>
+        base_data = f"android_v2_ANMP.GloftM5HM_{random.randint(1000000000, 9999999999)}"
+        # Simple encoding simulation (in real implementation, this would be proper base64)
+        encoded = base_data.replace("ANMP", "QU5NUA==").replace("GloftM5HM", "R2xvZnRNNUhN")
+        return encoded
+
+def get_platform_config(platform: Platform = Platform.PC) -> PlatformConfig:
+    """Get platform configuration."""
+    return PlatformConfig(platform)
+
+def detect_platform_from_client_id(client_id: str) -> Platform:
+    """Detect platform from client ID."""
+    if "android" in client_id.lower():
+        return Platform.ANDROID
+    elif "pc" in client_id.lower() or "steam" in client_id.lower():
+        return Platform.PC
+    else:
+        return Platform.PC  # Default to PC
+
+def get_android_anonymous_credential() -> str:
+    """Generate Android anonymous credential."""
+    config = get_platform_config(Platform.ANDROID)
+    return config.generate_android_credential()
+
+def get_pc_anonymous_credential() -> str:
+    """Generate PC anonymous credential."""
+    return f"win8_v2_{random.randint(100000000, 999999999)}_{random.choices(string.ascii_letters + string.digits, k=20)}"