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

mc5_api_client/simple_client.py

@@ -14,8 +14,11 @@ Provides easy-to-use methods with automatic clan detection and simplified syntax
 """
 
 from typing import Optional, Dict, Any, List
-from .client import MC5Client
+from .telemetry import telemetry, report_error, report_usage, is_telemetry_enabled
+from .debug import debug_function, debug_print, debug_request, debug_response, print_error_analysis
 from .exceptions import MC5APIError
+from .client import MC5Client
+from .platform import Platform
 
 class SimpleMC5Client:
     """
@@ -25,46 +28,74 @@ class SimpleMC5Client:
     for common operations.
     """
     
-    def __init__(self, username: str, password: str):
+    def __init__(self, username: str, password: str, platform: Platform = Platform.PC):
         """
-        Initialize the client with your MC5 credentials.
+        Initialize SimpleMC5Client.
         
         Args:
             username: Your MC5 username (e.g., "anonymous:your_credential")
             password: Your MC5 password
+            platform: Platform to use (PC or Android)
         """
         self.username = username
         self.password = password
-        self.client = None
+        self.platform = platform
+        self.client = MC5Client(platform=platform)  # Initialize the client without auto-auth
         self._clan_id = None
         self._profile = None
         
+    @debug_function
     def connect(self) -> bool:
         """
