mc5-api-client 1.0.5__py3-none-any.whl → 1.0.8__py3-none-any.whl

mc5_api_client/__init__.py

@@ -13,17 +13,35 @@ Provides easy access to authentication, profile management, clan operations,
 messaging, and more.
 """
 
-__version__ = "1.0.0"
+__version__ = "1.0.8"
 __author__ = "Chizoba"
 __email__ = "chizoba2026@hotmail.com"
 __license__ = "MIT"
 
+from .simple_client import (
+    SimpleMC5Client,
+    batch_search_players,
+    clan_cleanup,
+    monitor_clan_activity,
+    quick_search,
+    quick_kick,
+    get_inactive_members,
+    auto_kick_inactive_members
+)
 from .client import MC5Client
 from .auth import TokenGenerator
 from .exceptions import MC5APIError, AuthenticationError, RateLimitError
 
 __all__ = [
     "MC5Client",
+    "SimpleMC5Client",
+    "batch_search_players",
+    "clan_cleanup",
+    "monitor_clan_activity",
+    "quick_search",
+    "quick_kick",
+    "get_inactive_members",
+    "auto_kick_inactive_members",
     "TokenGenerator", 
     "MC5APIError",
     "AuthenticationError",

mc5_api_client/client.py

@@ -1150,16 +1150,20 @@ class MC5Client:
     
     def get_alias_info(self, alias_id: str) -> Dict[str, Any]:
         """
-        Get alias information.
+        Retrieve player information using alias/dogtag.
         
         Args:
-            alias_id: Player alias ID
+            alias_id: Alias or dogtag identifier
             
         Returns:
-            Alias information
+            Player information including credential and account ID
         """
-        url = f"{self.BASE_URLS['auth']}/games/mygame/alias/{alias_id}"
-        return self._make_request("GET", url)
+        url = f"{self.BASE_URLS['janus']}/games/mygame/alias/{alias_id}"
+        params = {
+            "access_token": self._token_data["access_token"]
+        }
+        
+        return self._make_request("GET", url, params=params)
     
     def convert_dogtag_to_alias(self, dogtag: str) -> str:
         """
@@ -1564,63 +1568,48 @@ class MC5Client:
     
     # Alias/Dogtags System
     
+    # Dogtag conversion mappings
+    DOGTAG_SWAP = {
+        '0': '8', '1': '9', '2': '0', '3': '1', '4': '2', '5': '3', 
+        '6': '4', '7': '5', '8': '6', '9': '7',
+        'a': 'y', 'b': 'z', 'c': 'a', 'd': 'b', 'e': 'c', 'f': 'd',
+        'g': 'e', 'h': 'f', 'i': 'g', 'j': 'h', 'k': 'i', 'l': 'j',
+        'm': 'k', 'n': 'l', 'o': 'm', 'p': 'n', 'q': 'o', 'r': 'p',
+        's': 'q', 't': 'r', 'u': 's', 'v': 't', 'w': 'u', 'x': 'v',
+        'y': 'w', 'z': 'x'
+    }
+    
+    REVERSE_DOGTAG_SWAP = {v: k for k, v in DOGTAG_SWAP.items()}
+    
     def convert_dogtag_to_alias(self, dogtag: str) -> str:
         """
-        Convert a dogtag (player ID) to alias format.
+        Convert a dogtag (player ID) to alias format using the correct MC5 mapping.
         
         Args:
-            dogtag: Dogtag in XXXX format (hexadecimal)
+            dogtag: Dogtag in XXXX format (hexadecimal), can be 4-8 characters
             
         Returns:
             Alias string
         """
-        if not dogtag or len(dogtag) != 4:
+        if not dogtag or len(dogtag) < 4 or len(dogtag) > 8:
             return dogtag
         
