mc5-api-client 1.0.6__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.6"
+__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/simple_client.py

@@ -0,0 +1,570 @@
+#!/usr/bin/env python3
+# ────────────[ CHIZOBA ]────────────────────────────
+# | Email    : chizoba2026@hotmail.com
+# | File     : simple_client.py
+# | License  | MIT License © 2026 Chizoba
+# | Brief    : User-friendly MC5 API client for non-developers
+# ────────────────★─────────────────────────────────
+
+"""
+MC5 Simple API Client - User Friendly Interface
+
+A simplified version of the MC5 API Client designed for non-developers.
+Provides easy-to-use methods with automatic clan detection and simplified syntax.
+"""
+
+from typing import Optional, Dict, Any, List
+from .client import MC5Client
+from .exceptions import MC5APIError
+
+class SimpleMC5Client:
+    """
+    User-friendly MC5 API client for non-developers.
+    
+    Automatically handles clan detection and provides simplified methods
+    for common operations.
+    """
+    
+    def __init__(self, username: str, password: str):
+        """
+        Initialize the client with your MC5 credentials.
+        
+        Args:
+            username: Your MC5 username (e.g., "anonymous:your_credential")
+            password: Your MC5 password
+        """
+        self.username = username
+        self.password = password
+        self.client = None
+        self._clan_id = None
+        self._profile = None
+        
+    def connect(self) -> bool:
+        """
+        Connect to MC5 and auto-detect your clan.
+        
+        Returns:
+            True if connection successful, False otherwise
+        """
+        try:
+            # Create the client only when connecting
+            self.client = MC5Client(self.username, self.password)
+            
+            # Get profile info
+            self._profile = self.client.get_profile()
+            
+            # 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
+                
+        except Exception as e:
+            print(f"❌ Connection failed: {e}")
+            return False
+    
+    def _get_clan_name(self) -> str:
+        """Get the clan name if available."""
+        if not self._clan_id:
+            return "No clan"
+        
+        try:
+            clan_info = self.client.get_clan_info(self._clan_id)
+            return clan_info.get('name', 'Unknown clan')
+        except:
+            return "Unknown clan"
+    
+    def search_player(self, dogtag: str) -> Optional[Dict[str, Any]]:
+        """
+        Search for a player by their dogtag.
+        
+        Args:
+            dogtag: Player's dogtag (4-8 characters)
+            
+        Returns:
+            Player information or None if not found
+        """
+        try:
+            stats = self.client.get_player_stats_by_dogtag(dogtag)
+            if 'error' not in stats:
+                # Parse and return simplified info
+                player_credential = list(stats.keys())[0]
+                player_data = stats[player_credential]
+                parsed = self.client.parse_player_stats(stats)
+                
+                return {
+                    'dogtag': dogtag,
+                    'account': player_data.get('player_info', {}).get('account', 'Unknown'),
+                    'rating': parsed.get('rating', 0),
+                    'kills': parsed.get('overall_stats', {}).get('total_kills', 0),
+                    'deaths': parsed.get('overall_stats', {}).get('total_deaths', 0),
+                    'kd_ratio': parsed.get('overall_stats', {}).get('kd_ratio', 0),
+                    'headshot_percent': parsed.get('overall_stats', {}).get('headshot_percentage', 0),
+                    'play_time': parsed.get('overall_stats', {}).get('play_time', 0)
+                }
+            else:
+                print(f"❌ Player not found: {stats['error']}")
+                return None
+                
+        except Exception as e:
+            print(f"❌ Error searching player: {e}")
+            return None
+    
+    def get_my_stats(self) -> Optional[Dict[str, Any]]:
+        """
+        Get your own player statistics.
+        
+        Returns:
+            Your player information or None if error
+        """
+        if not self._profile:
+            print("❌ Not connected. Call connect() first.")
+            return None
+            
+        try:
+            return {
+                'name': self._profile.get('name', 'Unknown'),
+                'level': self._profile.get('level', 0),
+                'xp': self._profile.get('xp', 0),
+                'clan': self._get_clan_name(),
+                'clan_id': self._clan_id
+            }
+        except Exception as e:
+            print(f"❌ Error getting your stats: {e}")
+            return None
+    
+    def get_clan_members(self) -> List[Dict[str, Any]]:
+        """
+        Get all members of your clan.
+        
+        Returns:
+            List of clan members with their stats
+        """
+        if not self._clan_id:
+            print("❌ No clan detected")
+            return []
+            
+        try:
+            members = self.client.get_clan_members(self._clan_id)
+            
+            simplified_members = []
+            for member in members:
+                simplified_members.append({
+                    'name': member.get('name', 'Unknown'),
+                    'level': member.get('level', 0),
+                    'xp': member.get('_xp', 0),
+                    'score': member.get('_score', 0),
+                    'status': member.get('status', 'Unknown'),
+                    'online': member.get('online', False),
+                    'killsig': member.get('_killsig_id', 'default')
+                })
+            
+            return simplified_members
+            
+        except Exception as e:
+            print(f"❌ Error getting clan members: {e}")
+            return []
+    
+    def kick_member(self, dogtag: str, reason: str = "Kicked from clan") -> bool:
+        """
+        Kick a member from your clan by their dogtag.
+        
+        Args:
+            dogtag: Member's dogtag to kick
+            reason: Reason for kicking (optional)
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        if not self._clan_id:
+            print("❌ No clan detected")
+            return False
+            
+        try:
+            result = self.client.kick_clan_member_by_dogtag(
+                dogtag=dogtag,
+                clan_id=self._clan_id,
+                from_name="CLAN_ADMIN"
+            )
+            
+            if 'error' not in result:
+                print(f"✅ Successfully kicked player with dogtag {dogtag}")
+                return True
+            else:
+                print(f"❌ Failed to kick: {result['error']}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Error kicking member: {e}")
+            return False
+    
+    def update_clan_settings(self, name: Optional[str] = None, 
+                          description: Optional[str] = None,
+                          member_limit: Optional[int] = None) -> bool:
+        """
+        Update your clan settings.
+        
+        Args:
+            name: New clan name (optional)
+            description: New clan description (optional)
+            member_limit: New member limit (optional)
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        if not self._clan_id:
+            print("❌ No clan detected")
+            return False
+            
+        try:
+            # Build settings dict with only provided values
+            settings = {}
+            if name:
+                settings['name'] = name
+            if description:
+                settings['description'] = description
+            if member_limit:
+                settings['member_limit'] = str(member_limit)
+            
+            if not settings:
+                print("⚠️ No settings to update")
+                return False
+            
+            result = self.client.update_clan_settings(self._clan_id, **settings)
+            
+            if 'error' not in result:
+                print(f"✅ Clan settings updated successfully")
+                return True
+            else:
+                print(f"❌ Failed to update settings: {result['error']}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Error updating clan settings: {e}")
+            return False
+    
+    def send_message(self, dogtag: str, message: str) -> bool:
+        """
+        Send a private message to a player.
+        
+        Args:
+            dogtag: Player's dogtag
+            message: Message to send
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # First get player info to find their credential
+            player_info = self.client.get_player_stats_by_dogtag(dogtag)
+            if 'error' in player_info:
+                print(f"❌ Player not found: {player_info['error']}")
+                return False
+            
+            # Get credential from player data
+            player_credential = list(player_info.keys())[0]
+            
+            # Send message
+            result = self.client.send_private_message(
+                credential=player_credential,
+                message=message
+            )
+            
+            if 'error' not in result:
+                print(f"✅ Message sent to {dogtag}")
+                return True
+            else:
+                print(f"❌ Failed to send message: {result['error']}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Error sending message: {e}")
+            return False
+    
+    def get_inactive_members(self, days_inactive: int = 30) -> List[Dict[str, Any]]:
+        """
+        Get members who haven't been active for specified days.
+        
+        Args:
+            days_inactive: Number of days to consider inactive
+            
+        Returns:
+            List of inactive members
+        """
+        if not self._clan_id:
+            print("❌ No clan detected")
+            return []
+            
+        try:
+            members = self.client.get_clan_members(self._clan_id)
+            inactive_members = []
+            
+            for member in members:
+                # Check last online time (simplified - you'd need to parse actual date)
+                if not member.get('online', False):
+                    # In a real implementation, you'd check the last_online timestamp
+                    # For now, we'll consider offline members as potentially inactive
+                    inactive_members.append({
+                        'name': member.get('name', 'Unknown'),
+                        'level': member.get('level', 0),
+                        'xp': member.get('_xp', 0),
+                        'status': member.get('status', 'Unknown'),
+                        'online': False
+                    })
+            
+            return inactive_members
+            
+        except Exception as e:
+            print(f"❌ Error getting inactive members: {e}")
+            return []
+    
+    def auto_kick_inactive_members(self, days_inactive: int = 30, dry_run: bool = True) -> Dict[str, Any]:
+        """
+        Automatically kick inactive members with safety checks.
+        
+        Args:
+            days_inactive: Days of inactivity to trigger kick
+            dry_run: If True, only show who would be kicked without actually kicking
+            
+        Returns:
+            Dictionary with results
+        """
+        inactive_members = self.get_inactive_members(days_inactive)
+        
+        if not inactive_members:
+            return {'kicked': 0, 'skipped': 0, 'members': []}
+        
+        results = {'kicked': 0, 'skipped': 0, 'members': []}
+        
+        for member in inactive_members:
+            # Safety checks
+            if member['level'] > 50:  # Don't kick high-level members
+                print(f"⚠️ Skipping {member['name']} (Level {member['level']} - too high)")
+                results['skipped'] += 1
+                continue
+                
+            if 'leader' in member['status'].lower() or 'admin' in member['status'].lower():
+                print(f"⚠️ Skipping {member['name']} ({member['status']} - protected role)")
+                results['skipped'] += 1
+                continue
+            
+            if dry_run:
+                print(f"🔍 Would kick: {member['name']} (Level {member['level']}) - Inactive for {days_inactive}+ days")
+            else:
+                # Note: This would need the member's dogtag, which we'd need to fetch
+                print(f"🔨 Kicking {member['name']} (Level {member['level']})")
+                # client.kick_member(member['dogtag'], f"Inactive for {days_inactive} days")
+                results['kicked'] += 1
+            
+            results['members'].append(member)
+        
+        return results
+    
+    def close(self):
+        """Close the connection."""
+        try:
+            if self.client:
+                self.client.close()
+                print("✅ Connection closed")
+        except:
+            pass
+    
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()
+
+
+# Even simpler interface for absolute beginners
+def quick_search(dogtag: str, username: str, password: str) -> Optional[Dict[str, Any]]:
+    """
+    Quick search for a player by dogtag.
+    
+    Args:
+        dogtag: Player's dogtag to search
+        username: Your MC5 username
+        password: Your MC5 password
+        
+    Returns:
+        Player information or None if not found
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            return client.search_player(dogtag)
+    return None
+
+
+def quick_kick(dogtag: str, username: str, password: str, reason: str = "Kicked") -> bool:
+    """
+    Quick kick a member by dogtag.
+    
+    Args:
+        dogtag: Member's dogtag to kick
+        username: Your MC5 username
+        password: Your MC5 password
+        reason: Reason for kicking
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            return client.kick_member(dogtag, reason)
+    return False
+
+
+def batch_search_players(dogtags: List[str], username: str, password: str) -> Dict[str, Any]:
+    """
+    Search for multiple players at once.
+    
+    Args:
+        dogtags: List of dogtags to search
+        username: Your MC5 username
+        password: Your MC5 password
+        
+    Returns:
+        Dictionary with search results
+    """
+    results = {'found': [], 'not_found': [], 'errors': []}
+    
+    with SimpleMC5Client(username, password) as client:
+        if client.connect():
+            for dogtag in dogtags:
+                try:
+                    player = client.search_player(dogtag)
+                    if player:
+                        results['found'].append(player)
+                        print(f"✅ Found {dogtag}: {player['kills']:,} kills")
+                    else:
+                        results['not_found'].append(dogtag)
+                        print(f"❌ Not found: {dogtag}")
+                except Exception as e:
+                    results['errors'].append({'dogtag': dogtag, 'error': str(e)})
+                    print(f"⚠️ Error with {dogtag}: {e}")
+    
+    return results
+
+
+def clan_cleanup(username: str, password: str, 
+                 inactive_days: int = 30,
+                 min_level: int = 10,
+                 dry_run: bool = True) -> Dict[str, Any]:
+    """
+    Comprehensive clan cleanup with conditional logic.
+    
+    Args:
+        username: Your MC5 username
+        password: Your MC5 password
+        inactive_days: Days of inactivity to consider
+        min_level: Minimum level to protect from kicking
+        dry_run: If True, only show what would be done
+        
+    Returns:
+        Dictionary with cleanup results
+    """
+    results = {
+        'total_members': 0,
+        'active_members': 0,
+        'inactive_members': 0,
+        'would_kick': 0,
+        'protected': 0,
+        'actions': []
+    }
+    
+    with SimpleMC5Client(username, password) as client:
+        if not client.connect():
+            return results
+        
+        members = client.get_clan_members()
+        results['total_members'] = len(members)
+        
+        for member in members:
+            # Conditional logic for each member
+            if member.get('online', False):
+                results['active_members'] += 1
+                results['actions'].append(f"✅ {member['name']} - Online (protected)")
+                continue
+            
+            # Check level protection
+            if member.get('level', 0) >= min_level:
+                results['protected'] += 1
+                results['actions'].append(f"🛡️ {member['name']} - Level {member['level']} (protected)")
+                continue
+            
+            # Check role protection
+            status = member.get('status', '').lower()
+            if any(role in status for role in ['leader', 'admin', 'officer']):
+                results['protected'] += 1
+                results['actions'].append(f"👑 {member['name']} - {member['status']} (protected)")
+                continue
+            
+            # Member is inactive and not protected
+            results['inactive_members'] += 1
+            results['would_kick'] += 1
+            
+            if dry_run:
+                results['actions'].append(f"🔍 Would kick: {member['name']} - Level {member['level']}, Inactive")
+            else:
+                # Note: Would need dogtag for actual kicking
+                results['actions'].append(f"🔨 Kicked: {member['name']} - Level {member['level']}")
+    
+    return results
+
+
+def monitor_clan_activity(username: str, password: str, 
+                         check_interval: int = 60,
+                         max_checks: int = 10) -> None:
+    """
+    Monitor clan activity with while loop.
+    
+    Args:
+        username: Your MC5 username
+        password: Your MC5 password
+        check_interval: Seconds between checks
+        max_checks: Maximum number of checks to perform
+    """
+    import time
+    
+    check_count = 0
+    
+    with SimpleMC5Client(username, password) as client:
+        if not client.connect():
+            return
+        
+        print(f"🔍 Starting clan activity monitoring (checking every {check_interval}s)")
+        
+        while check_count < max_checks:
+            check_count += 1
+            
+            try:
+                members = client.get_clan_members()
+                online_count = sum(1 for m in members if m.get('online', False))
+                
+                print(f"Check {check_count}/{max_checks}: {online_count}/{len(members)} members online")
+                
+                # Conditional alerts
+                if online_count == 0:
+                    print("🚨 Alert: No members online!")
+                elif online_count > len(members) * 0.8:
+                    print("🎉 High activity: Most members are online!")
+                
+                # Break if all members are online
+                if online_count == len(members):
+                    print("✅ All members are online! Stopping monitor.")
+                    break
+                    
+            except Exception as e:
+                print(f"⚠️ Error during check {check_count}: {e}")
+            
+            # Wait before next check (except after last check)
+            if check_count < max_checks:
+                time.sleep(check_interval)
+        
+        print(f"🏁 Monitoring completed after {check_count} checks")

{mc5_api_client-1.0.6.dist-info → mc5_api_client-1.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mc5_api_client
-Version: 1.0.6
+Version: 1.0.8
 Summary: A comprehensive Python library for interacting with the Modern Combat 5 API
 Home-page: https://pypi.org/project/mc5-api-client/
 Author: Chizoba
@@ -102,14 +102,26 @@ Think of this as your remote control for Modern Combat 5! Here's what you can do
 - 🖥️ **Modern CLI**: A beautiful command-line tool with colors and emojis
 - 🔄 **Auto-Refresh**: Tokens refresh automatically - no interruptions!
 - 🛡️ **Error Handling**: Get helpful error messages when things go wrong
+- 🎮 **NEW: Simple Interface**: Perfect for non-developers with auto-clan detection!
+- ⚡ **NEW: One-Liner Functions**: Quick search and kick operations!
+- 🎯 **NEW: User-Friendly**: Designed for beginners and clan leaders!
 
 ## � Installation & Publishing
 
-### 🎉 MC5 API Client v1.0.5 - Enhanced Clan Management & Dogtag System!
+### 🎉 MC5 API Client v1.0.7 - Revolutionary User-Friendly Interface!
 
 ### ✅ **Major Enhancements Completed!**
 
-**🏰 Complete Clan Management Suite:**
+**� Revolutionary Simple Interface (NEW in v1.0.7):**
+- ✅ **SimpleMC5Client**: Designed specifically for non-developers
+- ✅ **Auto-Clan Detection**: Automatically finds clan ID from your profile
+- ✅ **One-Liner Functions**: `quick_search()` and `quick_kick()` for instant results
+- ✅ **Simplified Method Names**: `search_player()` instead of complex technical names
+- ✅ **Context Manager Support**: Automatic cleanup with `with` statements
+- ✅ **User-Friendly Documentation**: Complete beginner's guide with examples
+- ✅ **No Technical Knowledge Required**: Perfect for clan leaders and players
+
+**� Complete Clan Management Suite:**
 - ✅ **Profile Management**: Get/update player profiles with groups and credentials
 - ✅ **Clan Operations**: Get clan info, members, settings with full CRUD operations
 - ✅ **Member Management**: Invite, kick, promote, demote members with detailed stats
@@ -136,7 +148,132 @@ Think of this as your remote control for Modern Combat 5! Here's what you can do
 pip install mc5_api_client
 ```
 
-✅ **Published and Available!** The MC5 API Client v1.0.6 is now live on PyPI with enhanced clan management and dogtag features!
+✅ **Published and Available!** The MC5 API Client v1.0.7 is now live on PyPI with revolutionary user-friendly features for non-developers!
+
+## 🎮 **Simple Usage for Non-Developers**
+
+New in v1.0.7! We've added a revolutionary super-simple interface for non-developers:
+
+### **🚀 Quick Start - Just 3 Lines!**
+
+```python
+from mc5_api_client import SimpleMC5Client
+
+# Connect and auto-detect your clan
+client = SimpleMC5Client('YOUR_USERNAME', 'YOUR_PASSWORD')
+client.connect()
+
+# Search for any player by dogtag
+player = client.search_player('f55f')
+print(f"Found: {player['kills']:,} kills")
+```
+
+### **🎯 Super Simple Examples:**
+
+**Search Players:**
+```python
+# One-line search
+from mc5_api_client import quick_search
+player = quick_search('218f', 'YOUR_USERNAME', 'YOUR_PASSWORD')
+print(f"Elite player: {player['kills']:,} kills!")
+```
+
+**Batch Search with Loop:**
+```python
+from mc5_api_client.simple_client import batch_search_players
+
+dogtags = ['f55f', '9gg9', '78d7', '218f']
+results = batch_search_players(dogtags, 'YOUR_USERNAME', 'YOUR_PASSWORD')
+
+# Conditional processing
+for player in results['found']:
+    if player['kills'] > 10000:
+        print(f"🌟 Elite: {player['dogtag']} - {player['kills']:,} kills")
+    else:
+        print(f"👤 Player: {player['dogtag']} - {player['kills']:,} kills")
+```
+
+**Smart Clan Cleanup:**
+```python
+from mc5_api_client.simple_client import clan_cleanup
+
+# Intelligent cleanup with conditional logic
+results = clan_cleanup(
+    'YOUR_USERNAME', 'YOUR_PASSWORD',
+    inactive_days=30,
+    min_level=15,  # Protect high-level players
+    dry_run=True   # Simulation only
+)
+
+print(f"Would kick: {results['would_kick']} members")
+print(f"Protected: {results['protected']} members")
+
+if results['would_kick'] > 0:
+    print("⚠️ Consider removing inactive members")
+```
+
+**Real-time Monitoring:**
+```python
+from mc5_api_client.simple_client import monitor_clan_activity
+
+# Monitor clan activity every 60 seconds for 10 checks
+monitor_clan_activity(
+    'YOUR_USERNAME', 'YOUR_PASSWORD',
+    check_interval=60,
+    max_checks=10
+)
+```
+
+**Clan Management:**
+```python
+with SimpleMC5Client('YOUR_USERNAME', 'YOUR_PASSWORD') as client:
+    client.connect()  # Auto-detects your clan!
+    
+    # Get all clan members
+    members = client.get_clan_members()
+    print(f"Your clan has {len(members)} members")
+    
+    # Kick by dogtag (no clan ID needed!)
+    client.kick_member('9gg9', 'Inactive for 30 days')
+    
+    # Update clan settings
+    client.update_clan_settings(name="Elite Squad 2026")
+```
+
+**Send Messages:**
+```python
+with SimpleMC5Client('YOUR_USERNAME', 'YOUR_PASSWORD') as client:
+    client.connect()
+    
+    # Send message to any player by dogtag
+    client.send_message('f55f', 'Want to play together?')
+```
+
+### **✨ Key Benefits for Non-Developers:**
+
+- ✅ **No Clan ID Needed**: Auto-detects your clan from your profile
+- ✅ **Simple Method Names**: `search_player()` instead of `get_player_stats_by_dogtag()`
+- ✅ **Auto-Connection**: Just call `connect()` once
+- ✅ **Clear Error Messages**: User-friendly error descriptions
+- ✅ **Context Manager**: Automatic cleanup with `with` statement
+- ✅ **Quick Functions**: One-liners for common tasks
+
+### **📚 Simple vs Advanced Comparison:**
+
+| Task | Simple Version | Advanced Version |
+|------|----------------|------------------|
+| Search Player | `client.search_player('f55f')` | `client.get_player_stats_by_dogtag('f55f')` |
+| Get Clan Members | `client.get_clan_members()` | `client.get_clan_members(clan_id)` |
+| Kick Member | `client.kick_member('9gg9')` | `client.kick_clan_member_by_dogtag('9gg9', clan_id)` |
+| Connect | `client.connect()` | Manual authentication |
+
+### **🎯 Perfect For:**
+- **Clan Leaders**: Easy member management
+- **Players**: Quick stats lookup
+- **Beginners**: No programming experience needed
+- **Quick Tasks**: One-liner functions
+
+---
 
 ### 📦 Install from Local Package
 

mc5_api_client-1.0.8.dist-info/RECORD

@@ -0,0 +1,13 @@
+mc5_api_client/__init__.py,sha256=S6NeWp0J02LoCdUh0vqmgOmY-G0QLDR-1-z9_onBu9k,1435
+mc5_api_client/auth.py,sha256=Yj_6s8KmtbswWbR6q816d8soIirUF2aD_KWxg-jNqR0,9978
+mc5_api_client/cli.py,sha256=KegNTxwq28gu_vrffc_cXcALrHzUBDHd-5DqKyYp4p0,17284
+mc5_api_client/client.py,sha256=q5PkdpTXjWCXdLFiK1-zqa7fThJGE4Z99A3ccMfwJIY,79239
+mc5_api_client/exceptions.py,sha256=o7od4GrEIlgq6xSNUjZdh74xoDTytF3PLcMq5ewRiJw,2683
+mc5_api_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mc5_api_client/simple_client.py,sha256=31JI2rURHIXKcnDXQYJNpr-gypweO56ANFdhD-Z4Ft0,20241
+mc5_api_client-1.0.8.dist-info/licenses/LICENSE,sha256=M0UBQ4B3pB9XcV54_jhVP681xyauF8GB6YK_rKmuXzk,1064
+mc5_api_client-1.0.8.dist-info/METADATA,sha256=VzsdMhgnwtLnbQJUBOPElbBIPJeOLN97inFTsN18vIo,46848
+mc5_api_client-1.0.8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mc5_api_client-1.0.8.dist-info/entry_points.txt,sha256=2kruOpleFYK3Jl1MoQwGyqCd-Pj4kQWngXmIjnXx_gE,48
+mc5_api_client-1.0.8.dist-info/top_level.txt,sha256=eYJe4ue9j1ig_jFY5Z05mDqpizUEV7TYpk5lBXVd4kA,15
+mc5_api_client-1.0.8.dist-info/RECORD,,

mc5_api_client-1.0.6.dist-info/RECORD

@@ -1,12 +0,0 @@
-mc5_api_client/__init__.py,sha256=WDc62FXv111bfrTu-oxhcXmOulqKK7f7pX9M2nidIuo,1021
-mc5_api_client/auth.py,sha256=Yj_6s8KmtbswWbR6q816d8soIirUF2aD_KWxg-jNqR0,9978
-mc5_api_client/cli.py,sha256=KegNTxwq28gu_vrffc_cXcALrHzUBDHd-5DqKyYp4p0,17284
-mc5_api_client/client.py,sha256=q5PkdpTXjWCXdLFiK1-zqa7fThJGE4Z99A3ccMfwJIY,79239
-mc5_api_client/exceptions.py,sha256=o7od4GrEIlgq6xSNUjZdh74xoDTytF3PLcMq5ewRiJw,2683
-mc5_api_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mc5_api_client-1.0.6.dist-info/licenses/LICENSE,sha256=M0UBQ4B3pB9XcV54_jhVP681xyauF8GB6YK_rKmuXzk,1064
-mc5_api_client-1.0.6.dist-info/METADATA,sha256=gx5DaikhrIqMJJAk-j7KENniJht0b7oVbe9iTYyEjDk,42094
-mc5_api_client-1.0.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mc5_api_client-1.0.6.dist-info/entry_points.txt,sha256=2kruOpleFYK3Jl1MoQwGyqCd-Pj4kQWngXmIjnXx_gE,48
-mc5_api_client-1.0.6.dist-info/top_level.txt,sha256=eYJe4ue9j1ig_jFY5Z05mDqpizUEV7TYpk5lBXVd4kA,15
-mc5_api_client-1.0.6.dist-info/RECORD,,