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

binalyze_air/commands/cloud_forensics.py

@@ -0,0 +1,88 @@
+"""
+Cloud Forensics commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any
+
+from ..base import Command
+from ..models.cloud_forensics import (
+    CloudAccount, CreateCloudAccountRequest, UpdateCloudAccountRequest, 
+    CloudVendorSyncResult, CloudVendor
+)
+from ..http_client import HTTPClient
+
+
+class CreateCloudAccountCommand(Command[CloudAccount]):
+    """Command to create a new cloud account."""
+    
+    def __init__(self, http_client: HTTPClient, request: CreateCloudAccountRequest):
+        self.http_client = http_client
+        self.request = request
+    
+    def execute(self) -> CloudAccount:
+        """Execute the command."""
+        response = self.http_client.post(
+            "cloud-forensics/accounts",
+            json_data=self.request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return CloudAccount(**response["result"])
+
+
+class UpdateCloudAccountCommand(Command[CloudAccount]):
+    """Command to update an existing cloud account."""
+    
+    def __init__(self, http_client: HTTPClient, account_id: str, request: UpdateCloudAccountRequest):
+        self.http_client = http_client
+        self.account_id = account_id
+        self.request = request
+    
+    def execute(self) -> CloudAccount:
+        """Execute the command."""
+        response = self.http_client.patch(
+            f"cloud-forensics/accounts/{self.account_id}",
+            json_data=self.request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return CloudAccount(**response["result"])
+
+
+class DeleteCloudAccountCommand(Command[Dict[str, Any]]):
+    """Command to delete a cloud account."""
+    
+    def __init__(self, http_client: HTTPClient, account_id: str):
+        self.http_client = http_client
+        self.account_id = account_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command."""
+        response = self.http_client.delete(f"cloud-forensics/accounts/{self.account_id}")
+        return response 
+
+
+class SyncCloudAccountsCommand(Command[CloudVendorSyncResult]):
+    """Command to sync cloud accounts."""
+    
+    def __init__(self, http_client: HTTPClient, cloud_vendor: CloudVendor):
+        self.http_client = http_client
+        self.cloud_vendor = cloud_vendor
+    
+    def execute(self) -> CloudVendorSyncResult:
+        """Execute the command."""
+        response = self.http_client.post(f"cloud-forensics/accounts/sync/{self.cloud_vendor}")
+        
+        if response.get("success"):
+            result_data = response.get("result")
+            # Handle null result properly - API may return null
+            if result_data is None:
+                # Return a minimal CloudVendorSyncResult for null responses
+                from datetime import datetime
+                # Use model_validate instead of direct constructor to ensure proper field mapping
+                return CloudVendorSyncResult.model_validate({
+                    "cloudVendor": self.cloud_vendor,
+                    "accountsSynced": 0,
+                    "totalAssetsDiscovered": 0,
+                    "syncStartedAt": datetime.now(),
+                    "accountResults": []
+                })
+            return CloudVendorSyncResult(**result_data)
+        
+        raise Exception(f"Failed to sync cloud accounts: {response.get('errors', [])}") 

binalyze_air/commands/event_subscription.py