-        alias = ""
-        for char in dogtag.lower():
-            if char.isdigit():
-                # Digit: subtract 2 using modulo 10 arithmetic
-                digit = int(char)
-                new_digit = (digit - 2) % 10
-                alias += str(new_digit)
-            elif char.isalpha():
-                # Letter: subtract 2 from ASCII value
-                new_char = chr(ord(char) - 2)
-                alias += new_char
-            else:
-                alias += char
-        
-        return alias
+        return ''.join(self.DOGTAG_SWAP.get(c, c) for c in dogtag.lower())
     
     def convert_alias_to_dogtag(self, alias: str) -> str:
         """
-        Convert an alias back to dogtag format.
+        Convert an alias back to dogtag format using the correct MC5 mapping.
         
         Args:
             alias: Alias string
             
         Returns:
-            Dogtag in XXXX format
+            Dogtag in XXXX format (hexadecimal)
         """
-        if not alias or len(alias) != 4:
+        if not alias:
             return alias
         
-        dogtag = ""
-        for char in alias.lower():
-            if char.isdigit():
-                # Digit: add 2 using modulo 10 arithmetic
-                digit = int(char)
-                new_digit = (digit + 2) % 10
-                dogtag += str(new_digit)
-            elif char.isalpha():
-                # Letter: add 2 to ASCII value
-                new_char = chr(ord(char) + 2)
-                dogtag += new_char
-            else:
-                dogtag += char
-        
-        return dogtag
+        return ''.join(self.REVERSE_DOGTAG_SWAP.get(c, c) for c in alias.lower())
     
     def get_alias_info(self, alias_id: str) -> Dict[str, Any]:
         """
@@ -1632,10 +1621,6 @@ class MC5Client:
         Returns:
             Player account information
         """
-        # Convert to alias if it's a dogtag
-        if len(alias_id) == 4 and all(c in '0123456789abcdefABCDEF' for c in alias_id):
-            alias_id = self.convert_dogtag_to_alias(alias_id)
-        
         url = f"{self.BASE_URLS['janus']}/games/mygame/alias/{alias_id}"
         return self._make_request("GET", url)
     
@@ -1673,15 +1658,21 @@ class MC5Client:
         Returns:
             List of game objects with detailed information
         """
-        # This would typically use a dynamic URL with timestamp
-        # For now, using a placeholder URL
+        # Use timestamp-based URL for dynamic content
         import time
-        url = f"https://iris16-gold.gameloft.com/game_object_{int(time.time())}"
+        timestamp = int(time.time())
+        url = f"https://iris16-gold.gameloft.com/1875/game_object_{timestamp}"
+        
         try:
             return self._make_request("GET", url)
         except:
-            # Fallback to basic catalog if dynamic URL fails
-            return []
+            # Fallback to static URL if dynamic fails
+            fallback_url = "https://iris16-gold.gameloft.com/1875/game_object_1747885487.1257186"
+            try:
+                return self._make_request("GET", fallback_url)
+            except:
+                # Return empty catalog if both fail
+                return []
     
     def get_service_urls(self) -> Dict[str, str]:
         """
@@ -1759,12 +1750,27 @@ class MC5Client:
         
         return self._make_request("POST", url, data=data, headers=headers)
     
