asteroid-odyssey 1.0.2__tar.gz → 1.1.0__tar.gz

{asteroid_odyssey-1.0.2 → asteroid_odyssey-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asteroid-odyssey
-Version: 1.0.2
+Version: 1.1.0
 Summary: A Python SDK for browser automation using Asteroid platform.
 Author-email: David Mlcoch <founders@asteroid.com>
 License-Expression: MIT

{asteroid_odyssey-1.0.2 → asteroid_odyssey-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "asteroid-odyssey"
-version = "1.0.2"
+version = "1.1.0"
 authors = [
   { name = "David Mlcoch", email = "founders@asteroid.com" },
 ]

{asteroid_odyssey-1.0.2 → asteroid_odyssey-1.1.0}/src/asteroid_odyssey/client.py

@@ -10,11 +10,12 @@ without modifying any generated files.
 
 import time
 import os
+import logging
 from typing import Dict, Any, Optional, List, Union, Tuple
 from .openapi_client import (
     Configuration,
     ApiClient,
-    SDKApi,
+    APIApi,
     ExecutionApi,
     ExecutionStatusResponse,
     ExecutionResultResponse,
@@ -55,17 +56,17 @@ class AsteroidClient:
         )
         
         self.api_client = ApiClient(config)
-        self.sdk_api = SDKApi(self.api_client)
+        self.api_api = APIApi(self.api_client)
         self.execution_api = ExecutionApi(self.api_client)
         
-    def execute_agent(self, agent_id: str, execution_data: Dict[str, Any]) -> str: 
+    def execute_agent(self, agent_id: str, execution_data: Dict[str, Any], agent_profile_id: Optional[str] = None) -> str: 
         """
         Execute an agent with the provided parameters.
         
         Args:
             agent_id: The ID of the agent to execute
-            agent_profile_id: The ID of the agent profile
             execution_data: The execution parameters
+            agent_profile_id: Optional ID of the agent profile
             
         Returns:
             The execution ID
@@ -74,11 +75,11 @@ class AsteroidClient:
             Exception: If the execution request fails
             
         Example:
-            execution_id = client.execute_structured_agent('my-agent-id', 'agent-profile-id', {'input': 'some dynamic value'})
+            execution_id = client.execute_agent('my-agent-id', {'input': 'some dynamic value'}, 'agent-profile-id')
         """
-        req = StructuredAgentExecutionRequest(dynamic_data=execution_data)
+        req = StructuredAgentExecutionRequest(dynamic_data=execution_data, agent_profile_id=agent_profile_id)
         try:
-            response = self.sdk_api.execute_agent_structured(agent_id, req)
+            response = self.execution_api.execute_agent_structured(agent_id, req)
             return response.execution_id
         except ApiException as e:
             raise Exception(f"Failed to execute agent: {e}")
@@ -101,7 +102,7 @@ class AsteroidClient:
             print(status.status)
         """
         try:
-            return self.sdk_api.get_execution_status(execution_id)
+            return self.execution_api.get_execution_status(execution_id)
         except ApiException as e:
             raise Exception(f"Failed to get execution status: {e}")
     
@@ -123,12 +124,12 @@ class AsteroidClient:
             print(result)
         """
         try:
-            response = self.sdk_api.get_execution_result(execution_id)
+            response = self.execution_api.get_execution_result(execution_id)
             
             if response.error:
                 raise Exception(response.error)
             
-            return response.result or {}
+            return response.execution_result or {}
         except ApiException as e:
             raise Exception(f"Failed to get execution result: {e}")
     
@@ -269,7 +270,7 @@ class AsteroidClient:
             print(f"Recording available at: {recording_url}")
         """
         try:
-            response = self.sdk_api.get_browser_session_recording(execution_id)
+            response = self.execution_api.get_browser_session_recording(execution_id)
             return response.recording_url
         except ApiException as e:
             raise Exception(f"Failed to get browser session recording: {e}")
@@ -278,9 +279,23 @@ class AsteroidClient:
         """Context manager entry."""
         return self
     
-    def __exit__(self, exc_type, exc_value, traceback):
-        """Context manager exit."""
-        pass
+    def __exit__(self, exc_type, exc_value, tb):
+        """Context manager exit: clean up API client connection pool."""
+        try:
+            # Try to grab the pool_manager; if any attr is missing, skip
+            try:
+                pool_manager = self.api_client.rest_client.pool_manager
+            except AttributeError:
+                pool_manager = None
+
+            if pool_manager:
+                pool_manager.clear()
+        except Exception as e:
+            # Log but don't mask the original exception (if any)
+            logging.warning("Failed to clear connection pool: %s", e)
+
+        # Returning False allows any exception in the 'with' block to propagate
+        return False
 
 
 # Convenience functions that mirror the TypeScript SDK pattern
@@ -302,23 +317,23 @@ def create_client(api_key: str, base_url: Optional[str] = None) -> AsteroidClien
     """
     return AsteroidClient(api_key, base_url)
 
-def execute_agent(client: AsteroidClient, agent_id: str, agent_profile_id: str, execution_data: Dict[str, Any]) -> str:
+def execute_agent(client: AsteroidClient, agent_id: str, execution_data: Dict[str, Any], agent_profile_id: Optional[str] = None) -> str:
     """
     Execute an agent with the provided parameters.
     
     Args:
         client: The AsteroidClient instance
         agent_id: The ID of the agent to execute
-        agent_profile_id: The ID of the agent profile
         execution_data: The execution parameters
+        agent_profile_id: Optional ID of the agent profile
         
     Returns:
         The execution ID
         
     Example:
-        execution_id = execute_agent(client, 'my-agent-id', {'input': 'some dynamic value'})
+        execution_id = execute_agent(client, 'my-agent-id', {'input': 'some dynamic value'}, 'agent-profile-id')
     """
-    return client.execute_agent(agent_id, agent_profile_id, execution_data)
+    return client.execute_agent(agent_id, execution_data, agent_profile_id)
 
 
 

{asteroid_odyssey-1.0.2 → asteroid_odyssey-1.1.0}/src/asteroid_odyssey/openapi_client/__init__.py

@@ -20,7 +20,6 @@ __version__ = "1.0.0"
 __all__ = [
     "APIApi",
     "ExecutionApi",
-    "SDKApi",
     "ApiResponse",
     "ApiClient",
     "Configuration",
@@ -46,7 +45,6 @@ __all__ = [
 # import apis into sdk package
 from asteroid_odyssey.openapi_client.api.api_api import APIApi as APIApi
 from asteroid_odyssey.openapi_client.api.execution_api import ExecutionApi as ExecutionApi
-from asteroid_odyssey.openapi_client.api.sdk_api import SDKApi as SDKApi
 
 # import ApiClient
 from asteroid_odyssey.openapi_client.api_response import ApiResponse as ApiResponse

{asteroid_odyssey-1.0.2 → asteroid_odyssey-1.1.0}/src/asteroid_odyssey/openapi_client/api/__init__.py

@@ -3,5 +3,4 @@
 # import apis into api package
 from asteroid_odyssey.openapi_client.api.api_api import APIApi
 from asteroid_odyssey.openapi_client.api.execution_api import ExecutionApi
-from asteroid_odyssey.openapi_client.api.sdk_api import SDKApi
 

asteroid_odyssey-1.0.2/src/asteroid_odyssey/openapi_client/api/sdk_api.py → asteroid_odyssey-1.1.0/src/asteroid_odyssey/openapi_client/api/execution_api.py

@@ -16,21 +16,22 @@ from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
-from pydantic import Field, StrictStr
-from typing import Any, Dict
+from pydantic import Field, StrictBytes, StrictStr
+from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 from asteroid_odyssey.openapi_client.models.browser_session_recording_response import BrowserSessionRecordingResponse
 from asteroid_odyssey.openapi_client.models.execution_response import ExecutionResponse
 from asteroid_odyssey.openapi_client.models.execution_result_response import ExecutionResultResponse
 from asteroid_odyssey.openapi_client.models.execution_status_response import ExecutionStatusResponse
 from asteroid_odyssey.openapi_client.models.structured_agent_execution_request import StructuredAgentExecutionRequest
+from asteroid_odyssey.openapi_client.models.upload_execution_files200_response import UploadExecutionFiles200Response
 
 from asteroid_odyssey.openapi_client.api_client import ApiClient, RequestSerialized
 from asteroid_odyssey.openapi_client.api_response import ApiResponse
 from asteroid_odyssey.openapi_client.rest import RESTResponseType
 
 
-class SDKApi:
+class ExecutionApi:
     """NOTE: This class is auto generated by OpenAPI Generator
     Ref: https://openapi-generator.tech
 
@@ -61,7 +62,7 @@ class SDKApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ExecutionResponse:
-        """Execute an agent
+        """(Deprecated) Execute an agent
 
         Executes an agent with the provided parameters
 
@@ -90,6 +91,7 @@ class SDKApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /agent/{id} is deprecated.", DeprecationWarning)
 
         _param = self._execute_agent_serialize(
             id=id,
@@ -135,7 +137,7 @@ class SDKApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[ExecutionResponse]:
-        """Execute an agent
+        """(Deprecated) Execute an agent
 
         Executes an agent with the provided parameters
 
@@ -164,6 +166,7 @@ class SDKApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /agent/{id} is deprecated.", DeprecationWarning)
 
         _param = self._execute_agent_serialize(
             id=id,
@@ -209,7 +212,7 @@ class SDKApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Execute an agent
+        """(Deprecated) Execute an agent
 
         Executes an agent with the provided parameters
 
@@ -238,6 +241,7 @@ class SDKApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /agent/{id} is deprecated.", DeprecationWarning)
 
         _param = self._execute_agent_serialize(
             id=id,
@@ -556,7 +560,7 @@ class SDKApi:
             *_param,
             _request_timeout=_request_timeout
         )
-        return response_data.response
+        return response_data.execution_response
 
 
     def _execute_agent_structured_serialize(
@@ -1432,3 +1436,299 @@ class SDKApi:
         )
 
 
+
+
+    @validate_call
+    def upload_execution_files(
+        self,
+        id: Annotated[StrictStr, Field(description="The ID of the execution")],
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="Files to upload to the execution")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> UploadExecutionFiles200Response:
+        """Upload files to an execution
+
+
+        :param id: The ID of the execution (required)
+        :type id: str
+        :param files: Files to upload to the execution
+        :type files: List[bytearray]
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._upload_execution_files_serialize(
+            id=id,
+            files=files,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "UploadExecutionFiles200Response",
+            '400': "ErrorResponse",
+            '401': "ErrorResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def upload_execution_files_with_http_info(
+        self,
+        id: Annotated[StrictStr, Field(description="The ID of the execution")],
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="Files to upload to the execution")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[UploadExecutionFiles200Response]:
+        """Upload files to an execution
+
+
+        :param id: The ID of the execution (required)
+        :type id: str
+        :param files: Files to upload to the execution
+        :type files: List[bytearray]
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._upload_execution_files_serialize(
+            id=id,
+            files=files,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "UploadExecutionFiles200Response",
+            '400': "ErrorResponse",
+            '401': "ErrorResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def upload_execution_files_without_preload_content(
+        self,
+        id: Annotated[StrictStr, Field(description="The ID of the execution")],
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="Files to upload to the execution")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Upload files to an execution
+
+
+        :param id: The ID of the execution (required)
+        :type id: str
+        :param files: Files to upload to the execution
+        :type files: List[bytearray]
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._upload_execution_files_serialize(
+            id=id,
+            files=files,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "UploadExecutionFiles200Response",
+            '400': "ErrorResponse",
+            '401': "ErrorResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _upload_execution_files_serialize(
+        self,
+        id,
+        files,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+            'files': 'csv',
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if id is not None:
+            _path_params['id'] = id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        if files is not None:
+            _files['files'] = files
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'multipart/form-data'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'ApiKeyAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/execution/{id}/files',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+

{asteroid_odyssey-1.0.2 → asteroid_odyssey-1.1.0}/src/asteroid_odyssey.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asteroid-odyssey
-Version: 1.0.2
+Version: 1.1.0
 Summary: A Python SDK for browser automation using Asteroid platform.
 Author-email: David Mlcoch <founders@asteroid.com>
 License-Expression: MIT

{asteroid_odyssey-1.0.2 → asteroid_odyssey-1.1.0}/src/asteroid_odyssey.egg-info/SOURCES.txt

@@ -17,7 +17,6 @@ src/asteroid_odyssey/openapi_client/rest.py
 src/asteroid_odyssey/openapi_client/api/__init__.py
 src/asteroid_odyssey/openapi_client/api/api_api.py
 src/asteroid_odyssey/openapi_client/api/execution_api.py
-src/asteroid_odyssey/openapi_client/api/sdk_api.py
 src/asteroid_odyssey/openapi_client/models/__init__.py
 src/asteroid_odyssey/openapi_client/models/browser_session_recording_response.py
 src/asteroid_odyssey/openapi_client/models/error_response.py
@@ -40,7 +39,6 @@ test/test_execution_result_response.py
 test/test_execution_status_response.py
 test/test_health_check200_response.py
 test/test_health_check500_response.py
-test/test_sdk_api.py
 test/test_status.py
 test/test_structured_agent_execution_request.py
 test/test_upload_execution_files200_response.py

asteroid_odyssey-1.0.2/test/test_sdk_api.py → asteroid_odyssey-1.1.0/test/test_execution_api.py

@@ -14,14 +14,14 @@
 
 import unittest
 
-from asteroid_odyssey.openapi_client.api.sdk_api import SDKApi
+from asteroid_odyssey.openapi_client.api.execution_api import ExecutionApi
 
 
-class TestSDKApi(unittest.TestCase):
-    """SDKApi unit test stubs"""
+class TestExecutionApi(unittest.TestCase):
+    """ExecutionApi unit test stubs"""
 
     def setUp(self) -> None:
-        self.api = SDKApi()
+        self.api = ExecutionApi()
 
     def tearDown(self) -> None:
         pass
@@ -61,6 +61,13 @@ class TestSDKApi(unittest.TestCase):
         """
         pass
 
+    def test_upload_execution_files(self) -> None:
+        """Test case for upload_execution_files
+
+        Upload files to an execution
+        """
+        pass
+
 
 if __name__ == '__main__':
     unittest.main()

asteroid_odyssey-1.0.2/src/asteroid_odyssey/openapi_client/api/execution_api.py

@@ -1,335 +0,0 @@
-# coding: utf-8
-
-"""
-    Asteroid Agents API
-
-    Version 1 of the Asteroid Agents API
-
-    The version of the OpenAPI document: v1.0.0
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-import warnings
-from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
-from typing import Any, Dict, List, Optional, Tuple, Union
-from typing_extensions import Annotated
-
-from pydantic import Field, StrictBytes, StrictStr
-from typing import List, Optional, Tuple, Union
-from typing_extensions import Annotated
-from asteroid_odyssey.openapi_client.models.upload_execution_files200_response import UploadExecutionFiles200Response
-
-from asteroid_odyssey.openapi_client.api_client import ApiClient, RequestSerialized
-from asteroid_odyssey.openapi_client.api_response import ApiResponse
-from asteroid_odyssey.openapi_client.rest import RESTResponseType
-
-
-class ExecutionApi:
-    """NOTE: This class is auto generated by OpenAPI Generator
-    Ref: https://openapi-generator.tech
-
-    Do not edit the class manually.
-    """
-
-    def __init__(self, api_client=None) -> None:
-        if api_client is None:
-            api_client = ApiClient.get_default()
-        self.api_client = api_client
-
-
-    @validate_call
-    def upload_execution_files(
-        self,
-        id: Annotated[StrictStr, Field(description="The ID of the execution")],
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="Files to upload to the execution")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> UploadExecutionFiles200Response:
-        """Upload files to an execution
-
-
-        :param id: The ID of the execution (required)
-        :type id: str
-        :param files: Files to upload to the execution
-        :type files: List[bytearray]
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._upload_execution_files_serialize(
-            id=id,
-            files=files,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadExecutionFiles200Response",
-            '400': "ErrorResponse",
-            '401': "ErrorResponse",
-            '404': "ErrorResponse",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        ).data
-
-
-    @validate_call
-    def upload_execution_files_with_http_info(
-        self,
-        id: Annotated[StrictStr, Field(description="The ID of the execution")],
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="Files to upload to the execution")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[UploadExecutionFiles200Response]:
-        """Upload files to an execution
-
-
-        :param id: The ID of the execution (required)
-        :type id: str
-        :param files: Files to upload to the execution
-        :type files: List[bytearray]
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._upload_execution_files_serialize(
-            id=id,
-            files=files,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadExecutionFiles200Response",
-            '400': "ErrorResponse",
-            '401': "ErrorResponse",
-            '404': "ErrorResponse",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        )
-
-
-    @validate_call
-    def upload_execution_files_without_preload_content(
-        self,
-        id: Annotated[StrictStr, Field(description="The ID of the execution")],
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="Files to upload to the execution")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RESTResponseType:
-        """Upload files to an execution
-
-
-        :param id: The ID of the execution (required)
-        :type id: str
-        :param files: Files to upload to the execution
-        :type files: List[bytearray]
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._upload_execution_files_serialize(
-            id=id,
-            files=files,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadExecutionFiles200Response",
-            '400': "ErrorResponse",
-            '401': "ErrorResponse",
-            '404': "ErrorResponse",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _upload_execution_files_serialize(
-        self,
-        id,
-        files,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-            'files': 'csv',
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        if id is not None:
-            _path_params['id'] = id
-        # process the query parameters
-        # process the header parameters
-        # process the form parameters
-        if files is not None:
-            _files['files'] = files
-        # process the body parameter
-
-
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'application/json'
-                ]
-            )
-
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'multipart/form-data'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
-
-        # authentication setting
-        _auth_settings: List[str] = [
-            'ApiKeyAuth'
-        ]
-
-        return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/execution/{id}/files',
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth
-        )
-
-

asteroid_odyssey-1.0.2/test/test_execution_api.py

@@ -1,38 +0,0 @@
-# coding: utf-8
-
-"""
-    Asteroid Agents API
-
-    Version 1 of the Asteroid Agents API
-
-    The version of the OpenAPI document: v1.0.0
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-
-import unittest
-
-from asteroid_odyssey.openapi_client.api.execution_api import ExecutionApi
-
-
-class TestExecutionApi(unittest.TestCase):
-    """ExecutionApi unit test stubs"""
-
-    def setUp(self) -> None:
-        self.api = ExecutionApi()
-
-    def tearDown(self) -> None:
-        pass
-
-    def test_upload_execution_files(self) -> None:
-        """Test case for upload_execution_files
-
-        Upload files to an execution
-        """
-        pass
-
-
-if __name__ == '__main__':
-    unittest.main()