@@ -1,102 +1,102 @@
-"""
-Event Subscription commands for the Binalyze AIR SDK.
-"""
-
-from typing import Dict, Any, Union
-
-from ..base import Command
-from ..models.event_subscription import EventSubscription, CreateEventSubscriptionRequest, UpdateEventSubscriptionRequest
-from ..http_client import HTTPClient
-
-
-class CreateEventSubscriptionCommand(Command[EventSubscription]):
-    """Command to create an event subscription."""
-    
-    def __init__(self, http_client: HTTPClient, request: Union[CreateEventSubscriptionRequest, Dict[str, Any]]):
-        self.http_client = http_client
-        self.request = request
-    
-    def execute(self) -> EventSubscription:
-        """Execute the command to create an event subscription."""
-        # Handle both dict and model objects
-        if isinstance(self.request, dict):
-            data = self.request
-        else:
-            data = self.request.model_dump(exclude_none=True)
-        
-        response = self.http_client.post("event-subscription", json_data=data)
-        
-        # Handle null result from API
-        result = response.get("result")
-        if result is None:
-            # If result is null but status is success, create a basic EventSubscription
-            if response.get("success"):
-                # Use Pydantic parsing with proper field aliasing
-                basic_data = {
-                    "id": data.get("name", "unknown"),  # Use name as fallback ID
-                    "name": data.get("name", ""),
-                    "url": data.get("url", ""),
-                    "active": data.get("active", True),
-                    "events": data.get("events", []),
-                    "organizationId": data.get("organizationId", 0)
-                }
-                return EventSubscription.model_validate(basic_data)
-            else:
-                # Create empty EventSubscription for failed requests
-                basic_data = {
-                    "id": "failed",
-                    "name": "Failed Creation"
-                }
-                return EventSubscription.model_validate(basic_data)
-        
-        # Convert id to string as Pydantic expects
-        if "id" in result:
-            result["id"] = str(result["id"])
-        
-        # Use Pydantic parsing with proper field aliasing
-        return EventSubscription.model_validate(result)
-
-
-class UpdateEventSubscriptionCommand(Command[EventSubscription]):
-    """Command to update an event subscription."""
-    
-    def __init__(self, http_client: HTTPClient, subscription_id: str, request: Union[UpdateEventSubscriptionRequest, Dict[str, Any]]):
-        self.http_client = http_client
-        self.subscription_id = subscription_id
-        self.request = request
-    
-    def execute(self) -> EventSubscription:
-        """Execute the command to update an event subscription."""
-        # Handle both dict and model objects
-        if isinstance(self.request, dict):
-            data = self.request
-        else:
-            data = self.request.model_dump(exclude_none=True)
-        
-        response = self.http_client.put(
-            f"event-subscription/{self.subscription_id}", 
-            json_data=data
-        )
-        
-        result = response.get("result", {})
-        
-        # Convert id to string as Pydantic expects
-        if "id" in result:
-            result["id"] = str(result["id"])
-        
-        # Use Pydantic parsing with proper field aliasing
-        return EventSubscription.model_validate(result)
-
-
-class DeleteEventSubscriptionCommand(Command[Dict[str, Any]]):
-    """Command to delete an event subscription."""
-    
-    def __init__(self, http_client: HTTPClient, subscription_id: str):
-        self.http_client = http_client
-        self.subscription_id = subscription_id
-    
-    def execute(self) -> Dict[str, Any]:
-        """Execute the command to delete an event subscription."""
-        response = self.http_client.delete(f"event-subscription/{self.subscription_id}")
-        
+"""
+Event Subscription commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any, Union
+
+from ..base import Command
+from ..models.event_subscription import EventSubscription, CreateEventSubscriptionRequest, UpdateEventSubscriptionRequest
+from ..http_client import HTTPClient
+
+
+class CreateEventSubscriptionCommand(Command[EventSubscription]):
+    """Command to create an event subscription."""
+    
+    def __init__(self, http_client: HTTPClient, request: Union[CreateEventSubscriptionRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.request = request
+    
+    def execute(self) -> EventSubscription:
+        """Execute the command to create an event subscription."""
+        # Handle both dict and model objects
+        if isinstance(self.request, dict):
+            data = self.request
+        else:
+            data = self.request.model_dump(exclude_none=True)
+        
+        response = self.http_client.post("event-subscription", json_data=data)
+        
+        # Handle null result from API
+        result = response.get("result")
+        if result is None:
+            # If result is null but status is success, create a basic EventSubscription
+            if response.get("success"):
+                # Use Pydantic parsing with proper field aliasing
+                basic_data = {
+                    "id": data.get("name", "unknown"),  # Use name as fallback ID
+                    "name": data.get("name", ""),
+                    "url": data.get("url", ""),
+                    "active": data.get("active", True),
+                    "events": data.get("events", []),
+                    "organizationId": data.get("organizationId", 0)
+                }
+                return EventSubscription.model_validate(basic_data)
+            else:
+                # Create empty EventSubscription for failed requests
+                basic_data = {
+                    "id": "failed",
+                    "name": "Failed Creation"
+                }
+                return EventSubscription.model_validate(basic_data)
+        
+        # Convert id to string as Pydantic expects
+        if "id" in result:
+            result["id"] = str(result["id"])
+        
+        # Use Pydantic parsing with proper field aliasing
+        return EventSubscription.model_validate(result)
+
+
+class UpdateEventSubscriptionCommand(Command[EventSubscription]):
+    """Command to update an event subscription."""
+    
+    def __init__(self, http_client: HTTPClient, subscription_id: str, request: Union[UpdateEventSubscriptionRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.subscription_id = subscription_id
+        self.request = request
+    
+    def execute(self) -> EventSubscription:
+        """Execute the command to update an event subscription."""
+        # Handle both dict and model objects
+        if isinstance(self.request, dict):
+            data = self.request
+        else:
+            data = self.request.model_dump(exclude_none=True)
+        
+        response = self.http_client.put(
+            f"event-subscription/{self.subscription_id}", 
+            json_data=data
+        )
+        
+        result = response.get("result", {})
+        
+        # Convert id to string as Pydantic expects
+        if "id" in result:
+            result["id"] = str(result["id"])
+        
+        # Use Pydantic parsing with proper field aliasing
+        return EventSubscription.model_validate(result)
+
+
+class DeleteEventSubscriptionCommand(Command[Dict[str, Any]]):
+    """Command to delete an event subscription."""
+    
+    def __init__(self, http_client: HTTPClient, subscription_id: str):
+        self.http_client = http_client
+        self.subscription_id = subscription_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to delete an event subscription."""
+        response = self.http_client.delete(f"event-subscription/{self.subscription_id}")
+        
         return response