+    def get_complete_player_stats(self, credentials: List[str]) -> Dict[str, Any]:
+        """
+        Get complete player statistics with all available fields.
+        
+        Args:
+            credentials: List of player credentials to fetch
+            
+        Returns:
+            Dictionary with complete player profiles
+        """
+        # Try to get all possible fields
+        all_fields = ['_game_save', 'inventory', 'statistics', 'profile', 'achievements']
+        return self.get_batch_profiles(credentials, all_fields)
+    
     def get_player_stats_by_dogtag(self, dogtag: str) -> Dict[str, Any]:
         """
         Get detailed player statistics using their dogtag (in-game ID).
+        Follows the exact API flow: dogtag → alias → janus lookup → batch profiles.
         
         Args:
-            dogtag: Player's dogtag in XXXX format (hexadecimal)
+            dogtag: Player's dogtag in XXXX format (hexadecimal), can be 4-8 characters
             
         Returns:
             Player statistics and profile information
@@ -1772,42 +1778,300 @@ class MC5Client:
         # Convert dogtag to alias for API lookup
         alias = self.convert_dogtag_to_alias(dogtag)
         
-        # Get player info using alias
-        player_info = self.get_alias_info(alias)
-        if not player_info.get('credential'):
-            return {'error': f'Player not found for dogtag: {dogtag}', 'alias': alias}
-        
-        # Get detailed stats using the credential
+        # Get player info using alias from janus endpoint
         try:
-            stats = self.get_batch_profiles([player_info['credential']])
+            player_info = self.get_alias_info(alias)
+            if not player_info.get('credential'):
+                return {
+                    'error': f'Player not found for dogtag: {dogtag}', 
+                    'dogtag': dogtag,
+                    'alias': alias,
+                    'janus_response': player_info
+                }
+        
+            # Get detailed stats using the credential from batch profiles endpoint
+            try:
+                stats = self.get_batch_profiles([player_info['credential']])
+                
+                # Add dogtag and alias info to the response
+                if player_info['credential'] in stats:
+                    stats[player_info['credential']]['dogtag'] = dogtag
+                    stats[player_info['credential']]['alias'] = alias
+                    stats[player_info['credential']]['player_info'] = player_info
+                    stats[player_info['credential']]['janus_response'] = player_info
+                
+                return stats
+                
+            except Exception as e:
+                return {
+                    'error': f'Failed to get stats for dogtag {dogtag}: {e}',
+                    'dogtag': dogtag,
+                    'alias': alias,
+                    'player_info': player_info,
+                    'janus_response': player_info
+                }
+        except Exception as e:
+            return {
+                'error': f'Failed to lookup alias {alias} for dogtag {dogtag}: {e}',
+                'dogtag': dogtag,
+                'alias': alias
+            }
+    
+    # Clan Management & Profile Operations
+    
+    def get_profile(self) -> Dict[str, Any]:
+        """
+        Retrieve player profile details including name, groups, and last time played.
+        
+        Returns:
+            Player profile information
+        """
+        url = f"{self.BASE_URLS['osiris']}/accounts/me"
+        params = {
+            "access_token": self._token_data["access_token"]
+        }
+        
+        return self._make_request("GET", url, params=params)
+    
+    def update_profile(self, name: str = None, groups: str = None, games: str = None, 
+                       credential: str = None, fed_id: str = None) -> Dict[str, Any]:
+        """
+        Update player profile (name, groups, games data).
+        
+        Args:
+            name: Player nickname
+            groups: Comma-separated clan IDs
+            games: JSON string with game data
+            credential: Player credential
+            fed_id: Federated ID
+            
+        Returns:
+            Update result
+        """
+        url = f"{self.BASE_URLS['osiris']}/accounts/me"
+        
+        data = {
+            "access_token": self._token_data["access_token"],
+            "timestamp": str(int(time.time()))
+        }
+        
+        if name is not None:
+            data["name"] = name
+        if groups is not None:
+            data["groups"] = groups
+        if games is not None:
+            data["games"] = games
+        if credential is not None:
+            data["credential"] = credential
+        if fed_id is not None:
+            data["fed_id"] = fed_id
+        
+        return self._make_request("POST", url, data=data)
+    
+    def get_clan_members(self, clan_id: str, offset: int = 0) -> List[Dict[str, Any]]:
+        """
+        Get all members of a clan.
+        
+        Args:
+            clan_id: The unique identifier of the clan
+            offset: Number of results to skip for pagination
+            
+        Returns:
+            List of clan members with their details
+        """
+        url = f"{self.BASE_URLS['osiris']}/groups/{clan_id}/members"
+        params = {
+            "access_token": self._token_data["access_token"],
+            "group_id": clan_id,
+            "offset": str(offset)
+        }
+        
+        response = self._make_request("GET", url, params=params)
+        return response if isinstance(response, list) else []
+    
+    def get_clan_info(self, clan_id: str) -> Dict[str, Any]:
+        """
+        Get detailed information about a clan.
+        
+        Args:
+            clan_id: The unique identifier of the clan
+            
+        Returns:
+            Clan information including settings
+        """
+        url = f"{self.BASE_URLS['osiris']}/groups/{clan_id}"
+        params = {
+            "access_token": self._token_data["access_token"]
+        }
+        
+        return self._make_request("GET", url, params=params)
+    
+    def update_clan_settings(self, clan_id: str, name: str = None, description: str = None,
+                            rating: str = None, score: str = None, member_limit: str = None,
+                            membership: str = None, logo: str = None, logo_primary_color: str = None,
+                            logo_secondary_color: str = None, min_join_value: str = None,
+                            xp: str = None, currency: str = None, killsig_id: str = None,
+                            active_clan_label: str = None, active_member_count: str = None,
+                            active_clan_threshold: str = None) -> Dict[str, Any]:
+        """
+        Update clan settings and information.
+        
+        Args:
+            clan_id: The unique identifier of the clan
+            name: Clan name
+            description: Clan description
+            rating: Clan rating
+            score: Clan score
+            member_limit: Maximum number of members
+            membership: Membership type (open, owner_approved, member_approved, closed)
+            logo: Logo ID
+            logo_primary_color: Primary logo color (0-16777215)
+            logo_secondary_color: Secondary logo color (0-16777215)
+            min_join_value: Minimum join value
+            xp: Clan XP (max 10000)
+            currency: Clan currency
+            killsig_id: Kill sign ID
+            active_clan_label: Whether clan label is active (true/false)
+            active_member_count: Active member count
+            active_clan_threshold: Active member threshold
+            
+        Returns:
+            Update result
+        """
+        url = f"{self.BASE_URLS['osiris']}/groups/{clan_id}"
+        
+        # Get current profile for required fields
+        profile = self.get_profile()
+        
+        data = {
+            "access_token": self._token_data["access_token"],
+            "_anonId": profile.get("credential", ""),
+            "_fedId": profile.get("fed_id", ""),
+            "timestamp": str(int(time.time()))
+        }
+        
+        # Add optional parameters
+        if name is not None:
+            data["name"] = name
+        if description is not None:
+            data["description"] = description
+        if rating is not None:
+            data["_rating"] = rating
+        if score is not None:
+            data["score"] = score
+        if member_limit is not None:
+            data["member_limit"] = member_limit
+        if membership is not None:
+            data["membership"] = membership
+        if logo is not None:
+            data["_logo"] = logo
+        if logo_primary_color is not None:
+            data["_logo_clr_prim"] = logo_primary_color
+        if logo_secondary_color is not None:
+            data["_logo_clr_sec"] = logo_secondary_color
+        if min_join_value is not None:
+            data["_min_join_value"] = min_join_value
+        if xp is not None:
+            data["_xp"] = xp
+        if currency is not None:
+            data["currency"] = currency
+        if killsig_id is not None:
+            data["_killsig_id"] = killsig_id
+        if active_clan_label is not None:
+            data["active_clan_label"] = active_clan_label
+        if active_member_count is not None:
+            data["active_member_count"] = active_member_count
+        if active_clan_threshold is not None:
+            data["active_clan_threshold"] = active_clan_threshold
+        
+        return self._make_request("POST", url, data=data)
+    
+    def kick_clan_member_by_dogtag(self, dogtag: str, clan_id: str, from_name: str = "SYSTEM", 
+                                kill_sign_name: str = "default_killsig_42", 
+                                kill_sign_color: str = "-974646126") -> Dict[str, Any]:
+        """
+        Kick a clan member using their dogtag (in-game ID).
+        
+        This method follows the flow: dogtag → alias → janus lookup → credential → kick
+        
+        Args:
+            dogtag: Player's dogtag in XXXX format (4-8 characters)
+            clan_id: Clan ID to kick the member from
+            from_name: Sender name (default: "SYSTEM")
+            kill_sign_name: Kill sign name (default: "default_killsig_42")
+            kill_sign_color: Kill sign color (default: "-974646126")
             