-        Connect to MC5 and auto-detect your clan.
+        Connect to MC5 API with enhanced debugging.
         
         Returns:
             True if connection successful, False otherwise
         """
         try:
-            # Create the client only when connecting
-            self.client = MC5Client(self.username, self.password)
+            # debug_print(f"🔐 Connecting to MC5 API as {self.username[:10]}...")
             
-            # Get profile info
-            self._profile = self.client.get_profile()
+            # Authenticate
+            self.client.authenticate(self.username, self.password)
+            # debug_print("✅ Authentication successful", "success")
             
-            # Auto-detect clan ID
-            groups = self._profile.get('groups', [])
-            if groups:
-                self._clan_id = groups[0]
-                print(f"✅ Connected! Auto-detected clan: {self._get_clan_name()}")
-                return True
-            else:
-                print("⚠️ Connected but no clan found")
-                return True
+            # Get profile
+            profile = self.client.get_profile()
+            if not profile:
+                debug_print("❌ Failed to get profile", "error")
+                return False
+            
+            self._profile = profile
+            # debug_print("👤 Profile loaded: " + profile.get('name', 'Unknown'), "info")
+            
+            # Auto-detect clan
+            clan_id = profile.get('_clan_id')
+            if clan_id:
+                self._clan_id = clan_id
+            # debug_print("🏰 Auto-detected clan: {clan_id}", "success")
                 
+                # Try to get clan details
+                try:
+                    clan_settings = self.client.get_clan_settings(clan_id)
+                    if clan_settings:
+                        clan_name = clan_settings.get('name', f'Clan_{clan_id[:8]}')
+                        debug_print(f"🏰 Clan name: {clan_name}", "info")
+                except:
+                    debug_print("⚠️ Could not get clan details", "warning")
+            else:
+                debug_print("ℹ️ No clan detected", "info")
+            
+            self.connected = True
+            # debug_print("🎉 Connection successful!", "success")
+            return True
+            
         except Exception as e:
-            print(f"❌ Connection failed: {e}")
+            debug_print(f"❌ Connection failed: {e}", "error")
+            print_error_analysis(e)
+            report_error(e, "SimpleMC5Client.connect", {
+                "username": self.username[:10] + "..."
+            })
+            self.connected = False
             return False
     
     def _get_clan_name(self) -> str:
@@ -474,6 +505,329 @@ class SimpleMC5Client:
         except:
             pass
     
+    def remove_friend(self, target_user_id: str, message: str = "removed", 
+                     killsig_color: str = None, killsig_name: str = None) -> bool:
+        """
+        Send a friend removal notification message.
+        
+        Args:
+            target_user_id: Target player's user ID
+            message: Message content (default: "removed")
+            killsig_color: Kill signature color (optional)
+            killsig_name: Kill signature name (optional)
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            print(f"🔵 Sending friend removal notification to {target_user_id}...")
+            result = self.client.remove_friend(target_user_id, message, killsig_color, killsig_name)
+            
+            if result and not result.get('error'):
+                print(f"✅ Friend removal notification sent to {target_user_id}")
+                return True
+            else:
+                print(f"❌ Failed to send friend removal notification: {result.get('error', 'Unknown error')}")
+                return False
+        except Exception as e:
+            print(f"❌ Error removing friend: {e}")
+            return False
+    
+    def delete_friend_connection(self, target_user_id: str) -> bool:
+        """
+        Delete a friend connection (actual removal from friends list).
+        
+        Args:
+            target_user_id: Target player's user ID
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            print(f"🔴 Deleting friend connection with {target_user_id}...")
+            result = self.client.delete_friend_connection(target_user_id)
+            
+            if result and not result.get('error'):
+                print(f"✅ Friend connection deleted: {target_user_id}")
+                return True
+            else:
+                print(f"❌ Failed to delete friend connection: {result.get('error', 'Unknown error')}")
+                return False
+        except Exception as e:
+            print(f"❌ Error deleting friend connection: {e}")
+            return False
+    
+    def send_friend_request(self, target_user_id: str, alert_kairos: bool = True) -> bool:
+        """
+        Send a friend request to another player.
+        
+        Args:
+            target_user_id: Target player's user ID
+            alert_kairos: Whether to send alert notification
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            print(f"🤝 Sending friend request to {target_user_id}...")
+            result = self.client.send_friend_request(target_user_id, alert_kairos)
+            
+            if result and not result.get('error'):
+                print(f"✅ Friend request sent to {target_user_id}")
+                return True
+            else:
+                print(f"❌ Failed to send friend request: {result.get('error', 'Unknown error')}")
+                return False
+        except Exception as e:
+            print(f"❌ Error sending friend request: {e}")
+            return False
+    
+    def get_friend_connection_status(self, target_user_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get the connection status with a specific friend.
+        
+        Args:
+            target_user_id: Target player's user ID
+            
+        Returns:
+            Connection status information or None if error
+        """
+        try:
+            print(f"🔍 Checking friend connection status with {target_user_id}...")
+            result = self.client.get_friend_connection_status(target_user_id)
+            
+            if result and not result.get('error'):
+                print(f"✅ Friend connection status retrieved")
+                return result
+            else:
+                print(f"ℹ️ No friend connection found with {target_user_id}")
+                return None
+        except Exception as e:
+            print(f"❌ Error checking friend connection status: {e}")
+            return None
+    
+    # Event Management
+    
+    def sign_up_for_event(self, event_id: str) -> bool:
+        """
+        Sign up for an event.
+        
+        Args:
+            event_id: Event ID to sign up for
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            print(f"🎯 Signing up for event: {event_id}")
+            result = self.client.sign_up_for_event(event_id)
+            
+            if result and not result.get('error'):
+                print(f"✅ Successfully signed up for event {event_id}")
+                return True
+            else:
+                print(f"❌ Failed to sign up for event: {result.get('error', 'Unknown error')}")
+                return False
+        except Exception as e:
+            print(f"❌ Error signing up for event: {e}")
+            return False
+    
+    def get_event_leaderboard(self, event_id: str, offset: int = 0, limit: int = 100) -> Optional[Dict[str, Any]]:
+        """
+        Get the leaderboard for a specific event.
+        
+        Args:
+            event_id: Event ID
+            offset: Pagination offset (default: 0)
+            limit: Number of entries to retrieve (default: 100)
+            
+        Returns:
+            Event leaderboard data or None if error
+        """
+        try:
+            print(f"🏆 Getting event leaderboard for {event_id}...")
+            result = self.client.get_event_leaderboard(event_id, offset, limit)
+            
+            if result and 'data' in result:
+                print(f"✅ Retrieved {len(result['data'])} leaderboard entries")
+                return result
+            else:
+                print(f"❌ Failed to get event leaderboard")
+                return None
+        except Exception as e:
+            print(f"❌ Error getting event leaderboard: {e}")
+            return None
+    
+    def get_my_event_leaderboard_entry(self, event_id: str, limit: int = 5) -> Optional[Dict[str, Any]]:
+        """
+        Get your entry and surrounding players in the event leaderboard.
+        
+        Args:
+            event_id: Event ID
+            limit: Number of surrounding entries to show (default: 5)
+            
+        Returns:
+            Your leaderboard entry with surrounding players or None if error
+        """
+        try:
+            print(f"🔍 Getting your event leaderboard entry for {event_id}...")
+            result = self.client.get_my_event_leaderboard_entry(event_id, limit)
+            
+            if result and 'my_entry' in result:
+                my_rank = result['my_entry'].get('rank', 'Unknown')
+                my_score = result['my_entry'].get('score', 0)
+                print(f"✅ Your rank: {my_rank}, Score: {my_score}")
+                return result
+            else:
+                print(f"❌ Failed to get your event leaderboard entry")
+                return None
+        except Exception as e:
+            print(f"❌ Error getting your event leaderboard entry: {e}")
+            return None
+    
+    # Squad/Group Management
+    
+    def get_squad_invitations(self) -> List[Dict[str, Any]]:
+        """
+        Get all pending squad invitations.
+        
+        Returns:
+            List of squad invitations or empty list if error
+        """
+        try:
+            print("📨 Getting squad invitations...")
+            invitations = self.client.get_squad_invitations()
+            
+            if invitations:
+                print(f"✅ Found {len(invitations)} squad invitation(s)")
+                for i, invite in enumerate(invitations, 1):
+                    squad_name = invite.get('group', {}).get('name', 'Unknown Squad')
+                    requester = invite.get('requester', {}).get('name', 'Unknown Player')
+                    print(f"   {i}. {squad_name} from {requester}")
+            else:
+                print("ℹ️ No squad invitations found")
+            
+            return invitations
+        except Exception as e:
+            print(f"❌ Error getting squad invitations: {e}")
+            return []
+    
+    def accept_squad_invitation(self, invitation: Dict[str, Any]) -> bool:
+        """
+        Accept a squad invitation.
+        
+        Args:
+            invitation: Squad invitation dictionary from get_squad_invitations()
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            group_id = invitation.get('group_id')
+            message_id = invitation.get('id')
+            squad_name = invitation.get('group', {}).get('name', 'Unknown Squad')
+            requester = invitation.get('requester', {}).get('name', 'Unknown Player')
+            
+            if not group_id or not message_id:
+                print("❌ Invalid invitation data")
+                return False
+            
+            print(f"🎯 Accepting squad invitation: {squad_name} from {requester}")
+            
+            # Get your profile data for optional parameters
+            profile = self.client.get_profile()
+            credential = profile.get('credential', '')
+            
+            # Accept the invitation
+            result = self.client.accept_squad_invitation(
+                group_id=group_id,
+                credential=credential,
+                killsig_color=profile.get('_killsig_color'),
+                killsig_id=profile.get('_killsig_id'),
+                score=profile.get('_score'),
+                xp=profile.get('_xp')
+            )
+            
+            if result:
+                print(f"✅ Successfully joined squad: {squad_name}")
+                
+                # Delete the invitation message
+                print("🗑️ Cleaning up invitation message...")
+                self.client.delete_squad_invitation_message(message_id)
+                print("✅ Invitation message deleted")
+                
+                return True
+            else:
+                print(f"❌ Failed to join squad: {squad_name}")
+                return False
+        except Exception as e:
+            print(f"❌ Error accepting squad invitation: {e}")
+            return False
+    
+    def decline_squad_invitation(self, invitation: Dict[str, Any]) -> bool:
+        """
+        Decline a squad invitation.
+        
+        Args:
+            invitation: Squad invitation dictionary from get_squad_invitations()
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            message_id = invitation.get('id')
+            squad_name = invitation.get('group', {}).get('name', 'Unknown Squad')
+            requester = invitation.get('requester', {}).get('name', 'Unknown Player')
+            
+            if not message_id:
+                print("❌ Invalid invitation data")
+                return False
+            
+            print(f"🚫 Declining squad invitation: {squad_name} from {requester}")
+            
+            # Decline the invitation (just delete the message)
+            result = self.client.decline_squad_invitation(message_id)
+            
+            if result:
+                print(f"✅ Successfully declined squad invitation: {squad_name}")
+                return True
+            else:
+                print(f"❌ Failed to decline squad invitation: {squad_name}")
+                return False
+        except Exception as e:
+            print(f"❌ Error declining squad invitation: {e}")
+            return False
+    
+    def accept_friend_request(self, request_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Accept an incoming friend request.
+        
+        Args:
+            request_id: Friend request ID to accept
+            
+        Returns:
+            Connection details or None if error
+        """
+        try:
+            print(f"🤝 Accepting friend request: {request_id}")
+            result = self.client.accept_friend_request(request_id)
+            
+            if result and 'requester' in result:
+                requester_name = result['requester'].get('name', 'Unknown')
+                print(f"✅ Successfully accepted friend request from {requester_name}")
+                
+                # Show connection details
+                connection_type = result.get('connection_type', 'Unknown')
+                print(f"   Connection type: {connection_type}")
+                
+                return result
+            else:
+                print("❌ Failed to accept friend request")
+                return None
+        except Exception as e:
+            print(f"❌ Error accepting friend request: {e}")
+            return None
+    
     def __enter__(self):
         """Context manager entry."""
         return self
@@ -553,6 +907,196 @@ def batch_search_players(dogtags: List[str], username: str, password: str) -> Di
     return results
 
 
+def quick_remove_friend(target_user_id: str, username: str, password: str, 
+                       message: str = "removed") -> bool:
+    """
+    Quick remove a friend (send notification and delete connection).
+    
+    Args:
+        target_user_id: Target player's user ID
+        username: Your MC5 username
+        password: Your MC5 password
+        message: Message content (default: "removed")
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            # Send notification first
+            notification_sent = client.remove_friend(target_user_id, message)
+            # Then delete connection
+            connection_deleted = client.delete_friend_connection(target_user_id)
+            return notification_sent and connection_deleted
+    return False
+
+
+def quick_send_friend_request(target_user_id: str, username: str, password: str) -> bool:
+    """
+    Quick send a friend request.
+    
+    Args:
+        target_user_id: Target player's user ID
+        username: Your MC5 username
+        password: Your MC5 password
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            return client.send_friend_request(target_user_id)
+    return False
+
+
+def quick_check_friend_status(target_user_id: str, username: str, password: str) -> Optional[Dict[str, Any]]:
+    """
+    Quick check friend connection status.
+    
+    Args:
+        target_user_id: Target player's user ID
+        username: Your MC5 username
+        password: Your MC5 password
+        
+    Returns:
+        Connection status information or None if not found
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            return client.get_friend_connection_status(target_user_id)
+    return None
+
+
+def quick_sign_up_for_event(event_id: str, username: str, password: str) -> bool:
+    """
+    Quick sign up for an event.
+    
+    Args:
+        event_id: Event ID to sign up for
+        username: Your MC5 username
+        password: Your MC5 password
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            return client.sign_up_for_event(event_id)
+    return False
+
+
+def quick_get_event_leaderboard(event_id: str, username: str, password: str, 
+                               offset: int = 0, limit: int = 100) -> Optional[Dict[str, Any]]:
+    """
+    Quick get event leaderboard.
+    
+    Args:
+        event_id: Event ID
+        username: Your MC5 username
+        password: Your MC5 password
+        offset: Pagination offset (default: 0)
+        limit: Number of entries to retrieve (default: 100)
+        
+    Returns:
+        Event leaderboard data or None if error
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            return client.get_event_leaderboard(event_id, offset, limit)
+    return None
+
+
+def quick_get_my_event_rank(event_id: str, username: str, password: str, 
+                          limit: int = 5) -> Optional[Dict[str, Any]]:
+    """
+    Quick get your event leaderboard entry and rank.
+    
+    Args:
+        event_id: Event ID
+        username: Your MC5 username
+        password: Your MC5 password
+        limit: Number of surrounding entries to show (default: 5)
+        
+    Returns:
+        Your leaderboard entry with surrounding players or None if error
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            return client.get_my_event_leaderboard_entry(event_id, limit)
+    return None
+
+
+def quick_get_squad_invitations(username: str, password: str) -> List[Dict[str, Any]]:
+    """
+    Quick get squad invitations.
+    
+    Args:
+        username: Your MC5 username
+        password: Your MC5 password
+        
+    Returns:
+        List of squad invitations or empty list if error
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            return client.get_squad_invitations()
+    return []
+
+
+def quick_accept_squad_invitation(invitation: Dict[str, Any], username: str, password: str) -> bool:
+    """
+    Quick accept a squad invitation.
+    
+    Args:
+        invitation: Squad invitation dictionary from quick_get_squad_invitations()
+        username: Your MC5 username
+        password: Your MC5 password
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            return client.accept_squad_invitation(invitation)
+    return False
+
+
+def quick_decline_squad_invitation(invitation: Dict[str, Any], username: str, password: str) -> bool:
+    """
+    Quick decline a squad invitation.
+    
+    Args:
+        invitation: Squad invitation dictionary from quick_get_squad_invitations()
+        username: Your MC5 username
+        password: Your MC5 password
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            return client.decline_squad_invitation(invitation)
+    return False
+
+
+def quick_accept_friend_request(request_id: str, username: str, password: str) -> Optional[Dict[str, Any]]:
+    """
+    Quick accept a friend request.
+    
+    Args:
+        request_id: Friend request ID to accept
+        username: Your MC5 username
+        password: Your MC5 password
+        
+    Returns:
+        Connection details or None if error
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            return client.accept_friend_request(request_id)
+    return None
+
+
 def clan_cleanup(username: str, password: str, 
                  inactive_days: int = 30,
                  min_level: int = 10,