binalyze-air-sdk 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

binalyze_air/commands/license.py

@@ -0,0 +1,183 @@
+"""License command classes for Binalyze AIR SDK."""
+
+from typing import Optional, Dict, Any
+from ..models.license import License
+from ..queries.license import GetLicenseQuery, SetLicenseQuery
+
+
+class LicenseCommand:
+    """Base command class for license operations."""
+    
+    def __init__(self, api_client):
+        """Initialize license command.
+        
+        Args:
+            api_client: The License API client instance
+        """
+        self._api_client = api_client
+
+
+class GetLicenseCommand(LicenseCommand):
+    """Command for retrieving current license information.
+    
+    This command provides comprehensive license details including
+    expiration status, usage statistics, and validation.
+    """
+    
+    def execute(self) -> License:
+        """Execute get license command.
+        
+        Returns:
+            License object with current license information
+            
+        Raises:
+            APIError: If the request fails
+        """
+        query = GetLicenseQuery()
+        response = self._api_client._get_license_query(query)
+        
+        if response.get('success') and response.get('result'):
+            return License.from_dict(response['result'])
+        else:
+            raise ValueError(
+                f"Failed to get license: {response.get('errors', [])}"
+            )
+
+    def get_license_status(self) -> Dict[str, Any]:
+        """Get comprehensive license status information.
+        
+        Returns:
+            Dictionary with license status, usage, and warnings
+        """
+        license_info = self.execute()
+        usage_stats = license_info.get_usage_percentage()
+        
+        status = {
+            'license_key': license_info.key,
+            'customer_name': license_info.customer_name,
+            'is_active': not license_info.is_expired(),
+            'is_lifetime': license_info.is_lifetime,
+            'expires_on': license_info.expires_on.isoformat(),
+            'remaining_days': license_info.remaining_days,
+            'device_usage': {
+                'current': license_info.device_count,
+                'maximum': license_info.max_device_count,
+                'percentage': usage_stats['device_usage_percent']
+            },
+            'client_usage': {
+                'current': license_info.client_count,
+                'maximum': license_info.max_client_count,
+                'percentage': usage_stats['client_usage_percent']
+            },
+            'warnings': []
+        }
+        
+        # Add warnings for various conditions
+        if license_info.is_expired():
+            status['warnings'].append('License has expired')
+        elif license_info.is_near_expiry(30):
+            status['warnings'].append(
+                f'License expires in {license_info.remaining_days} days'
+            )
+        
+        if usage_stats['device_usage_percent'] > 80:
+            status['warnings'].append(
+                f'Device usage at {usage_stats["device_usage_percent"]}%'
+            )
+        
+        if usage_stats['client_usage_percent'] > 80:
+            status['warnings'].append(
+                f'Client usage at {usage_stats["client_usage_percent"]}%'
+            )
+        
+        if license_info.is_locked_down:
+            status['warnings'].append('License is in locked down mode')
+        
+        return status
+
+
+class SetLicenseCommand(LicenseCommand):
+    """Command for setting/updating license key.
+    
+    This command allows updating the system license key
+    and validates the operation.
+    """
+    
+    def __init__(self, api_client, license_key: str):
+        """Initialize set license command.
+        
+        Args:
+            api_client: The License API client instance
+            license_key: The new license key to set
+        """
+        super().__init__(api_client)
+        self._license_key = license_key
+
+    def execute(self) -> bool:
+        """Execute set license command.
+        
+        Returns:
+            True if license was set successfully
+            
+        Raises:
+            APIError: If the request fails
+            ValueError: If license key is invalid
+        """
+        if not self._license_key or not self._license_key.strip():
+            raise ValueError("License key cannot be empty")
+        
+        query = SetLicenseQuery(self._license_key)
+        response = self._api_client._set_license_query(query)
+        
+        if response.get('success'):
+            return True
+        else:
+            raise ValueError(
+                f"Failed to set license: {response.get('errors', [])}"
+            )
+
+    def set_and_verify(self) -> Dict[str, Any]:
+        """Set license key and verify the operation.
+        
+        Returns:
+            Dictionary with operation result and new license status
+        """
+        # Set the license
+        success = self.execute()
+        
+        if success:
+            # Verify by getting current license info
+            get_command = GetLicenseCommand(self._api_client)
+            try:
+                new_license = get_command.execute()
+                return {
+                    'success': True,
+                    'message': 'License updated successfully',
+                    'license_info': {
+                        'key': new_license.key,
+                        'customer_name': new_license.customer_name,
+                        'expires_on': new_license.expires_on.isoformat(),
+                        'remaining_days': new_license.remaining_days,
+                        'is_active': not new_license.is_expired()
+                    }
+                }
+            except Exception as e:
+                return {
+                    'success': True,
+                    'message': 'License set but verification failed',
+                    'warning': str(e)
+                }
+        
+        return {
+            'success': False,
+            'message': 'Failed to set license'
+        }
+
+    @property
+    def license_key(self) -> str:
+        """Get the license key to be set.
+        
+        Returns:
+            The license key
+        """
+        return self._license_key 