-            # Add dogtag and alias info to the response
-            if player_info['credential'] in stats:
-                stats[player_info['credential']]['dogtag'] = dogtag
-                stats[player_info['credential']]['alias'] = alias
-                stats[player_info['credential']]['player_info'] = player_info
+        Returns:
+            Dictionary with kick result
+        """
+        # Convert dogtag to alias for API lookup
+        alias = self.convert_dogtag_to_alias(dogtag)
+        
+        # Get player info using alias from janus endpoint
+        try:
+            player_info = self.get_alias_info(alias)
+            if not player_info.get('credential'):
+                return {
+                    'error': f'Player not found for dogtag: {dogtag}', 
+                    'dogtag': dogtag,
+                    'alias': alias,
+                    'success': False
+                }
             
-            return stats
+            # Use the credential to kick the member
+            return self.kick_clan_member(
+                target_fed_id=player_info['credential'],
+                clan_id=clan_id,
+                from_name=from_name,
+                kill_sign_name=kill_sign_name,
+                kill_sign_color=kill_sign_color
+            )
             
         except Exception as e:
             return {
-                'error': f'Failed to get stats for dogtag {dogtag}: {e}',
+                'error': f'Failed to kick member with dogtag {dogtag}: {e}',
                 'dogtag': dogtag,
                 'alias': alias,
-                'player_info': player_info
+                'success': False
             }
     
-    def search_player_by_dogtag(self, dogtag: str) -> Dict[str, Any]:
+    def kick_clan_member(self, target_fed_id: str, clan_id: str, from_name: str = "SYSTEM", 
+                       kill_sign_name: str = "default_killsig_42", 
+                       kill_sign_color: str = "-974646126") -> Dict[str, Any]:
         """
