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

binalyze_air/models/{authentication.py → auth.py}

@@ -1,70 +1,70 @@
-"""
-Authentication-related data models for the Binalyze AIR SDK.
-"""
-
-from typing import Optional, List, Dict, Any
-from datetime import datetime
-from pydantic import Field
-
-from ..base import AIRBaseModel
-
-
-class UserProfile(AIRBaseModel):
-    """User profile information."""
-    name: Optional[str] = None
-    surname: Optional[str] = None
-    department: Optional[str] = None
-
-
-class UserRole(AIRBaseModel):
-    """User role information."""
-    id: Optional[str] = Field(alias="_id", default=None)
-    name: str
-    tag: str
-    created_at: Optional[str] = Field(alias="createdAt", default=None)
-    updated_at: Optional[str] = Field(alias="updatedAt", default=None)
-    created_by: Optional[str] = Field(alias="createdBy", default=None)
-    privilege_types: List[str] = Field(alias="privilegeTypes", default_factory=list)
-
-
-class User(AIRBaseModel):
-    """User model."""
-    
-    id: str = Field(alias="_id")
-    username: str
-    email: str
-    organization_ids: Optional[str] = Field(alias="organizationIds", default=None)  # Can be "ALL"
-    strategy: Optional[str] = None
-    profile: Optional[UserProfile] = None
-    privileges: List[str] = Field(default_factory=list)
-    roles: List[UserRole] = Field(default_factory=list)
-    tfa_enabled: bool = Field(alias="tfaEnabled", default=False)
-    created_at: Optional[str] = Field(alias="createdAt", default=None)
-    updated_at: Optional[str] = Field(alias="updatedAt", default=None)
-    has_password: bool = Field(alias="hasPassword", default=False)
-    photo: Optional[str] = None
-    groups: List[Any] = Field(default_factory=list)
-    user_flow_user_signature: Optional[str] = Field(alias="userFlowUserSignature", default=None)
-    user_flow_group_signature: Optional[str] = Field(alias="userFlowGroupSignature", default=None)
-
-
-class AuthStatus(AIRBaseModel):
-    """Authentication status model - matches actual API response."""
-    
-    # The API doesn't return authenticated field, we derive it from success
-    authenticated: bool = True  # Default to True since if we get a response, we're authenticated
-    user: Optional[User] = None
-    
-
-class LoginRequest(AIRBaseModel):
-    """Login request model."""
-    
-    username: str
-    password: str
-
-
-class LoginResponse(AIRBaseModel):
-    """Login response model."""
-    
-    access_token: str = Field(alias="accessToken")
+"""
+Auth-related data models for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+from pydantic import Field
+
+from ..base import AIRBaseModel
+
+
+class UserProfile(AIRBaseModel):
+    """User profile information."""
+    name: Optional[str] = None
+    surname: Optional[str] = None
+    department: Optional[str] = None
+
+
+class UserRole(AIRBaseModel):
+    """User role information."""
+    id: Optional[str] = Field(alias="_id", default=None)
+    name: str
+    tag: str
+    created_at: Optional[str] = Field(alias="createdAt", default=None)
+    updated_at: Optional[str] = Field(alias="updatedAt", default=None)
+    created_by: Optional[str] = Field(alias="createdBy", default=None)
+    privilege_types: List[str] = Field(alias="privilegeTypes", default_factory=list)
+
+
+class User(AIRBaseModel):
+    """User model."""
+    
+    id: str = Field(alias="_id")
+    username: str
+    email: str
+    organization_ids: Optional[str] = Field(alias="organizationIds", default=None)  # Can be "ALL"
+    strategy: Optional[str] = None
+    profile: Optional[UserProfile] = None
+    privileges: List[str] = Field(default_factory=list)
+    roles: List[UserRole] = Field(default_factory=list)
+    tfa_enabled: bool = Field(alias="tfaEnabled", default=False)
+    created_at: Optional[str] = Field(alias="createdAt", default=None)
+    updated_at: Optional[str] = Field(alias="updatedAt", default=None)
+    has_password: bool = Field(alias="hasPassword", default=False)
+    photo: Optional[str] = None
+    groups: List[Any] = Field(default_factory=list)
+    user_flow_user_signature: Optional[str] = Field(alias="userFlowUserSignature", default=None)
+    user_flow_group_signature: Optional[str] = Field(alias="userFlowGroupSignature", default=None)
+
+
+class AuthStatus(AIRBaseModel):
+    """Authentication status model - matches actual API response."""
+    
+    # The API doesn't return authenticated field, we derive it from success
+    authenticated: bool = True  # Default to True since if we get a response, we're authenticated
+    user: Optional[User] = None
+    
+
+class LoginRequest(AIRBaseModel):
+    """Login request model."""
+    
+    username: str
+    password: str
+
+
+class LoginResponse(AIRBaseModel):
+    """Login response model."""
+    
+    access_token: str = Field(alias="accessToken")
     refresh_token: str = Field(alias="refreshToken") 

binalyze_air/models/auto_asset_tags.py

@@ -1,117 +1,228 @@
-"""
-Auto Asset Tags-related data models for the Binalyze AIR SDK.
-"""
-
-from typing import Optional, List, Dict, Any
-from datetime import datetime
-from pydantic import Field
-from pydantic import ConfigDict
-
-from ..base import AIRBaseModel, Filter
-
-
-class AutoAssetTag(AIRBaseModel):
-    """Auto asset tag model."""
-    
-    id: str = Field(alias="_id")
-    tag: str
-    linux_conditions: Optional[Dict[str, Any]] = Field(alias="linuxConditions", default=None)
-    windows_conditions: Optional[Dict[str, Any]] = Field(alias="windowsConditions", default=None)
-    macos_conditions: Optional[Dict[str, Any]] = Field(alias="macosConditions", default=None)
-    organization_ids: Optional[List[int]] = Field(alias="organizationIds", default_factory=list)
-    created_at: Optional[datetime] = Field(alias="createdAt", default=None)
-    updated_at: Optional[datetime] = Field(alias="updatedAt", default=None)
-    created_by: Optional[str] = Field(alias="createdBy", default=None)
-    updated_by: Optional[str] = Field(alias="updatedBy", default=None)
-
-
-class CreateAutoAssetTagRequest(AIRBaseModel):
-    """Create auto asset tag request model."""
-    
-    model_config = ConfigDict(populate_by_name=True)
-    
-    tag: str
-    linux_conditions: Optional[Dict[str, Any]] = Field(default=None, alias="linuxConditions")
-    windows_conditions: Optional[Dict[str, Any]] = Field(default=None, alias="windowsConditions")
-    macos_conditions: Optional[Dict[str, Any]] = Field(default=None, alias="macosConditions")
-    organization_ids: List[int] = Field(default_factory=list, alias="organizationIds")
-
-
-class UpdateAutoAssetTagRequest(AIRBaseModel):
-    """Update auto asset tag request model."""
-    
-    model_config = ConfigDict(populate_by_name=True)
-    
-    tag: Optional[str] = None
-    linux_conditions: Optional[Dict[str, Any]] = Field(default=None, alias="linuxConditions")
-    windows_conditions: Optional[Dict[str, Any]] = Field(default=None, alias="windowsConditions")
-    macos_conditions: Optional[Dict[str, Any]] = Field(default=None, alias="macosConditions")
-
-
-class StartTaggingRequest(AIRBaseModel):
-    """Start tagging process request model."""
-    
-    filter: Dict[str, Any]
-    schedulerConfig: Dict[str, Any]
-
-
-class TaggingResult(AIRBaseModel):
-    """Tagging process result model."""
-    
-    taskId: str
-    message: str
-    processedTags: int
-    affectedAssets: int
-
-
-class TaggingTask(AIRBaseModel):
-    """Individual tagging task result from start tagging API."""
-    
-    task_id: str = Field(alias="_id")
-    name: str = Field(alias="name")
-
-
-class TaggingResponse(AIRBaseModel):
-    """Response from start tagging API containing list of tasks."""
-    
-    tasks: List[TaggingTask] = []
-    
-    @classmethod
-    def from_api_result(cls, result_list: List[Dict[str, Any]]) -> 'TaggingResponse':
-        """Create TaggingResponse from API result list."""
-        if not isinstance(result_list, list):
-            raise ValueError("API result must be a list")
-        
-        tasks = [TaggingTask(**task) for task in result_list]
-        return cls(tasks=tasks)
-    
-    @property
-    def task_count(self) -> int:
-        """Get the number of tasks created."""
-        return len(self.tasks)
-    
-    def get_task_ids(self) -> List[str]:
-        """Get list of all task IDs."""
-        return [task.task_id for task in self.tasks]
-
-
-class AutoAssetTagFilter(Filter):
-    """Filter for auto asset tag queries."""
-    
-    tag: Optional[str] = None
-    organization_ids: Optional[List[int]] = None
-    search_term: Optional[str] = None
-    
-    def to_params(self) -> Dict[str, Any]:
-        """Convert filter to API parameters with proper field name mapping."""
-        params = super().to_params()
-        
-        # Convert organization_ids to organizationIds for API compatibility
-        if "filter[organization_ids]" in params:
-            params["filter[organizationIds]"] = params.pop("filter[organization_ids]")
-        
-        # Convert search_term to searchTerm for API compatibility
-        if "filter[search_term]" in params:
-            params["filter[searchTerm]"] = params.pop("filter[search_term]")
-            
+"""
+Auto Asset Tags-related data models for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, List, Dict, Any, Union
+from datetime import datetime
+from pydantic import Field
+from pydantic import ConfigDict
+from enum import Enum
+
+from ..base import AIRBaseModel, Filter
+
+
+class ConditionField(str, Enum):
+    """Valid condition fields for auto asset tags."""
+    HOSTNAME = "hostname"
+    IP_ADDRESS = "ip-address"
+    SUBNET = "subnet"
+    OSQUERY = "osquery"
+    PROCESS = "process"
+    FILE = "file"
+    DIRECTORY = "directory"
+
+
+class ConditionOperator(str, Enum):
+    """Valid condition operators for auto asset tags."""
+    RUNNING = "running"
+    EXIST = "exist"
+    IS = "is"
+    CONTAINS = "contains"
+    STARTS_WITH = "starts-with"
+    ENDS_WITH = "ends-with"
+    IN_RANGE = "in-range"
+    HAS_RESULT = "has-result"
+    NOT_RUNNING = "not-running"
+    NOT_EXIST = "not-exist"
+    HAS_NO_RESULT = "has-no-result"
+
+
+class LogicalOperator(str, Enum):
+    """Valid logical operators for condition groups."""
+    AND = "and"
+    OR = "or"
+
+
+class AutoAssetTagCondition(AIRBaseModel):
+    """Individual condition for auto asset tag."""
+    
+    field: ConditionField
+    operator: ConditionOperator
+    value: str
+
+
+class AutoAssetTagConditionGroup(AIRBaseModel):
+    """Group of conditions with logical operator."""
+    
+    operator: LogicalOperator
+    conditions: List[AutoAssetTagCondition]
+
+
+class AutoAssetTagConditions(AIRBaseModel):
+    """Platform-specific conditions structure."""
+    
+    operator: LogicalOperator
+    conditions: List[AutoAssetTagConditionGroup]
+
+
+class AutoAssetTag(AIRBaseModel):
+    """Auto asset tag model - handles actual API response format."""
+    
+    id: str = Field(alias="_id")
+    tag: str
+    linuxConditions: Optional[Union[AutoAssetTagConditions, Dict[str, Any]]] = None
+    windowsConditions: Optional[Union[AutoAssetTagConditions, Dict[str, Any]]] = None
+    macosConditions: Optional[Union[AutoAssetTagConditions, Dict[str, Any]]] = None
+    organizationIds: Optional[List[int]] = Field(default_factory=list)
+    createdAt: Optional[datetime] = None
+    updatedAt: Optional[datetime] = None
+    createdBy: Optional[str] = None
+    updatedBy: Optional[str] = None
+    conditionIdCounter: Optional[int] = None  # API includes this field
+
+
+class CreateAutoAssetTagRequest(AIRBaseModel):
+    """Create auto asset tag request model - matches API specification exactly."""
+    
+    model_config = ConfigDict(populate_by_name=True)
+    
+    tag: str
+    linuxConditions: AutoAssetTagConditions  # Required by API
+    windowsConditions: AutoAssetTagConditions  # Required by API  
+    macosConditions: AutoAssetTagConditions  # Required by API
+    organizationIds: List[int] = Field(default_factory=list)
+    
+    def model_dump(self, **kwargs):
+        """Exclude None values from serialization to prevent API validation errors."""
+        # Set exclude_none=True if not explicitly set
+        if 'exclude_none' not in kwargs:
+            kwargs['exclude_none'] = True
+        return super().model_dump(**kwargs)
+
+
+class UpdateAutoAssetTagRequest(AIRBaseModel):
+    """Update auto asset tag request model."""
+    
+    model_config = ConfigDict(populate_by_name=True)
+    
+    tag: Optional[str] = None
+    linuxConditions: Optional[AutoAssetTagConditions] = None
+    windowsConditions: Optional[AutoAssetTagConditions] = None
+    macosConditions: Optional[AutoAssetTagConditions] = None
+    organizationIds: Optional[List[int]] = Field(default_factory=list)
+    
+    def model_dump(self, **kwargs):
+        """Exclude None values from serialization to prevent API validation errors."""
+        # Set exclude_none=True if not explicitly set
+        if 'exclude_none' not in kwargs:
+            kwargs['exclude_none'] = True
+        return super().model_dump(**kwargs)
+
+
+class StartTaggingSchedulerConfig(AIRBaseModel):
+    """Scheduler configuration for start tagging."""
+    
+    when: str  # "now" or "scheduled"
+    timezoneType: Optional[str] = None  # "asset" or "custom" - required if scheduled
+    timezone: Optional[str] = None  # required if scheduled and custom timezone
+    startDate: Optional[int] = None  # unix timestamp - required if scheduled
+    recurrence: Optional[str] = None  # "onetime", "daily", "weekly", "monthly" - required if scheduled
+    repeatEvery: Optional[int] = None  # required if scheduled and daily/monthly
+    repeatOnWeek: Optional[List[str]] = None  # required if scheduled and weekly
+    repeatOnMonth: Optional[int] = None  # required if scheduled and monthly
+    endRepeatType: Optional[str] = None  # "never", "date", "occurrence" - required if scheduled
+    endDate: Optional[int] = None  # unix timestamp - required if end repeat type is date
+    limit: Optional[int] = None  # required if end repeat type is occurrence
+
+
+class StartTaggingFilter(AIRBaseModel):
+    """Filter for start tagging process - matches API specification exactly."""
+    
+    organizationIds: List[int]  # Required
+    searchTerm: Optional[str] = ""
+    name: Optional[str] = ""
+    ipAddress: Optional[str] = ""
+    groupId: Optional[str] = ""
+    groupFullPath: Optional[str] = ""
+    label: Optional[str] = ""
+    lastSeen: Optional[str] = ""
+    managedStatus: List[str] = []  # "unmanaged", "managed", "off-network"
+    isolationStatus: List[str] = []  # "isolating", "isolated", "unisolating", "unisolated"
+    platform: List[str] = []  # "windows", "linux", "darwin"
+    issue: Optional[str] = ""  # "unreachable", "old-version", "update-required"
+    onlineStatus: List[str] = []  # "online", "offline"
+    tags: List[str] = []
+    version: Optional[str] = ""
+    policy: Optional[str] = ""
+    includedEndpointIds: List[str] = []
+    excludedEndpointIds: List[str] = []
+    caseId: Optional[str] = None
+
+
+class StartTaggingRequest(AIRBaseModel):
+    """Start tagging process request model - matches API specification exactly."""
+    
+    filter: StartTaggingFilter
+    schedulerConfig: StartTaggingSchedulerConfig
+
+
+class TaggingResult(AIRBaseModel):
+    """Tagging process result model."""
+    
+    taskId: str
+    message: str
+    processedTags: int
+    affectedAssets: int
+
+
+class TaggingTask(AIRBaseModel):
+    """Individual tagging task result from start tagging API."""
+    
+    task_id: str = Field(alias="_id")
+    name: str = Field(alias="name")
+
+
+class TaggingResponse(AIRBaseModel):
+    """Response from start tagging API containing list of tasks."""
+    
+    tasks: List[TaggingTask] = []
+    
+    @classmethod
+    def from_api_result(cls, result_list: List[Dict[str, Any]]) -> 'TaggingResponse':
+        """Create TaggingResponse from API result list."""
+        if not isinstance(result_list, list):
+            raise ValueError("API result must be a list")
+        
+        tasks = [TaggingTask(**task) for task in result_list]
+        return cls(tasks=tasks)
+    
+    @property
+    def task_count(self) -> int:
+        """Get the number of tasks created."""
+        return len(self.tasks)
+    
+    def get_task_ids(self) -> List[str]:
+        """Get list of all task IDs."""
+        return [task.task_id for task in self.tasks]
+
+
+class AutoAssetTagFilter(Filter):
+    """Filter for auto asset tag queries."""
+    
+    tag: Optional[str] = None
+    organization_ids: Optional[List[int]] = None
+    search_term: Optional[str] = None
+    
+    def to_params(self) -> Dict[str, Any]:
+        """Convert filter to API parameters with proper field name mapping."""
+        params = super().to_params()
+        
+        # Convert organization_ids to organizationIds for API compatibility
+        if "filter[organization_ids]" in params:
+            params["filter[organizationIds]"] = params.pop("filter[organization_ids]")
+        
+        # Convert search_term to searchTerm for API compatibility
+        if "filter[search_term]" in params:
+            params["filter[searchTerm]"] = params.pop("filter[search_term]")
+            
         return params 