binalyze_air/commands/logger.py

@@ -0,0 +1,126 @@
+"""Logger command classes for Binalyze AIR SDK."""
+
+from typing import Optional, Dict, Any
+from pathlib import Path
+from ..models.logger import LogDownloadResponse
+from ..queries.logger import DownloadLogsQuery
+
+
+class LoggerCommand:
+    """Base command class for logger operations."""
+    
+    def __init__(self, api_client):
+        """Initialize logger command.
+        
+        Args:
+            api_client: The Logger API client instance
+        """
+        self._api_client = api_client
+
+
+class DownloadLogsCommand(LoggerCommand):
+    """Command for downloading application logs as ZIP file.
+    
+    This command provides comprehensive log download functionality
+    with options for latest logs only and automatic file saving.
+    """
+    
+    def __init__(self, api_client, latest_log_file: bool = False):
+        """Initialize download logs command.
+        
+        Args:
+            api_client: The Logger API client instance
+            latest_log_file: Whether to download only the latest log file
+        """
+        super().__init__(api_client)
+        self._latest_log_file = latest_log_file
+
+    def execute(self) -> LogDownloadResponse:
+        """Execute download logs command.
+        
+        Returns:
+            LogDownloadResponse with downloaded log data
+            
+        Raises:
+            APIError: If the request fails
+        """
+        query = DownloadLogsQuery(self._latest_log_file)
+        response_data, headers = self._api_client._download_logs_query(query)
+        
+        # Create response object from binary data and headers
+        return LogDownloadResponse.from_response(response_data, headers)
+
+    def download_and_save(self, save_path: Optional[str] = None) -> Dict[str, Any]:
+        """Download logs and save to file.
+        
+        Args:
+            save_path: Optional path where to save the logs.
+                      If not provided, saves to current directory.
+        
+        Returns:
+            Dictionary with download result and file information
+        """
+        try:
+            # Download the logs
+            log_response = self.execute()
+            
+            # Determine save path
+            if save_path is None:
+                save_path = log_response.filename or 'air_logs.zip'
+            
+            # Ensure directory exists
+            Path(save_path).parent.mkdir(parents=True, exist_ok=True)
+            
+            # Save to file
+            success = log_response.save_to_file(save_path)
+            
+            return {
+                'success': success,
+                'file_path': save_path,
+                'file_size': log_response.size,
+                'content_type': log_response.content_type,
+                'filename': log_response.filename,
+                'latest_only': self._latest_log_file
+            }
+            
+        except Exception as e:
+            return {
+                'success': False,
+                'error': str(e),
+                'file_path': save_path,
+                'latest_only': self._latest_log_file
+            }
+
+    def get_log_info(self) -> Dict[str, Any]:
+        """Get information about available logs without downloading.
+        
+        Returns:
+            Dictionary with log information
+        """
+        try:
+            # Download logs to get metadata
+            log_response = self.execute()
+            
+            return {
+                'available': True,
+                'size': log_response.size,
+                'content_type': log_response.content_type,
+                'filename': log_response.filename,
+                'latest_only': self._latest_log_file
+            }
+            
+        except Exception as e:
+            return {
+                'available': False,
+                'error': str(e),
+                'latest_only': self._latest_log_file
+            }
+
+    @property
+    def latest_log_file(self) -> bool:
+        """Get the latest log file flag.
+        
+        Returns:
+            Whether downloading only the latest log file
+        """
+        return self._latest_log_file 

