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

binalyze_air/commands/policies.py

@@ -1,203 +1,175 @@
-"""
-Policy-related commands for the Binalyze AIR SDK.
-"""
-
-from typing import Dict, Any, List, Optional, Union
-
-from ..base import Command
-from ..models.policies import (
-    CreatePolicyRequest, UpdatePolicyRequest, UpdatePoliciesPrioritiesRequest, 
-    Policy, PolicyPriority, AssignPolicyRequest
-)
-from ..http_client import HTTPClient
-
-
-class CreatePolicyCommand(Command[Policy]):
-    """Command to create a new policy."""
-    
-    def __init__(self, http_client: HTTPClient, policy_data: Union[CreatePolicyRequest, Dict[str, Any]]):
-        self.http_client = http_client
-        self.policy_data = policy_data
-    
-    def execute(self) -> Policy:
-        """Execute the create policy command."""
-        # Handle both dict and model objects
-        if isinstance(self.policy_data, dict):
-            payload = self.policy_data.copy()
-        else:
-            # Convert model to dict using model_dump with aliases
-            payload = self.policy_data.model_dump(by_alias=True, exclude_none=True)
-        
-        response = self.http_client.post("policies", json_data=payload)
-        
-        # Parse using Pydantic models with automatic field mapping
-        return Policy.model_validate(response.get("result", {}))
-
-
-class UpdatePolicyCommand(Command[Policy]):
-    """Command to update an existing policy."""
-    
-    def __init__(self, http_client: HTTPClient, policy_id: str, update_data: Union[UpdatePolicyRequest, Dict[str, Any]]):
-        self.http_client = http_client
-        self.policy_id = policy_id
-        self.update_data = update_data
-    
-    def execute(self) -> Policy:
-        """Execute the update policy command."""
-        # Handle both dict and model objects
-        if isinstance(self.update_data, dict):
-            payload = self.update_data.copy()
-        else:
-            # Convert model to dict using model_dump with aliases
-            payload = self.update_data.model_dump(by_alias=True, exclude_none=True)
-        
-        response = self.http_client.put(f"policies/{self.policy_id}", json_data=payload)
-        
-        # Parse using Pydantic models with automatic field mapping
-        return Policy.model_validate(response.get("result", {}))
-
-
-class UpdatePoliciesPrioritiesCommand(Command[Dict[str, Any]]):
-    """Command to update policy priorities."""
-    
-    def __init__(self, http_client: HTTPClient, priorities_data: Union[UpdatePoliciesPrioritiesRequest, Dict[str, Any]]):
-        self.http_client = http_client
-        self.priorities_data = priorities_data
-    
-    def execute(self) -> Dict[str, Any]:
-        """Execute the update policy priorities command."""
-        # Handle both dict and model objects
-        if isinstance(self.priorities_data, dict):
-            payload = self.priorities_data.copy()
-        else:
-            # Convert model to dict using model_dump with aliases
-            payload = self.priorities_data.model_dump(by_alias=True, exclude_none=True)
-        
-        return self.http_client.put("policies/priorities", json_data=payload)
-
-
-class DeletePolicyCommand(Command[Dict[str, Any]]):
-    """Command to delete a policy."""
-    
-    def __init__(self, http_client: HTTPClient, policy_id: str):
-        self.http_client = http_client
-        self.policy_id = policy_id
-    
-    def execute(self) -> Dict[str, Any]:
-        """Execute the delete policy command."""
-        return self.http_client.delete(f"policies/{self.policy_id}")
-
-
-class AssignPolicyCommand(Command[Dict[str, Any]]):
-    """Command to assign policy to endpoints."""
-    
-    def __init__(self, http_client: HTTPClient, assignment_data: Union[AssignPolicyRequest, Dict[str, Any]]):
-        self.http_client = http_client
-        self.assignment_data = assignment_data
-    
-    def execute(self) -> Dict[str, Any]:
-        """Execute the assign policy command."""
-        # Handle both dict and model objects
-        if isinstance(self.assignment_data, dict):
-            payload = self.assignment_data.copy()
-        else:
-            payload = {
-                "policyId": self.assignment_data.policy_id,
-                "endpointIds": self.assignment_data.endpoint_ids,
-                "organizationIds": self.assignment_data.organization_ids,
-            }
-            
-            if self.assignment_data.filter_params:
-                payload["filter"] = self.assignment_data.filter_params
-        
-        return self.http_client.post("policies/assign", json_data=payload)
-
-
-class UnassignPolicyCommand(Command[Dict[str, Any]]):
-    """Command to unassign policy from endpoints."""
-    
-    def __init__(self, http_client: HTTPClient, policy_id: str, endpoint_ids: List[str]):
-        self.http_client = http_client
-        self.policy_id = policy_id
-        self.endpoint_ids = endpoint_ids
-    
-    def execute(self) -> Dict[str, Any]:
-        """Execute the unassign policy command."""
-        payload = {
-            "policyId": self.policy_id,
-            "endpointIds": self.endpoint_ids,
-        }
-        
-        return self.http_client.post("policies/unassign", json_data=payload)
-
-
-class ExecutePolicyCommand(Command[Dict[str, Any]]):
-    """Command to execute a policy on assigned endpoints."""
-    
-    def __init__(self, http_client: HTTPClient, policy_id: str, endpoint_ids: Optional[List[str]] = None):
-        self.http_client = http_client
-        self.policy_id = policy_id
-        self.endpoint_ids = endpoint_ids
-    
-    def execute(self) -> Dict[str, Any]:
-        """Execute the policy execution command."""
-        payload = {"policyId": self.policy_id}
-        
-        if self.endpoint_ids:
-            payload["endpointIds"] = self.endpoint_ids
-        
-        return self.http_client.post("policies/execute", json_data=payload)
-
-
-class ActivatePolicyCommand(Command[Policy]):
-    """Command to activate a policy."""
-    
-    def __init__(self, http_client: HTTPClient, policy_id: str):
-        self.http_client = http_client
-        self.policy_id = policy_id
-    
-    def execute(self) -> Policy:
-        """Execute the activate policy command."""
-        payload = {"status": "active"}
-        response = self.http_client.put(f"policies/{self.policy_id}", json_data=payload)
-        
-        entity_data = response.get("result", {})
-        return Policy(
-            id=entity_data.get("_id", self.policy_id),
-            name=entity_data.get("name", ""),
-            description=entity_data.get("description"),
-            type=entity_data.get("type", "custom"),
-            status=entity_data.get("status", "active"),
-            organization_ids=entity_data.get("organizationIds", [0]),
-            created_by=entity_data.get("createdBy", ""),
-            created_at=entity_data.get("createdAt"),
-            rules=entity_data.get("rules", []),
-            tags=entity_data.get("tags", [])
-        )
-
-
-class DeactivatePolicyCommand(Command[Policy]):
-    """Command to deactivate a policy."""
-    
-    def __init__(self, http_client: HTTPClient, policy_id: str):
-        self.http_client = http_client
-        self.policy_id = policy_id
-    
-    def execute(self) -> Policy:
-        """Execute the deactivate policy command."""
-        payload = {"status": "inactive"}
-        response = self.http_client.put(f"policies/{self.policy_id}", json_data=payload)
-        
-        entity_data = response.get("result", {})
-        return Policy(
-            id=entity_data.get("_id", self.policy_id),
-            name=entity_data.get("name", ""),
-            description=entity_data.get("description"),
-            type=entity_data.get("type", "custom"),
-            status=entity_data.get("status", "inactive"),
-            organization_ids=entity_data.get("organizationIds", [0]),
-            created_by=entity_data.get("createdBy", ""),
-            created_at=entity_data.get("createdAt"),
-            rules=entity_data.get("rules", []),
-            tags=entity_data.get("tags", [])
-        ) 
+"""
+Policy-related commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any, List, Optional, Union, cast
+
+from ..base import Command
+from ..models.policies import (
+    CreatePolicyRequest, UpdatePolicyRequest, UpdatePoliciesPrioritiesRequest, 
+    Policy, PolicyPriority, AssignPolicyRequest
+)
+from ..http_client import HTTPClient
+
+
+class CreatePolicyCommand(Command[Policy]):
+    """Command to create a new policy."""
+    
+    def __init__(self, http_client: HTTPClient, policy_data: Union[CreatePolicyRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.policy_data = policy_data
+    
+    def execute(self) -> Policy:
+        """Execute the create policy command."""
+        # Handle both dict and model objects
+        if isinstance(self.policy_data, dict):
+            payload = self.policy_data.copy()
+        else:
+            # Convert model to dict using model_dump with aliases
+            payload = self.policy_data.model_dump(by_alias=True, exclude_none=True)
+        
+        response = self.http_client.post("policies", json_data=payload)
+        
+        # Parse using Pydantic models with automatic field mapping
+        return Policy.model_validate(response.get("result", {}))
+
+
+class UpdatePolicyCommand(Command[Policy]):
+    """Command to update an existing policy."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str, update_data: Union[UpdatePolicyRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.policy_id = policy_id
+        self.update_data = update_data
+    
+    def execute(self) -> Policy:
+        """Execute the update policy command."""
+        # Handle both dict and model objects
+        if isinstance(self.update_data, dict):
+            payload = self.update_data.copy()
+        else:
+            # Convert model to dict using model_dump with aliases
+            payload = self.update_data.model_dump(by_alias=True, exclude_none=True)
+        
+        response = self.http_client.put(f"policies/{self.policy_id}", json_data=payload)
+        
+        # Parse using Pydantic models with automatic field mapping
+        return Policy.model_validate(response.get("result", {}))
+
+
+class UpdatePoliciesPrioritiesCommand(Command[Dict[str, Any]]):
+    """Command to update policy priorities."""
+    
+    def __init__(self, http_client: HTTPClient, priorities_data: Union[UpdatePoliciesPrioritiesRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.priorities_data = priorities_data
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the update policy priorities command."""
+        # Handle both dict and model objects
+        if isinstance(self.priorities_data, dict):
+            payload = self.priorities_data.copy()
+        else:
+            # Convert model to dict using model_dump with aliases
+            payload = self.priorities_data.model_dump(by_alias=True, exclude_none=True)
+        
+        return self.http_client.put("policies/priorities", json_data=payload)
+
+
+class DeletePolicyCommand(Command[Dict[str, Any]]):
+    """Command to delete a policy."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str):
+        self.http_client = http_client
+        self.policy_id = policy_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the delete policy command."""
+        return self.http_client.delete(f"policies/{self.policy_id}")
+
+
+class AssignPolicyCommand(Command[Dict[str, Any]]):
+    """Command to assign policy to endpoints."""
+    
+    def __init__(self, http_client: HTTPClient, assignment_data: Union[AssignPolicyRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.assignment_data = assignment_data
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the assign policy command."""
+        # Handle both dict and model objects
+        if isinstance(self.assignment_data, dict):
+            payload = self.assignment_data.copy()
+        else:
+            # Use model_dump method to properly serialize the request object
+            payload = self.assignment_data.model_dump(by_alias=True, exclude_none=True)
+        
+        return self.http_client.post("policies/assign", json_data=payload)
+
+
+class UnassignPolicyCommand(Command[Dict[str, Any]]):
+    """Command to unassign policy from endpoints."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str, endpoint_ids: List[str]):
+        self.http_client = http_client
+        self.policy_id = policy_id
+        self.endpoint_ids = endpoint_ids
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the unassign policy command."""
+        payload: Dict[str, Any] = {}
+        payload["policyId"] = self.policy_id
+        payload["endpointIds"] = self.endpoint_ids
+        
+        return self.http_client.post("policies/unassign", json_data=payload)
+
+
+class ExecutePolicyCommand(Command[Dict[str, Any]]):
+    """Command to execute a policy on assigned endpoints."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str, endpoint_ids: Optional[List[str]] = None):
+        self.http_client = http_client
+        self.policy_id = policy_id
+        self.endpoint_ids = endpoint_ids
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the policy execution command."""
+        payload: Dict[str, Any] = {}
+        payload["policyId"] = self.policy_id
+        
+        if self.endpoint_ids:
+            payload["endpointIds"] = self.endpoint_ids
+        
+        return self.http_client.post("policies/execute", json_data=payload)
+
+
+class ActivatePolicyCommand(Command[Policy]):
+    """Command to activate a policy."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str):
+        self.http_client = http_client
+        self.policy_id = policy_id
+    
+    def execute(self) -> Policy:
+        """Execute the activate policy command."""
+        payload = {"status": "active"}
+        response = self.http_client.put(f"policies/{self.policy_id}", json_data=payload)
+        
+        entity_data = response.get("result", {})
+        return Policy.model_validate(entity_data)
+
+
+class DeactivatePolicyCommand(Command[Policy]):
+    """Command to deactivate a policy."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str):
+        self.http_client = http_client
+        self.policy_id = policy_id
+    
+    def execute(self) -> Policy:
+        """Execute the deactivate policy command."""
+        payload = {"status": "inactive"}
+        response = self.http_client.put(f"policies/{self.policy_id}", json_data=payload)
+        
+        entity_data = response.get("result", {})
+        return Policy.model_validate(entity_data) 

binalyze_air/commands/preset_filters.py

@@ -0,0 +1,55 @@
+"""
+Preset Filters commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any
+
+from ..base import Command
+from ..models.preset_filters import PresetFilter, CreatePresetFilterRequest, UpdatePresetFilterRequest
+from ..http_client import HTTPClient
+
+
+class CreatePresetFilterCommand(Command[PresetFilter]):
+    """Command to create a preset filter."""
+    
+    def __init__(self, http_client: HTTPClient, preset_filter_data: CreatePresetFilterRequest):
+        self.http_client = http_client
+        self.preset_filter_data = preset_filter_data
+    
+    def execute(self) -> PresetFilter:
+        """Execute the command to create a preset filter."""
+        response = self.http_client.post(
+            '/preset-filters',
+            json_data=self.preset_filter_data.to_dict()
+        )
+        return PresetFilter(**response['result'])
+
+
+class UpdatePresetFilterCommand(Command[PresetFilter]):
+    """Command to update a preset filter."""
+    
+    def __init__(self, http_client: HTTPClient, filter_id: str, preset_filter_data: UpdatePresetFilterRequest):
+        self.http_client = http_client
+        self.filter_id = filter_id
+        self.preset_filter_data = preset_filter_data
+    
+    def execute(self) -> PresetFilter:
+        """Execute the command to update a preset filter."""
+        response = self.http_client.put(
+            f'/preset-filters/{self.filter_id}',
+            json_data=self.preset_filter_data.to_dict()
+        )
+        return PresetFilter(**response['result'])
+
+
+class DeletePresetFilterCommand(Command[Dict[str, Any]]):
+    """Command to delete a preset filter."""
+    
+    def __init__(self, http_client: HTTPClient, filter_id: str):
+        self.http_client = http_client
+        self.filter_id = filter_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to delete a preset filter."""
+        response = self.http_client.delete(f'/preset-filters/{self.filter_id}')
+        return response 

binalyze_air/commands/recent_activities.py

@@ -0,0 +1,32 @@
+"""
+Recent Activities commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any
+
+from ..base import Command
+from ..models.recent_activities import CreateRecentActivityRequest
+from ..http_client import HTTPClient
+
+
+class CreateRecentActivityCommand(Command[Dict[str, Any]]):
+    """Command to create a recent activity."""
+    
+    def __init__(self, http_client: HTTPClient, activity_data: CreateRecentActivityRequest):
+        self.http_client = http_client
+        self.activity_data = activity_data
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to create a recent activity."""
+        # API only requires 'type' and 'entityId' fields
+        # Other fields like username, organizationId are filled automatically by server
+        minimal_data = {
+            'type': self.activity_data.type,
+            'entityId': self.activity_data.entity_id
+        }
+        
+        response = self.http_client.post(
+            '/recent-activities',
+            json_data=minimal_data
+        )
+        return response 

binalyze_air/commands/relay_server.py

@@ -0,0 +1,144 @@
+"""
+Relay Server commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any
+
+from ..base import Command
+from ..models.relay_server import (
+    RebootTaskRequest, ShutdownTaskRequest, LogRetrievalTaskRequest, VersionUpdateTaskRequest,
+    UpdateTagsRequest, UpdateLabelRequest, UpdateAddressRequest
+)
+from ..http_client import HTTPClient
+
+
+class AssignRebootTaskCommand(Command[Dict[str, Any]]):
+    """Command to assign reboot task to relay server."""
+    
+    def __init__(self, http_client: HTTPClient, relay_server_id: str, task_request: RebootTaskRequest):
+        self.http_client = http_client
+        self.relay_server_id = relay_server_id
+        self.task_request = task_request
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to assign reboot task."""
+        response = self.http_client.post(
+            f'/relay-servers/{self.relay_server_id}/tasks/reboot',
+            json_data=self.task_request.model_dump(exclude_none=True)
+        )
+        return response
+
+
+class AssignShutdownTaskCommand(Command[Dict[str, Any]]):
+    """Command to assign shutdown task to relay server."""
+    
+    def __init__(self, http_client: HTTPClient, relay_server_id: str, task_request: ShutdownTaskRequest):
+        self.http_client = http_client
+        self.relay_server_id = relay_server_id
+        self.task_request = task_request
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to assign shutdown task."""
+        response = self.http_client.post(
+            f'/relay-servers/{self.relay_server_id}/tasks/shutdown',
+            json_data=self.task_request.model_dump(exclude_none=True)
+        )
+        return response
+
+
+class AssignLogRetrievalTaskCommand(Command[Dict[str, Any]]):
+    """Command to assign log retrieval task to relay server."""
+    
+    def __init__(self, http_client: HTTPClient, relay_server_id: str, task_request: LogRetrievalTaskRequest):
+        self.http_client = http_client
+        self.relay_server_id = relay_server_id
+        self.task_request = task_request
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to assign log retrieval task."""
+        response = self.http_client.post(
+            f'/relay-servers/{self.relay_server_id}/tasks/log-retrieval',
+            json_data=self.task_request.model_dump(exclude_none=True)
+        )
+        return response
+
+
+class AssignVersionUpdateTaskCommand(Command[Dict[str, Any]]):
+    """Command to assign version update task to relay server."""
+    
+    def __init__(self, http_client: HTTPClient, relay_server_id: str, task_request: VersionUpdateTaskRequest):
+        self.http_client = http_client
+        self.relay_server_id = relay_server_id
+        self.task_request = task_request
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to assign version update task."""
+        response = self.http_client.post(
+            f'/relay-servers/{self.relay_server_id}/tasks/version-update',
+            json_data=self.task_request.model_dump(exclude_none=True)
+        )
+        return response
+
+
+class DeleteRelayServerCommand(Command[Dict[str, Any]]):
+    """Command to delete a relay server."""
+    
+    def __init__(self, http_client: HTTPClient, server_id: str):
+        self.http_client = http_client
+        self.server_id = server_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to delete a relay server."""
+        response = self.http_client.delete(f'/relay-servers/remove', params={'id': self.server_id})
+        return response
+
+
+class UpdateTagsCommand(Command[Dict[str, Any]]):
+    """Command to update tags for a relay server."""
+    
+    def __init__(self, http_client: HTTPClient, relay_server_id: str, tags_request: UpdateTagsRequest):
+        self.http_client = http_client
+        self.relay_server_id = relay_server_id
+        self.tags_request = tags_request
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to update tags."""
+        response = self.http_client.patch(
+            f'/relay-servers/{self.relay_server_id}/tag',
+            json_data=self.tags_request.model_dump(exclude_none=True)
+        )
+        return response
+
+
+class UpdateLabelCommand(Command[Dict[str, Any]]):
+    """Command to update label for a relay server."""
+    
+    def __init__(self, http_client: HTTPClient, relay_server_id: str, label_request: UpdateLabelRequest):
+        self.http_client = http_client
+        self.relay_server_id = relay_server_id
+        self.label_request = label_request
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to update label."""
+        response = self.http_client.patch(
+            f'/relay-servers/{self.relay_server_id}/label',
+            json_data=self.label_request.model_dump(exclude_none=True)
+        )
+        return response
+
+
+class UpdateAddressCommand(Command[Dict[str, Any]]):
+    """Command to update address for a relay server."""
+    
+    def __init__(self, http_client: HTTPClient, relay_server_id: str, address_request: UpdateAddressRequest):
+        self.http_client = http_client
+        self.relay_server_id = relay_server_id
+        self.address_request = address_request
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to update address."""
+        response = self.http_client.patch(
+            f'/relay-servers/{self.relay_server_id}/address',
+            json_data=self.address_request.model_dump(exclude_none=True)
+        )
+        return response