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

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

@@ -1,56 +1,56 @@
-"""
-Authentication-related queries for the Binalyze AIR SDK.
-"""
-
-from ..base import Query
-from ..models.authentication import AuthStatus, User, UserProfile, UserRole
-from ..http_client import HTTPClient
-
-
-class CheckAuthStatusQuery(Query[AuthStatus]):
-    """Query to check authentication status."""
-    
-    def __init__(self, http_client: HTTPClient):
-        self.http_client = http_client
-    
-    def execute(self) -> AuthStatus:
-        """Execute the auth status check query."""
-        # Try different endpoint patterns since auth endpoints may vary
-        endpoints_to_try = [
-            "auth/check",  # Original pattern
-            # Note: /api/public/auth/check may not exist in all API versions
-            # The HTTP client will add the api_prefix automatically
-        ]
-        
-        last_exception = None
-        
-        for endpoint in endpoints_to_try:
-            try:
-                response = self.http_client.get(endpoint)
-                
-                if response.get("success"):
-                    result = response.get("result", {})
-                    
-                    # Use Pydantic to parse the User data with proper field aliasing
-                    user = User.model_validate(result)
-                    return AuthStatus(authenticated=True, user=user)
-                else:
-                    # Return unauthenticated status for failed responses
-                    return AuthStatus(authenticated=False)
-                    
-            except Exception as e:
-                last_exception = e
-                continue  # Try next endpoint
-        
-        # If all endpoints failed, check if it's because auth features are disabled
-        if last_exception and "auth-management-via-api" in str(last_exception):
-            # Auth features are disabled - this is a configuration issue, not authentication failure
-            # We can't determine auth status, so return a special state
-            return AuthStatus(authenticated=False)
-        
-        # If we get here, all endpoints failed
-        if last_exception:
-            raise last_exception
-        
-        # Return unauthenticated status as fallback
+"""
+Auth-related queries for the Binalyze AIR SDK.
+"""
+
+from ..base import Query
+from ..models.auth import AuthStatus, User, UserProfile, UserRole
+from ..http_client import HTTPClient
+
+
+class CheckAuthStatusQuery(Query[AuthStatus]):
+    """Query to check authentication status."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    def execute(self) -> AuthStatus:
+        """Execute the auth status check query."""
+        # Try different endpoint patterns since auth endpoints may vary
+        endpoints_to_try = [
+            "auth/check",  # Original pattern
+            # Note: /api/public/auth/check may not exist in all API versions
+            # The HTTP client will add the api_prefix automatically
+        ]
+        
+        last_exception = None
+        
+        for endpoint in endpoints_to_try:
+            try:
+                response = self.http_client.get(endpoint)
+                
+                if response.get("success"):
+                    result = response.get("result", {})
+                    
+                    # Use Pydantic to parse the User data with proper field aliasing
+                    user = User.model_validate(result)
+                    return AuthStatus(authenticated=True, user=user)
+                else:
+                    # Return unauthenticated status for failed responses
+                    return AuthStatus(authenticated=False)
+                    
+            except Exception as e:
+                last_exception = e
+                continue  # Try next endpoint
+        
+        # If all endpoints failed, check if it's because auth features are disabled
+        if last_exception and "auth-management-via-api" in str(last_exception):
+            # Auth features are disabled - this is a configuration issue, not authentication failure
+            # We can't determine auth status, so return a special state
+            return AuthStatus(authenticated=False)
+        
+        # If we get here, all endpoints failed
+        if last_exception:
+            raise last_exception
+        
+        # Return unauthenticated status as fallback
         return AuthStatus(authenticated=False) 

binalyze_air/queries/auto_asset_tags.py

@@ -1,60 +1,60 @@
-"""
-Auto Asset Tags-related queries for the Binalyze AIR SDK.
-"""
-
-from typing import List, Optional
-
-from ..base import Query
-from ..models.auto_asset_tags import AutoAssetTag, AutoAssetTagFilter
-from ..http_client import HTTPClient
-
-
-class ListAutoAssetTagsQuery(Query[List[AutoAssetTag]]):
-    """Query to list auto asset tags."""
-    
-    def __init__(self, http_client: HTTPClient, filter_params: Optional[AutoAssetTagFilter] = None):
-        self.http_client = http_client
-        self.filter_params = filter_params
-    
-    def execute(self) -> List[AutoAssetTag]:
-        """Execute the list auto asset tags query."""
-        params = {}
-        
-        # Add default organization filtering if no filter is provided
-        if self.filter_params:
-            params = self.filter_params.to_params()
-        else:
-            # Default organization filtering - critical for the API to work
-            params["filter[organizationIds]"] = "0"
-        
-        # Ensure organization filtering is always present
-        if "filter[organizationIds]" not in params and "filter[organizationId]" not in params:
-            params["filter[organizationIds]"] = "0"
-        
-        response = self.http_client.get("auto-asset-tag", params=params)
-        
-        if response.get("success"):
-            tags_data = response.get("result", {}).get("entities", [])
-            # Use Pydantic parsing with proper field aliasing
-            return [AutoAssetTag.model_validate(tag_data) for tag_data in tags_data]
-        
-        return []
-
-
-class GetAutoAssetTagQuery(Query[AutoAssetTag]):
-    """Query to get auto asset tag by ID."""
-    
-    def __init__(self, http_client: HTTPClient, tag_id: str):
-        self.http_client = http_client
-        self.tag_id = tag_id
-    
-    def execute(self) -> AutoAssetTag:
-        """Execute the get auto asset tag query."""
-        response = self.http_client.get(f"auto-asset-tag/{self.tag_id}")
-        
-        if response.get("success"):
-            tag_data = response.get("result", {})
-            # Use Pydantic parsing with proper field aliasing
-            return AutoAssetTag.model_validate(tag_data)
-        
+"""
+Auto Asset Tags-related queries for the Binalyze AIR SDK.
+"""
+
+from typing import List, Optional
+
+from ..base import Query
+from ..models.auto_asset_tags import AutoAssetTag, AutoAssetTagFilter
+from ..http_client import HTTPClient
+
+
+class ListAutoAssetTagsQuery(Query[List[AutoAssetTag]]):
+    """Query to list auto asset tags."""
+    
+    def __init__(self, http_client: HTTPClient, filter_params: Optional[AutoAssetTagFilter] = None):
+        self.http_client = http_client
+        self.filter_params = filter_params
+    
+    def execute(self) -> List[AutoAssetTag]:
+        """Execute the list auto asset tags query."""
+        params = {}
+        
+        # Add default organization filtering if no filter is provided
+        if self.filter_params:
+            params = self.filter_params.to_params()
+        else:
+            # Default organization filtering - critical for the API to work
+            params["filter[organizationIds]"] = "0"
+        
+        # Ensure organization filtering is always present
+        if "filter[organizationIds]" not in params and "filter[organizationId]" not in params:
+            params["filter[organizationIds]"] = "0"
+        
+        response = self.http_client.get("auto-asset-tag", params=params)
+        
+        if response.get("success"):
+            tags_data = response.get("result", {}).get("entities", [])
+            # Use Pydantic parsing with proper field aliasing
+            return [AutoAssetTag.model_validate(tag_data) for tag_data in tags_data]
+        
+        return []
+
+
+class GetAutoAssetTagQuery(Query[AutoAssetTag]):
+    """Query to get auto asset tag by ID."""
+    
+    def __init__(self, http_client: HTTPClient, tag_id: str):
+        self.http_client = http_client
+        self.tag_id = tag_id
+    
+    def execute(self) -> AutoAssetTag:
+        """Execute the get auto asset tag query."""
+        response = self.http_client.get(f"auto-asset-tag/{self.tag_id}")
+        
+        if response.get("success"):
+            tag_data = response.get("result", {})
+            # Use Pydantic parsing with proper field aliasing
+            return AutoAssetTag.model_validate(tag_data)
+        
         raise Exception(f"Auto asset tag not found: {self.tag_id}") 

binalyze_air/queries/backup.py

@@ -0,0 +1,66 @@
+"""
+Backup queries for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, Dict, Any
+
+from ..base import Query
+from ..models.backup import (
+    BackupHistoryResponse, BackupFilter, BackupDownloadInfo
+)
+from ..http_client import HTTPClient
+
+
+class GetBackupHistoryQuery(Query[BackupHistoryResponse]):
+    """Query to get backup history with optional filtering."""
+    
+    def __init__(self, http_client: HTTPClient, filter_params: Optional[BackupFilter] = None):
+        self.http_client = http_client
+        self.filter_params = filter_params or BackupFilter()
+    
+    def execute(self) -> BackupHistoryResponse:
+        """Execute the query."""
+        params = {}
+        
+        # Add pagination parameters
+        if self.filter_params.page_size is not None:
+            params["pageSize"] = self.filter_params.page_size
+        if self.filter_params.page_number is not None:
+            params["pageNumber"] = self.filter_params.page_number
+        if self.filter_params.sort_type is not None:
+            params["sortType"] = self.filter_params.sort_type
+        if self.filter_params.sort_by is not None:
+            params["sortBy"] = self.filter_params.sort_by
+        
+        # Add filter parameters
+        if self.filter_params.search_term is not None:
+            params["filter[searchTerm]"] = self.filter_params.search_term
+        if self.filter_params.username is not None:
+            params["filter[username]"] = self.filter_params.username
+        if self.filter_params.source is not None:
+            params["filter[source]"] = self.filter_params.source
+        if self.filter_params.status is not None:
+            params["filter[status]"] = self.filter_params.status
+        if self.filter_params.start_date is not None:
+            params["filter[startDate]"] = self.filter_params.start_date.isoformat()
+        if self.filter_params.end_date is not None:
+            params["filter[endDate]"] = self.filter_params.end_date.isoformat()
+        if self.filter_params.location is not None:
+            params["filter[location]"] = self.filter_params.location
+        
+        response = self.http_client.get("backup/history", params=params)
+        return BackupHistoryResponse(**response["result"])
+
+
+class GetBackupDownloadQuery(Query[Dict[str, Any]]):
+    """Query to get backup download information."""
+    
+    def __init__(self, http_client: HTTPClient, backup_id: str):
+        self.http_client = http_client
+        self.backup_id = backup_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the query."""
+        # This endpoint typically returns a file download or download URL
+        response = self.http_client.get(f"backup/{self.backup_id}/download")
+        return response 

binalyze_air/queries/baseline.py

@@ -1,185 +1,21 @@
-"""
-Baseline-related queries for the Binalyze AIR SDK.
-"""
-
-from typing import List, Optional
-
-from ..base import Query
-from ..models.baseline import (
-    Baseline, BaselineProfile, BaselineComparison, BaselineChange,
-    BaselineSchedule, BaselineFilter, BaselineStatus, ComparisonStatus
-)
-from ..http_client import HTTPClient
-
-
-class ListBaselinesQuery(Query[List[Baseline]]):
-    """Query to list baselines with optional filtering."""
-    
-    def __init__(self, http_client: HTTPClient, filter_params: Optional[BaselineFilter] = None, organization_ids: Optional[List[int]] = None):
-        self.http_client = http_client
-        self.filter_params = filter_params or BaselineFilter()
-        self.organization_ids = organization_ids or [0]
-    
-    def execute(self) -> List[Baseline]:
-        """Execute the query to list baselines."""
-        params = {}
-        if self.filter_params:
-            params = self.filter_params.model_dump(exclude_none=True)
-        
-        response = self.http_client.get("baselines", params=params)
-        
-        if response.get("success"):
-            baselines_data = response.get("result", {}).get("entities", [])
-            # Use Pydantic parsing with proper field aliasing
-            return [Baseline.model_validate(baseline_data) for baseline_data in baselines_data]
-        
-        return []
-
-
-class GetBaselineQuery(Query[Baseline]):
-    """Query to get a specific baseline by ID."""
-    
-    def __init__(self, http_client: HTTPClient, baseline_id: str):
-        self.http_client = http_client
-        self.baseline_id = baseline_id
-    
-    def execute(self) -> Baseline:
-        """Execute the query to get baseline details."""
-        response = self.http_client.get(f"baselines/{self.baseline_id}")
-        
-        if response.get("success"):
-            baseline_data = response.get("result", {})
-            # Use Pydantic parsing with proper field aliasing
-            return Baseline.model_validate(baseline_data)
-        
-        raise Exception(f"Baseline not found: {self.baseline_id}")
-
-
-class GetBaselineComparisonsQuery(Query[List[BaselineComparison]]):
-    """Query to get baseline comparisons."""
-    
-    def __init__(self, http_client: HTTPClient, baseline_id: str):
-        self.http_client = http_client
-        self.baseline_id = baseline_id
-    
-    def execute(self) -> List[BaselineComparison]:
-        """Execute the query to get baseline comparisons."""
-        response = self.http_client.get(f"baselines/{self.baseline_id}/comparisons")
-        
-        if response.get("success"):
-            comparisons_data = response.get("result", {}).get("entities", [])
-            comparisons = []
-            for comparison_data in comparisons_data:
-                # Parse changes if present
-                changes = []
-                for change_data in comparison_data.get("changes", []):
-                    # Use Pydantic parsing for changes
-                    changes.append(BaselineChange.model_validate(change_data))
-                
-                # Add parsed changes to comparison data
-                comparison_data["changes"] = changes
-                
-                # Use Pydantic parsing with proper field aliasing
-                comparisons.append(BaselineComparison.model_validate(comparison_data))
-            
-            return comparisons
-        
-        return []
-
-
-class GetBaselineComparisonQuery(Query[BaselineComparison]):
-    """Query to get a specific baseline comparison by ID."""
-    
-    def __init__(self, http_client: HTTPClient, comparison_id: str):
-        self.http_client = http_client
-        self.comparison_id = comparison_id
-    
-    def execute(self) -> BaselineComparison:
-        """Execute the query to get baseline comparison details."""
-        response = self.http_client.get(f"baselines/comparisons/{self.comparison_id}")
-        
-        if response.get("success"):
-            comparison_data = response.get("result", {})
-            
-            # Parse changes if present
-            changes = []
-            for change_data in comparison_data.get("changes", []):
-                # Use Pydantic parsing for changes
-                changes.append(BaselineChange.model_validate(change_data))
-            
-            # Add parsed changes to comparison data
-            comparison_data["changes"] = changes
-            
-            # Use Pydantic parsing with proper field aliasing
-            return BaselineComparison.model_validate(comparison_data)
-        
-        raise Exception(f"Baseline comparison not found: {self.comparison_id}")
-
-
-class ListBaselineProfilesQuery(Query[List[BaselineProfile]]):
-    """Query to list baseline profiles."""
-    
-    def __init__(self, http_client: HTTPClient, organization_ids: Optional[List[int]] = None):
-        self.http_client = http_client
-        self.organization_ids = organization_ids or [0]
-    
-    def execute(self) -> List[BaselineProfile]:
-        """Execute the query to list baseline profiles."""
-        params = {
-            "filter[organizationIds]": ",".join(map(str, self.organization_ids))
-        }
-        
-        response = self.http_client.get("baseline-profiles", params=params)
-        
-        if response.get("success"):
-            profiles_data = response.get("result", {}).get("entities", [])
-            # Use Pydantic parsing with proper field aliasing
-            return [BaselineProfile.model_validate(profile_data) for profile_data in profiles_data]
-        
-        return []
-
-
-class GetBaselineProfileQuery(Query[BaselineProfile]):
-    """Query to get a specific baseline profile by ID."""
-    
-    def __init__(self, http_client: HTTPClient, profile_id: str):
-        self.http_client = http_client
-        self.profile_id = profile_id
-    
-    def execute(self) -> BaselineProfile:
-        """Execute the query to get baseline profile details."""
-        response = self.http_client.get(f"baseline-profiles/{self.profile_id}")
-        
-        if response.get("success"):
-            profile_data = response.get("result", {})
-            # Use Pydantic parsing with proper field aliasing
-            return BaselineProfile.model_validate(profile_data)
-        
-        raise Exception(f"Baseline profile not found: {self.profile_id}")
-
-
-class GetBaselineSchedulesQuery(Query[List[BaselineSchedule]]):
-    """Query to get baseline schedules."""
-    
-    def __init__(self, http_client: HTTPClient, baseline_id: Optional[str] = None, organization_ids: Optional[List[int]] = None):
-        self.http_client = http_client
-        self.baseline_id = baseline_id
-        self.organization_ids = organization_ids or [0]
-    
-    def execute(self) -> List[BaselineSchedule]:
-        """Execute the query to get baseline schedules."""
-        params = {
-            "filter[organizationIds]": ",".join(map(str, self.organization_ids))
-        }
-        
-        if self.baseline_id:
-            params["baselineId"] = self.baseline_id
-        
-        response = self.http_client.get("baseline-schedules", params=params)
-        
-        if response.get("success"):
-            schedules_data = response.get("result", {}).get("entities", [])
-            # Use Pydantic parsing with proper field aliasing
-            return [BaselineSchedule.model_validate(schedule_data) for schedule_data in schedules_data]
-        
-        return [] 
+"""
+Baseline-related queries for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any
+
+from ..base import Query
+from ..http_client import HTTPClient
+
+
+class GetBaselineComparisonReportQuery(Query[Dict[str, Any]]):
+    """Query to get baseline comparison report by endpoint ID and task ID."""
+    
+    def __init__(self, http_client: HTTPClient, endpoint_id: str, task_id: str):
+        self.http_client = http_client
+        self.endpoint_id = endpoint_id
+        self.task_id = task_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the query to get baseline comparison report."""
+        return self.http_client.get(f"baseline/comparison/report/{self.endpoint_id}/{self.task_id}")