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

binalyze_air/models/license.py

@@ -0,0 +1,150 @@
+"""License models for Binalyze AIR SDK."""
+
+from typing import Optional
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class License:
+    """Represents a license in the Binalyze AIR system.
+    
+    Attributes:
+        key: The license key identifier
+        is_locked_down: Whether the license is in locked down mode
+        activated_on: When the license was activated
+        period_days: Total license period in days
+        remaining_days: Remaining days until expiration
+        expires_on: License expiration date
+        device_count: Current number of devices
+        max_device_count: Maximum allowed devices
+        client_count: Current number of clients
+        max_client_count: Maximum allowed clients
+        model: License model type
+        is_lifetime: Whether this is a lifetime license
+        customer_name: Name of the customer
+    """
+    key: str
+    is_locked_down: bool
+    activated_on: datetime
+    period_days: int
+    remaining_days: int
+    expires_on: datetime
+    device_count: int
+    max_device_count: int
+    client_count: int
+    max_client_count: int
+    model: int
+    is_lifetime: bool
+    customer_name: str
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'License':
+        """Create License instance from dictionary data.
+        
+        Args:
+            data: Dictionary containing license data
+            
+        Returns:
+            License instance
+        """
+        return cls(
+            key=data.get('key', ''),
+            is_locked_down=data.get('isLockedDown', False),
+            activated_on=datetime.fromisoformat(
+                data.get('activatedOn', '').replace('Z', '+00:00')
+            ) if data.get('activatedOn') else datetime.now(),
+            period_days=data.get('periodDays', 0),
+            remaining_days=data.get('remainingDays', 0),
+            expires_on=datetime.fromisoformat(
+                data.get('expiresOn', '').replace('Z', '+00:00')
+            ) if data.get('expiresOn') else datetime.now(),
+            device_count=data.get('deviceCount', 0),
+            max_device_count=data.get('maxDeviceCount', 0),
+            client_count=data.get('clientCount', 0),
+            max_client_count=data.get('maxClientCount', 0),
+            model=data.get('model', 0),
+            is_lifetime=data.get('isLifetime', False),
+            customer_name=data.get('customerName', '')
+        )
+
+    def to_dict(self) -> dict:
+        """Convert License instance to dictionary.
+        
+        Returns:
+            Dictionary representation of the license
+        """
+        return {
+            'key': self.key,
+            'isLockedDown': self.is_locked_down,
+            'activatedOn': self.activated_on.isoformat(),
+            'periodDays': self.period_days,
+            'remainingDays': self.remaining_days,
+            'expiresOn': self.expires_on.isoformat(),
+            'deviceCount': self.device_count,
+            'maxDeviceCount': self.max_device_count,
+            'clientCount': self.client_count,
+            'maxClientCount': self.max_client_count,
+            'model': self.model,
+            'isLifetime': self.is_lifetime,
+            'customerName': self.customer_name
+        }
+
+    def is_expired(self) -> bool:
+        """Check if the license is expired.
+        
+        Returns:
+            True if license is expired, False otherwise
+        """
+        return self.remaining_days <= 0
+
+    def is_near_expiry(self, days_threshold: int = 30) -> bool:
+        """Check if license is near expiry.
+        
+        Args:
+            days_threshold: Number of days to consider as near expiry
+            
+        Returns:
+            True if license expires within threshold days
+        """
+        return self.remaining_days <= days_threshold
+
+    def get_usage_percentage(self) -> dict:
+        """Get usage percentages for devices and clients.
+        
+        Returns:
+            Dictionary with device and client usage percentages
+        """
+        device_usage = (
+            (self.device_count / self.max_device_count * 100) 
+            if self.max_device_count > 0 else 0
+        )
+        client_usage = (
+            (self.client_count / self.max_client_count * 100) 
+            if self.max_client_count > 0 else 0
+        )
+        
+        return {
+            'device_usage_percent': round(device_usage, 2),
+            'client_usage_percent': round(client_usage, 2)
+        }
+
+
+@dataclass
+class LicenseUpdateRequest:
+    """Request model for updating license.
+    
+    Attributes:
+        license_key: The new license key to set
+    """
+    license_key: str
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for API request.
+        
+        Returns:
+            Dictionary representation for API
+        """
+        return {
+            'licenseKey': self.license_key
+        } 

binalyze_air/models/logger.py

@@ -0,0 +1,83 @@
+"""Logger models for Binalyze AIR SDK."""
+
+from typing import Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class LogDownloadRequest:
+    """Request model for downloading logs.
+    
+    Attributes:
+        latest_log_file: Whether to download only the latest log file
+    """
+    latest_log_file: bool = False
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for API request.
+        
+        Returns:
+            Dictionary representation for API
+        """
+        return {
+            'latestLogFile': self.latest_log_file
+        }
+
+
+@dataclass
+class LogDownloadResponse:
+    """Response model for log download operation.
+    
+    Attributes:
+        content: The downloaded log content (binary data)
+        filename: Suggested filename for the downloaded logs
+        content_type: MIME type of the downloaded content
+        size: Size of the downloaded content in bytes
+    """
+    content: bytes
+    filename: Optional[str] = None
+    content_type: Optional[str] = None
+    size: Optional[int] = None
+
+    @classmethod
+    def from_response(cls, response_data: bytes, headers: Optional[dict] = None) -> 'LogDownloadResponse':
+        """Create LogDownloadResponse from HTTP response.
+        
+        Args:
+            response_data: Binary response data
+            headers: HTTP response headers
+            
+        Returns:
+            LogDownloadResponse instance
+        """
+        if headers is None:
+            headers = {}
+        
+        # Extract filename from Content-Disposition header if available
+        filename = None
+        content_disposition = headers.get('Content-Disposition', '')
+        if 'filename=' in content_disposition:
+            filename = content_disposition.split('filename=')[1].strip('"')
+        
+        return cls(
+            content=response_data,
+            filename=filename or 'logs.zip',
+            content_type=headers.get('Content-Type', 'application/zip'),
+            size=len(response_data) if response_data else 0
+        )
+
+    def save_to_file(self, filepath: str) -> bool:
+        """Save downloaded logs to a file.
+        
+        Args:
+            filepath: Path where to save the log file
+            
+        Returns:
+            True if saved successfully, False otherwise
+        """
+        try:
+            with open(filepath, 'wb') as f:
+                f.write(self.content)
+            return True
+        except Exception:
+            return False 