binalyze_air/commands/multipart_upload.py

@@ -0,0 +1,363 @@
+"""Multipart Upload command classes for Binalyze AIR SDK."""
+
+from typing import Optional, Dict, Any, List, Callable
+from pathlib import Path
+import time
+from ..models.multipart_upload import (
+    UploadInitializeResponse, UploadPartResponse, UploadStatusResponse, 
+    UploadFinalizeResponse, MultipartUploadSession, FileChunker
+)
+from ..queries.multipart_upload import (
+    InitializeUploadQuery, UploadPartQuery, CheckUploadStatusQuery, FinalizeUploadQuery
+)
+
+
+class MultipartUploadCommand:
+    """Base command class for multipart upload operations."""
+    
+    def __init__(self, api_client):
+        """Initialize multipart upload command.
+        
+        Args:
+            api_client: The Multipart Upload API client instance
+        """
+        self._api_client = api_client
+
+
+class InitializeUploadCommand(MultipartUploadCommand):
+    """Command for initializing a multipart upload session."""
+    
+    def execute(self) -> UploadInitializeResponse:
+        """Execute upload initialization command.
+        
+        Returns:
+            UploadInitializeResponse with file ID for the session
+            
+        Raises:
+            APIError: If the request fails
+        """
+        query = InitializeUploadQuery()
+        response_data = self._api_client._initialize_upload_query(query)
+        
+        return UploadInitializeResponse.from_dict(response_data)
+
+
+class UploadPartCommand(MultipartUploadCommand):
+    """Command for uploading a file part in a multipart upload."""
+    
+    def __init__(self, api_client, file_id: str, part_number: int, file_data: bytes, filename: Optional[str] = None):
+        """Initialize upload part command.
+        
+        Args:
+            api_client: The Multipart Upload API client instance
+            file_id: Upload session identifier
+            part_number: Sequential part number (starting from 1)
+            file_data: Binary file data for this part
+            filename: Optional filename for the part
+        """
+        super().__init__(api_client)
+        self._file_id = file_id
+        self._part_number = part_number
+        self._file_data = file_data
+        self._filename = filename
+
+    def execute(self) -> UploadPartResponse:
+        """Execute upload part command.
+        
+        Returns:
+            UploadPartResponse indicating success/failure
+            
+        Raises:
+            APIError: If the request fails
+        """
+        query = UploadPartQuery(self._file_id, self._part_number, self._file_data, self._filename)
+        response_data = self._api_client._upload_part_query(query)
+        
+        return UploadPartResponse.from_dict(response_data, self._part_number)
+
+
+class CheckUploadStatusCommand(MultipartUploadCommand):
+    """Command for checking upload status."""
+    
+    def __init__(self, api_client, file_id: str):
+        """Initialize upload status check command.
+        
+        Args:
+            api_client: The Multipart Upload API client instance
+            file_id: Upload session identifier to check
+        """
+        super().__init__(api_client)
+        self._file_id = file_id
+
+    def execute(self) -> UploadStatusResponse:
+        """Execute upload status check command.
+        
+        Returns:
+            UploadStatusResponse with ready status
+            
+        Raises:
+            APIError: If the request fails
+        """
+        query = CheckUploadStatusQuery(self._file_id)
+        response_data = self._api_client._check_upload_status_query(query)
+        
+        return UploadStatusResponse.from_dict(response_data, self._file_id)
+
+
+class FinalizeUploadCommand(MultipartUploadCommand):
+    """Command for finalizing a multipart upload."""
+    
+    def __init__(self, api_client, file_id: str):
+        """Initialize upload finalization command.
+        
+        Args:
+            api_client: The Multipart Upload API client instance
+            file_id: Upload session identifier to finalize
+        """
+        super().__init__(api_client)
+        self._file_id = file_id
+
+    def execute(self) -> UploadFinalizeResponse:
+        """Execute upload finalization command.
+        
+        Returns:
+            UploadFinalizeResponse indicating success/failure
+            
+        Raises:
+            APIError: If the request fails
+        """
+        query = FinalizeUploadQuery(self._file_id)
+        response_data = self._api_client._finalize_upload_query(query)
+        
+        return UploadFinalizeResponse.from_dict(response_data, self._file_id)
+
+
+class CompleteFileUploadCommand(MultipartUploadCommand):
+    """Command for uploading a complete file using multipart upload.
+    
+    This command orchestrates the entire upload process:
+    1. Initialize upload session
+    2. Upload all file parts
+    3. Check upload status
+    4. Finalize upload
+    """
+    
+    def __init__(
+        self, 
+        api_client, 
+        file_path: str, 
+        chunk_size: int = 5 * 1024 * 1024,
+        progress_callback: Optional[Callable[[float, int, int], None]] = None
+    ):
+        """Initialize complete file upload command.
+        
+        Args:
+            api_client: The Multipart Upload API client instance
+            file_path: Path to the file to upload
+            chunk_size: Size of each chunk in bytes (default 5MB)
+            progress_callback: Optional callback for progress updates (percentage, current_part, total_parts)
+        """
+        super().__init__(api_client)
+        self._file_path = file_path
+        self._chunk_size = chunk_size
+        self._progress_callback = progress_callback
+        self._session: Optional[MultipartUploadSession] = None
+
+    def execute(self) -> Dict[str, Any]:
+        """Execute complete file upload.
+        
+        Returns:
+            Dictionary with upload results and session information
+            
+        Raises:
+            APIError: If any step of the upload fails
+            FileNotFoundError: If the file doesn't exist
+        """
+        try:
+            # Validate file exists
+            if not Path(self._file_path).exists():
+                raise FileNotFoundError(f"File not found: {self._file_path}")
+
+            # Step 1: Initialize upload session
+            init_response = self._initialize_session()
+            if not init_response.success:
+                return {
+                    'success': False,
+                    'error': 'Failed to initialize upload session',
+                    'file_path': self._file_path
+                }
+
+            # Step 2: Upload all parts
+            upload_results = self._upload_all_parts()
+            if not upload_results['success']:
+                return {
+                    'success': False,
+                    'error': upload_results['error'],
+                    'file_path': self._file_path,
+                    'file_id': self._session.file_id if self._session else None,
+                    'uploaded_parts': len(self._session.uploaded_parts) if self._session else 0,
+                    'total_parts': self._session.total_parts if self._session else 0
+                }
+
+            # Step 3: Check upload status
+            status_response = self._check_status()
+            if not status_response.success or not status_response.ready:
+                return {
+                    'success': False,
+                    'error': 'Upload not ready for finalization',
+                    'file_path': self._file_path,
+                    'file_id': self._session.file_id if self._session else None,
+                    'ready': status_response.ready
+                }
+
+            # Step 4: Finalize upload
+            finalize_response = self._finalize_upload()
+            if not finalize_response.success:
+                return {
+                    'success': False,
+                    'error': finalize_response.error_message or 'Failed to finalize upload',
+                    'file_path': self._file_path,
+                    'file_id': self._session.file_id if self._session else None
+                }
+
+            # Success!
+            return {
+                'success': True,
+                'file_path': self._file_path,
+                'file_id': self._session.file_id if self._session else None,
+                'total_parts': self._session.total_parts if self._session else 0,
+                'total_size': self._session.total_size if self._session else 0,
+                'chunk_size': self._session.chunk_size if self._session else 0,
+                'upload_complete': True
+            }
+
+        except Exception as e:
+            return {
+                'success': False,
+                'error': str(e),
+                'file_path': self._file_path,
+                'file_id': self._session.file_id if self._session else None
+            }
+
+    def _initialize_session(self) -> UploadInitializeResponse:
+        """Initialize the upload session."""
+        # Create session from file
+        self._session = FileChunker.create_session_from_file(self._file_path, self._chunk_size)
+        
+        # Initialize upload
+        init_command = InitializeUploadCommand(self._api_client)
+        init_response = init_command.execute()
+        
+        # Update session with file ID
+        if init_response.success:
+            self._session.file_id = init_response.file_id
+        
+        return init_response
+
+    def _upload_all_parts(self) -> Dict[str, Any]:
+        """Upload all file parts."""
+        if not self._session:
+            return {'success': False, 'error': 'Session not initialized'}
+
+        failed_parts = []
+        
+        for part_number in range(1, self._session.total_parts + 1):
+            try:
+                # Read chunk data
+                chunk_data = FileChunker.read_chunk(
+                    self._file_path, 
+                    part_number, 
+                    self._session.chunk_size
+                )
+                
+                # Upload part
+                upload_command = UploadPartCommand(
+                    self._api_client,
+                    self._session.file_id,
+                    part_number,
+                    chunk_data,
+                    Path(self._file_path).name
+                )
+                
+                part_response = upload_command.execute()
+                
+                if part_response.success:
+                    self._session.add_uploaded_part(part_number)
+                    
+                    # Call progress callback if provided
+                    if self._progress_callback:
+                        progress = self._session.get_progress_percentage()
+                        self._progress_callback(progress, part_number, self._session.total_parts)
+                else:
+                    failed_parts.append({
+                        'part_number': part_number,
+                        'error': part_response.error_message
+                    })
+                    
+            except Exception as e:
+                failed_parts.append({
+                    'part_number': part_number,
+                    'error': str(e)
+                })
+
+        if failed_parts:
+            return {
+                'success': False,
+                'error': f"Failed to upload {len(failed_parts)} parts",
+                'failed_parts': failed_parts
+            }
+
+        return {'success': True}
+
+    def _check_status(self) -> UploadStatusResponse:
+        """Check upload status."""
+        if not self._session:
+            raise ValueError("Session not initialized")
+        status_command = CheckUploadStatusCommand(self._api_client, self._session.file_id)
+        return status_command.execute()
+
+    def _finalize_upload(self) -> UploadFinalizeResponse:
+        """Finalize the upload."""
+        if not self._session:
+            raise ValueError("Session not initialized")
+        finalize_command = FinalizeUploadCommand(self._api_client, self._session.file_id)
+        return finalize_command.execute()
+
+    def get_session_info(self) -> Optional[Dict[str, Any]]:
+        """Get current session information.
+        
+        Returns:
+            Dictionary with session details or None if not initialized
+        """
+        if not self._session:
+            return None
+
+        return {
+            'file_id': self._session.file_id,
+            'file_path': self._session.file_path,
+            'total_parts': self._session.total_parts,
+            'uploaded_parts': len(self._session.uploaded_parts),
+            'total_size': self._session.total_size,
+            'chunk_size': self._session.chunk_size,
+            'progress_percentage': self._session.get_progress_percentage(),
+            'is_complete': self._session.is_complete(),
+            'missing_parts': self._session.get_missing_parts()
+        }
+
+
+# ---------------------------------------------------------------------------
+# Abort Upload Command
+# ---------------------------------------------------------------------------
+
+
+class AbortUploadCommand(MultipartUploadCommand):
+    """Command for aborting a multipart upload session (discard all parts)."""
+
+    def __init__(self, api_client, file_id: str):
+        super().__init__(api_client)
+        self._file_id = file_id
+
+    def execute(self) -> Dict[str, Any]:  # returns plain dict. specific model not needed
+        """Abort upload session by POSTing fileId to multipart-upload/abort."""
+        payload = {"fileId": self._file_id}
+        return self._api_client.http_client.post("multipart-upload/abort", json_data=payload)