-        Search for a player using their dogtag and return their profile information.
+        Kick a clan member using the hermes messaging system with clan kick message type.
         
         Args:
-            dogtag: Player's dogtag in XXXX format (hexadecimal)
+            target_fed_id: Target player's fed_id or credential
+            clan_id: Clan ID to kick the member from
+            from_name: Sender name (default: "SYSTEM")
+            kill_sign_name: Kill sign name (default: "default_killsig_42")
+            kill_sign_color: Kill sign color (default: "-974646126")
             
         Returns:
-            Complete player information including stats if found
+            Dictionary with kick result
         """
-        return self.get_player_stats_by_dogtag(dogtag)
+        url = f"{self.BASE_URLS['hermes']}/messages/inbox/{target_fed_id}"
+        
+        headers = {
+            'Accept': '*/*',
+            'User-Agent': 'ChatLibv2',
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Connection': 'keep-alive'
+        }
+        
+        data = {
+            'access_token': self._token_data['access_token'],
+            'alert_kairos': 'true',
+            'from': from_name,
+            'body': clan_id,
+            'reply_to': 'game:mc5_system',
+            '_killSignColor': kill_sign_color,
+            '_killSignName': kill_sign_name,
+            '_type': 'clankick'
+        }
+        
+        return self._make_request("POST", url, data=data, headers=headers)
     
     def get_player_detailed_stats(self, credential: str) -> Dict[str, Any]:
         """
@@ -1882,23 +2146,86 @@ class MC5Client:
         weapon_stats.sort(key=lambda x: x['kills'], reverse=True)
         parsed_stats['weapon_stats'] = weapon_stats
         
-        # Parse overall statistics
+        # Parse overall statistics with detailed breakdown
         stats = game_save.get('statistics', {})
         if stats:
             sp_stats = stats.get('sp', {})
             mp_stats = stats.get('mp', {})
             