binalyze_air/models/multipart_upload.py

@@ -0,0 +1,352 @@
+"""Multipart Upload models for Binalyze AIR SDK."""
+
+from typing import Optional, List, Dict, Any, BinaryIO
+from dataclasses import dataclass
+from pathlib import Path
+import hashlib
+import os
+
+
+@dataclass
+class UploadInitializeRequest:
+    """Request model for initializing a multipart upload.
+    
+    This model represents the request to start a new multipart upload session.
+    No parameters are typically required for initialization.
+    """
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for API request.
+        
+        Returns:
+            Dictionary representation for API (typically empty)
+        """
+        return {}
+
+
+@dataclass
+class UploadInitializeResponse:
+    """Response model for upload initialization.
+    
+    Attributes:
+        file_id: Unique identifier for the upload session
+        success: Whether the initialization was successful
+    """
+    file_id: str
+    success: bool = True
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'UploadInitializeResponse':
+        """Create UploadInitializeResponse from API response.
+        
+        Args:
+            data: API response dictionary
+            
+        Returns:
+            UploadInitializeResponse instance
+        """
+        result = data.get('result', {})
+        return cls(
+            file_id=result.get('fileId', ''),
+            success=data.get('success', False)
+        )
+
+
+@dataclass
+class UploadPartRequest:
+    """Request model for uploading a file part.
+    
+    Attributes:
+        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
+    """
+    file_id: str
+    part_number: int
+    file_data: bytes
+    filename: Optional[str] = None
+
+    def to_form_data(self) -> Dict[str, Any]:
+        """Convert to form data for multipart file upload.
+        
+        Returns:
+            Dictionary with form data fields
+        """
+        return {
+            'fileId': self.file_id,
+            'partNumber': str(self.part_number),
+            'file': self.file_data
+        }
+
+    def get_part_size(self) -> int:
+        """Get the size of this part in bytes.
+        
+        Returns:
+            Size of the file data in bytes
+        """
+        return len(self.file_data)
+
+    def get_part_hash(self) -> str:
+        """Generate MD5 hash of the part data for integrity checking.
+        
+        Returns:
+            MD5 hash of the part data
+        """
+        return hashlib.md5(self.file_data).hexdigest()
+
+
+@dataclass
+class UploadPartResponse:
+    """Response model for file part upload.
+    
+    Attributes:
+        success: Whether the part upload was successful
+        part_number: The part number that was uploaded
+        error_message: Error message if upload failed
+    """
+    success: bool
+    part_number: int
+    error_message: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any], part_number: int) -> 'UploadPartResponse':
+        """Create UploadPartResponse from API response.
+        
+        Args:
+            data: API response dictionary
+            part_number: The part number that was uploaded
+            
+        Returns:
+            UploadPartResponse instance
+        """
+        success = data.get('success', False)
+        error_message = None
+        if not success and data.get('errors'):
+            error_message = '; '.join(data['errors'])
+        
+        return cls(
+            success=success,
+            part_number=part_number,
+            error_message=error_message
+        )
+
+
+@dataclass
+class UploadStatusRequest:
+    """Request model for checking upload status.
+    
+    Attributes:
+        file_id: Upload session identifier to check
+    """
+    file_id: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for API request.
+        
+        Returns:
+            Dictionary with query parameters
+        """
+        return {'fileId': self.file_id}
+
+
+@dataclass
+class UploadStatusResponse:
+    """Response model for upload status check.
+    
+    Attributes:
+        ready: Whether the upload is ready to be finalized
+        file_id: Upload session identifier
+        success: Whether the status check was successful
+    """
+    ready: bool
+    file_id: str
+    success: bool = True
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any], file_id: str) -> 'UploadStatusResponse':
+        """Create UploadStatusResponse from API response.
+        
+        Args:
+            data: API response dictionary
+            file_id: Upload session identifier
+            
+        Returns:
+            UploadStatusResponse instance
+        """
+        result = data.get('result', {})
+        return cls(
+            ready=result.get('ready', False),
+            file_id=file_id,
+            success=data.get('success', False)
+        )
+
+
+@dataclass
+class UploadFinalizeRequest:
+    """Request model for finalizing a multipart upload.
+    
+    Attributes:
+        file_id: Upload session identifier to finalize
+    """
+    file_id: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for API request.
+        
+        Returns:
+            Dictionary representation for API
+        """
+        return {'fileId': self.file_id}
+
+
+@dataclass
+class UploadFinalizeResponse:
+    """Response model for upload finalization.
+    
+    Attributes:
+        success: Whether the finalization was successful
+        file_id: Upload session identifier
+        error_message: Error message if finalization failed
+    """
+    success: bool
+    file_id: str
+    error_message: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any], file_id: str) -> 'UploadFinalizeResponse':
+        """Create UploadFinalizeResponse from API response.
+        
+        Args:
+            data: API response dictionary
+            file_id: Upload session identifier
+            
+        Returns:
+            UploadFinalizeResponse instance
+        """
+        success = data.get('success', False)
+        error_message = None
+        if not success and data.get('errors'):
+            error_message = '; '.join(data['errors'])
+        
+        return cls(
+            success=success,
+            file_id=file_id,
+            error_message=error_message
+        )
+
+
+@dataclass
+class MultipartUploadSession:
+    """Complete multipart upload session information.
+    
+    Attributes:
+        file_id: Upload session identifier
+        total_parts: Total number of parts to upload
+        uploaded_parts: List of successfully uploaded part numbers
+        file_path: Path to the file being uploaded
+        chunk_size: Size of each chunk in bytes
+        total_size: Total size of the file in bytes
+    """
+    file_id: str
+    total_parts: int
+    uploaded_parts: List[int]
+    file_path: Optional[str] = None
+    chunk_size: int = 5 * 1024 * 1024  # 5MB default
+    total_size: int = 0
+
+    def is_complete(self) -> bool:
+        """Check if all parts have been uploaded.
+        
+        Returns:
+            True if all parts are uploaded, False otherwise
+        """
+        return len(self.uploaded_parts) == self.total_parts
+
+    def get_progress_percentage(self) -> float:
+        """Get upload progress as percentage.
+        
+        Returns:
+            Progress percentage (0.0 to 100.0)
+        """
+        if self.total_parts == 0:
+            return 0.0
+        return (len(self.uploaded_parts) / self.total_parts) * 100.0
+
+    def get_missing_parts(self) -> List[int]:
+        """Get list of part numbers that still need to be uploaded.
+        
+        Returns:
+            List of missing part numbers
+        """
+        all_parts = set(range(1, self.total_parts + 1))
+        uploaded_set = set(self.uploaded_parts)
+        return sorted(list(all_parts - uploaded_set))
+
+    def add_uploaded_part(self, part_number: int) -> None:
+        """Mark a part as successfully uploaded.
+        
+        Args:
+            part_number: Part number that was uploaded
+        """
+        if part_number not in self.uploaded_parts:
+            self.uploaded_parts.append(part_number)
+            self.uploaded_parts.sort()
+
+
+class FileChunker:
+    """Utility class for splitting files into chunks for multipart upload."""
+    
+    @staticmethod
+    def calculate_parts(file_size: int, chunk_size: int = 5 * 1024 * 1024) -> int:
+        """Calculate number of parts needed for a file.
+        
+        Args:
+            file_size: Size of the file in bytes
+            chunk_size: Size of each chunk in bytes
+            
+        Returns:
+            Number of parts needed
+        """
+        return (file_size + chunk_size - 1) // chunk_size
+
+    @staticmethod
+    def read_chunk(file_path: str, part_number: int, chunk_size: int = 5 * 1024 * 1024) -> bytes:
+        """Read a specific chunk from a file.
+        
+        Args:
+            file_path: Path to the file
+            part_number: Part number to read (1-based)
+            chunk_size: Size of each chunk in bytes
+            
+        Returns:
+            Binary data for the specified chunk
+        """
+        offset = (part_number - 1) * chunk_size
+        
+        with open(file_path, 'rb') as f:
+            f.seek(offset)
+            return f.read(chunk_size)
+
+    @staticmethod
+    def create_session_from_file(file_path: str, chunk_size: int = 5 * 1024 * 1024) -> MultipartUploadSession:
+        """Create an upload session from a file path.
+        
+        Args:
+            file_path: Path to the file to upload
+            chunk_size: Size of each chunk in bytes
+            
+        Returns:
+            MultipartUploadSession configured for the file
+        """
+        file_size = os.path.getsize(file_path)
+        total_parts = FileChunker.calculate_parts(file_size, chunk_size)
+        
+        return MultipartUploadSession(
+            file_id='',  # Will be set after initialization
+            total_parts=total_parts,
+            uploaded_parts=[],
+            file_path=file_path,
+            chunk_size=chunk_size,
+            total_size=file_size
+        )