binalyze_air/models/backup.py

@@ -0,0 +1,138 @@
+"""
+Backup models for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+from enum import Enum
+from pydantic import Field
+
+from ..base import AIRBaseModel
+
+
+class BackupStatus(str, Enum):
+    """Backup status enumeration."""
+    IN_PROGRESS = "in-progress"
+    SUCCEEDED = "succeeded"
+    UPLOADING = "uploading"
+    FAILED = "failed"
+    QUEUED = "queued"
+
+
+class BackupSource(str, Enum):
+    """Backup source enumeration."""
+    USER = "user"
+    SCHEDULER = "scheduler"
+
+
+class BackupLocation(str, Enum):
+    """Backup location enumeration."""
+    LOCAL = "local"
+    SFTP = "sftp"
+    S3 = "s3"
+
+
+class Backup(AIRBaseModel):
+    """Backup model."""
+    
+    id: str = Field(alias="_id")
+    location: BackupLocation
+    status: BackupStatus
+    size: Optional[int] = None
+    source: BackupSource
+    username: str
+    to: str  # Backup file path/location
+    stats: Dict[str, Any] = {}
+    start_date: datetime = Field(alias="startDate")
+    end_date: Optional[datetime] = Field(default=None, alias="endDate")
+    created_at: datetime = Field(alias="createdAt")
+    updated_at: datetime = Field(alias="updatedAt")
+
+
+class BackupFilter(AIRBaseModel):
+    """Filter parameters for backup history."""
+    
+    page_size: Optional[int] = Field(default=10, alias="pageSize")
+    page_number: Optional[int] = Field(default=1, alias="pageNumber")
+    sort_type: Optional[str] = Field(default="DESC", alias="sortType")  # ASC or DESC
+    sort_by: Optional[str] = Field(default="createdAt", alias="sortBy")  # source, username, status, startDate, createdAt
+    search_term: Optional[str] = Field(default=None, alias="searchTerm")
+    username: Optional[str] = None
+    source: Optional[BackupSource] = None
+    status: Optional[BackupStatus] = None
+    start_date: Optional[datetime] = Field(default=None, alias="startDate")
+    end_date: Optional[datetime] = Field(default=None, alias="endDate")
+    location: Optional[BackupLocation] = None
+
+
+class BackupHistoryResponse(AIRBaseModel):
+    """Paginated response for backup history."""
+    
+    entities: List[Backup]
+    filters: List[Dict[str, Any]]
+    sortables: List[str]
+    total_entity_count: int = Field(alias="totalEntityCount")
+    current_page: int = Field(alias="currentPage")
+    page_size: int = Field(alias="pageSize")
+    previous_page: int = Field(alias="previousPage")
+    total_page_count: int = Field(alias="totalPageCount")
+    next_page: int = Field(alias="nextPage")
+
+
+class BackupNowRequest(AIRBaseModel):
+    """Request model for creating an immediate backup."""
+    
+    # The API appears to use filters for backup scope
+    # Based on the prerequest script, it uses includedEndpointIds
+    include_endpoint_ids: Optional[List[str]] = Field(default=None, alias="includedEndpointIds")
+    exclude_endpoint_ids: Optional[List[str]] = Field(default=None, alias="excludedEndpointIds")
+    organization_ids: Optional[List[int]] = Field(default=None, alias="organizationIds")
+    backup_location: Optional[BackupLocation] = BackupLocation.LOCAL
+
+
+class BackupConfig(AIRBaseModel):
+    """Backup configuration model."""
+    
+    enabled: bool = True
+    schedule: Optional[str] = None  # Cron expression
+    location: BackupLocation = BackupLocation.LOCAL
+    retention_days: Optional[int] = Field(default=30, alias="retentionDays")
+    compression: bool = True
+    encryption: bool = False
+    
+    # SFTP configuration
+    sftp_host: Optional[str] = Field(default=None, alias="sftpHost")
+    sftp_port: Optional[int] = Field(default=22, alias="sftpPort")
+    sftp_username: Optional[str] = Field(default=None, alias="sftpUsername")
+    sftp_password: Optional[str] = Field(default=None, alias="sftpPassword")
+    sftp_path: Optional[str] = Field(default=None, alias="sftpPath")
+    
+    # S3 configuration
+    s3_bucket: Optional[str] = Field(default=None, alias="s3Bucket")
+    s3_region: Optional[str] = Field(default=None, alias="s3Region")
+    s3_access_key: Optional[str] = Field(default=None, alias="s3AccessKey")
+    s3_secret_key: Optional[str] = Field(default=None, alias="s3SecretKey")
+    s3_path: Optional[str] = Field(default=None, alias="s3Path")
+
+
+class BackupStats(AIRBaseModel):
+    """Backup statistics model."""
+    
+    total_backups: int = Field(default=0, alias="totalBackups")
+    successful_backups: int = Field(default=0, alias="successfulBackups")
+    failed_backups: int = Field(default=0, alias="failedBackups")
+    in_progress_backups: int = Field(default=0, alias="inProgressBackups")
+    total_size_bytes: int = Field(default=0, alias="totalSizeBytes")
+    average_backup_time_minutes: float = Field(default=0.0, alias="averageBackupTimeMinutes")
+    last_backup_date: Optional[datetime] = Field(default=None, alias="lastBackupDate")
+    next_scheduled_backup: Optional[datetime] = Field(default=None, alias="nextScheduledBackup")
+
+
+class BackupDownloadInfo(AIRBaseModel):
+    """Backup download information model."""
+    
+    backup_id: str = Field(alias="backupId")
+    filename: str
+    size_bytes: int = Field(alias="sizeBytes")
+    download_url: str = Field(alias="downloadUrl")
+    expires_at: Optional[datetime] = Field(default=None, alias="expiresAt")