+            # Calculate comprehensive kill statistics
+            sp_total_kills = sp_stats.get('kill.total', 0)
+            mp_total_kills = mp_stats.get('kill.total', 0)
+            sp_headshots = sp_stats.get('kill.headshots', 0)
+            mp_headshots = mp_stats.get('kill.headshots', 0)
+            sp_assists = sp_stats.get('kill.assists', 0)
+            mp_assists = mp_stats.get('kill.assists', 0)
+            
+            # Parse detailed kill types
+            sp_kill_types = {
+                'rifle': sp_stats.get('kill.rifle', 0),
+                'pistol': sp_stats.get('kill.pistol', 0),
+                'explosives': sp_stats.get('kill.explosives', 0),
+                'melees': sp_stats.get('kill.melees', 0),
+                'primsecweapon': sp_stats.get('kill.primsecweapon', 0),
+                'assaults': sp_stats.get('kill.assaults', 0),
+                'recon': sp_stats.get('kill.recon', 0)
+            }
+            
+            mp_kill_types = {
+                'rifle': mp_stats.get('kill.rifle', 0),
+                'pistol': mp_stats.get('kill.pistol', 0),
+                'explosives': mp_stats.get('kill.explosives', 0),
+                'primsecweapon': mp_stats.get('kill.primsecweapon', 0),
+                'assaults': mp_stats.get('kill.assaults', 0),
+                'with_collected_weapons': mp_stats.get('kill.with_collected_weapons', 0)
+            }
+            
+            # Parse killstreak stats
+            sp_killstreaks = {
+                'total': sp_stats.get('killstreak.total', 0),
+                'assault_total': sp_stats.get('killstreak.assault.total', 0),
+                'recon_total': sp_stats.get('killstreak.recon.total', 0)
+            }
+            
+            mp_killstreaks = {
+                'total': mp_stats.get('killstreak.total', 0),
+                'assault_total': mp_stats.get('killstreak.assault.total', 0),
+                'recon_total': mp_stats.get('killstreak.recon.total', 0)
+            }
+            
             parsed_stats['overall_stats'] = {
-                'total_kills': sp_stats.get('kill.total', 0) + mp_stats.get('kill.total', 0),
+                'total_kills': sp_total_kills + mp_total_kills,
                 'total_deaths': sp_stats.get('death.total', 0) + mp_stats.get('death.total', 0),
-                'total_headshots': sp_stats.get('kill.headshots', 0) + mp_stats.get('kill.headshots', 0),
-                'total_assists': sp_stats.get('kill.assists', 0) + mp_stats.get('kill.assists', 0),
+                'total_headshots': sp_headshots + mp_headshots,
+                'total_assists': sp_assists + mp_assists,
                 'total_time_played': sp_stats.get('time.played', 0) + mp_stats.get('time.played', 0),
-                'sp_kills': sp_stats.get('kill.total', 0),
-                'mp_kills': mp_stats.get('kill.total', 0),
-                'sp_headshots': sp_stats.get('kill.headshots', 0),
-                'mp_headshots': mp_stats.get('kill.headshots', 0)
+                'sp_kills': sp_total_kills,
+                'mp_kills': mp_total_kills,
+                'sp_headshots': sp_headshots,
+                'mp_headshots': mp_headshots,
+                'sp_assists': sp_assists,
+                'mp_assists': mp_assists,
+                'sp_kill_types': sp_kill_types,
+                'mp_kill_types': mp_kill_types,
+                'sp_killstreaks': sp_killstreaks,
+                'mp_killstreaks': mp_killstreaks,
+                'weapon_kills': sum(weapon_stats[i]['kills'] for i in range(len(weapon_stats))),
+                'top_weapon': weapon_stats[0] if weapon_stats else None
             }
+            
+            # Calculate K/D ratios
+            total_deaths = sp_stats.get('death.total', 0) + mp_stats.get('death.total', 0)
+            if total_deaths > 0:
+                parsed_stats['overall_stats']['kd_ratio'] = (sp_total_kills + mp_total_kills) / total_deaths
+            else:
+                parsed_stats['overall_stats']['kd_ratio'] = float('inf')
+            
+            # Calculate headshot percentage
+            total_kills = sp_total_kills + mp_total_kills
+            if total_kills > 0:
+                parsed_stats['overall_stats']['headshot_percentage'] = ((sp_headshots + mp_headshots) / total_kills) * 100
+            else:
+                parsed_stats['overall_stats']['headshot_percentage'] = 0
         
         return parsed_stats