diff --git a/.sdk-version b/.sdk-version index aaaf84e..5909159 100644 --- a/.sdk-version +++ b/.sdk-version @@ -1 +1 @@ -v1.75.0 +v1.78.1 diff --git a/README.md b/README.md index 7301958..bd185ba 100644 --- a/README.md +++ b/README.md @@ -156,6 +156,7 @@ Class | Method | HTTP request | Description *SearchApi* | [**search_collections**](docs/SearchApi.md#search_collections) | **GET** /v2/search/collections | Collections search *SearchApi* | [**search_functions**](docs/SearchApi.md#search_functions) | **GET** /v2/search/functions | Functions search *SearchApi* | [**search_tags**](docs/SearchApi.md#search_tags) | **GET** /v2/search/tags | Tags search +*DefaultApi* | [**get_analysis_function_map**](docs/DefaultApi.md#get_analysis_function_map) | **GET** /v2/analyses/{analysis_id}/func_maps | Get Analysis Function Map ## Documentation For Models @@ -169,6 +170,7 @@ Class | Method | HTTP request | Description - [AnalysisCreateRequest](docs/AnalysisCreateRequest.md) - [AnalysisCreateResponse](docs/AnalysisCreateResponse.md) - [AnalysisDetailResponse](docs/AnalysisDetailResponse.md) + - [AnalysisFunctionMapping](docs/AnalysisFunctionMapping.md) - [AnalysisFunctions](docs/AnalysisFunctions.md) - [AnalysisRecord](docs/AnalysisRecord.md) - [AnalysisScope](docs/AnalysisScope.md) @@ -193,6 +195,7 @@ Class | Method | HTTP request | Description - [BaseResponse](docs/BaseResponse.md) - [BaseResponseAnalysisCreateResponse](docs/BaseResponseAnalysisCreateResponse.md) - [BaseResponseAnalysisDetailResponse](docs/BaseResponseAnalysisDetailResponse.md) + - [BaseResponseAnalysisFunctionMapping](docs/BaseResponseAnalysisFunctionMapping.md) - [BaseResponseAnalysisFunctions](docs/BaseResponseAnalysisFunctions.md) - [BaseResponseAnalysisStringsResponse](docs/BaseResponseAnalysisStringsResponse.md) - [BaseResponseAnalysisTags](docs/BaseResponseAnalysisTags.md) @@ -352,6 +355,7 @@ Class | Method | HTTP request | Description - [FunctionInfoInputFuncDepsInner](docs/FunctionInfoInputFuncDepsInner.md) - [FunctionInfoOutput](docs/FunctionInfoOutput.md) - [FunctionLocalVariableResponse](docs/FunctionLocalVariableResponse.md) + - [FunctionMapping](docs/FunctionMapping.md) - [FunctionMappingFull](docs/FunctionMappingFull.md) - [FunctionNameConfidenceBody](docs/FunctionNameConfidenceBody.md) - [FunctionNameHistory](docs/FunctionNameHistory.md) diff --git a/docs/AnalysisFunctionMapping.md b/docs/AnalysisFunctionMapping.md new file mode 100644 index 0000000..0d7f543 --- /dev/null +++ b/docs/AnalysisFunctionMapping.md @@ -0,0 +1,29 @@ +# AnalysisFunctionMapping + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**function_maps** | [**FunctionMapping**](FunctionMapping.md) | A map of function ids to function addresses for the analysis, and it's inverse. | + +## Example + +```python +from revengai.models.analysis_function_mapping import AnalysisFunctionMapping + +# TODO update the JSON string below +json = "{}" +# create an instance of AnalysisFunctionMapping from a JSON string +analysis_function_mapping_instance = AnalysisFunctionMapping.from_json(json) +# print the JSON string representation of the object +print(AnalysisFunctionMapping.to_json()) + +# convert the object into a dict +analysis_function_mapping_dict = analysis_function_mapping_instance.to_dict() +# create an instance of AnalysisFunctionMapping from a dict +analysis_function_mapping_from_dict = AnalysisFunctionMapping.from_dict(analysis_function_mapping_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/docs/BaseResponseAnalysisFunctionMapping.md b/docs/BaseResponseAnalysisFunctionMapping.md new file mode 100644 index 0000000..524e0f9 --- /dev/null +++ b/docs/BaseResponseAnalysisFunctionMapping.md @@ -0,0 +1,33 @@ +# BaseResponseAnalysisFunctionMapping + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **bool** | Response status on whether the request succeeded | [optional] [default to True] +**data** | [**AnalysisFunctionMapping**](AnalysisFunctionMapping.md) | | [optional] +**message** | **str** | | [optional] +**errors** | [**List[ErrorModel]**](ErrorModel.md) | | [optional] +**meta** | [**MetaModel**](MetaModel.md) | Metadata | [optional] + +## Example + +```python +from revengai.models.base_response_analysis_function_mapping import BaseResponseAnalysisFunctionMapping + +# TODO update the JSON string below +json = "{}" +# create an instance of BaseResponseAnalysisFunctionMapping from a JSON string +base_response_analysis_function_mapping_instance = BaseResponseAnalysisFunctionMapping.from_json(json) +# print the JSON string representation of the object +print(BaseResponseAnalysisFunctionMapping.to_json()) + +# convert the object into a dict +base_response_analysis_function_mapping_dict = base_response_analysis_function_mapping_instance.to_dict() +# create an instance of BaseResponseAnalysisFunctionMapping from a dict +base_response_analysis_function_mapping_from_dict = BaseResponseAnalysisFunctionMapping.from_dict(base_response_analysis_function_mapping_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/docs/DefaultApi.md b/docs/DefaultApi.md new file mode 100644 index 0000000..3b66876 --- /dev/null +++ b/docs/DefaultApi.md @@ -0,0 +1,91 @@ +# revengai.DefaultApi + +All URIs are relative to *https://api.reveng.ai* + +Method | HTTP request | Description +------------- | ------------- | ------------- +[**get_analysis_function_map**](DefaultApi.md#get_analysis_function_map) | **GET** /v2/analyses/{analysis_id}/func_maps | Get Analysis Function Map + + +# **get_analysis_function_map** +> BaseResponseAnalysisFunctionMapping get_analysis_function_map(analysis_id, authorization=authorization) + +Get Analysis Function Map + +Returns the a map of function ids to function addresses for the analysis, and it's inverse. + +### Example + +* Api Key Authentication (APIKey): + +```python +import revengai +from revengai.models.base_response_analysis_function_mapping import BaseResponseAnalysisFunctionMapping +from revengai.rest import ApiException +from pprint import pprint + +# Defining the host is optional and defaults to https://api.reveng.ai +# See configuration.py for a list of all supported configuration parameters. +configuration = revengai.Configuration( + host = "https://api.reveng.ai" +) + +# The client must configure the authentication and authorization parameters +# in accordance with the API server security policy. +# Examples for each auth method are provided below, use the example that +# satisfies your auth use case. + +# Configure API key authorization: APIKey +configuration.api_key['APIKey'] = os.environ["API_KEY"] + +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['APIKey'] = 'Bearer' + +# Enter a context with an instance of the API client +with revengai.ApiClient(configuration) as api_client: + # Create an instance of the API class + api_instance = revengai.DefaultApi(api_client) + analysis_id = 56 # int | + authorization = 'authorization_example' # str | API Key bearer token (optional) + + try: + # Get Analysis Function Map + api_response = api_instance.get_analysis_function_map(analysis_id, authorization=authorization) + print("The response of DefaultApi->get_analysis_function_map:\n") + pprint(api_response) + except Exception as e: + print("Exception when calling DefaultApi->get_analysis_function_map: %s\n" % e) +``` + + + +### Parameters + + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **analysis_id** | **int**| | + **authorization** | **str**| API Key bearer token | [optional] + +### Return type + +[**BaseResponseAnalysisFunctionMapping**](BaseResponseAnalysisFunctionMapping.md) + +### Authorization + +[APIKey](../README.md#APIKey) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +### HTTP response details + +| Status code | Description | Response headers | +|-------------|-------------|------------------| +**200** | Successful Response | - | +**422** | Invalid request parameters | - | + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + diff --git a/docs/FunctionMapping.md b/docs/FunctionMapping.md new file mode 100644 index 0000000..198aec1 --- /dev/null +++ b/docs/FunctionMapping.md @@ -0,0 +1,30 @@ +# FunctionMapping + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**function_map** | **Dict[str, int]** | Mapping of remote function ids to local function addresses | +**inverse_function_map** | **Dict[str, int]** | Mapping of local function addresses to remote function ids | + +## Example + +```python +from revengai.models.function_mapping import FunctionMapping + +# TODO update the JSON string below +json = "{}" +# create an instance of FunctionMapping from a JSON string +function_mapping_instance = FunctionMapping.from_json(json) +# print the JSON string representation of the object +print(FunctionMapping.to_json()) + +# convert the object into a dict +function_mapping_dict = function_mapping_instance.to_dict() +# create an instance of FunctionMapping from a dict +function_mapping_from_dict = FunctionMapping.from_dict(function_mapping_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/revengai/__init__.py b/revengai/__init__.py index 6c6f24e..3a20ad2 100644 --- a/revengai/__init__.py +++ b/revengai/__init__.py @@ -13,7 +13,7 @@ """ # noqa: E501 -__version__ = "v1.75.0" +__version__ = "v1.78.1" # Define package exports __all__ = [ @@ -37,6 +37,7 @@ "FunctionsThreatScoreApi", "ModelsApi", "SearchApi", + "DefaultApi", "ApiResponse", "ApiClient", "Configuration", @@ -55,6 +56,7 @@ "AnalysisCreateRequest", "AnalysisCreateResponse", "AnalysisDetailResponse", + "AnalysisFunctionMapping", "AnalysisFunctions", "AnalysisRecord", "AnalysisScope", @@ -79,6 +81,7 @@ "BaseResponse", "BaseResponseAnalysisCreateResponse", "BaseResponseAnalysisDetailResponse", + "BaseResponseAnalysisFunctionMapping", "BaseResponseAnalysisFunctions", "BaseResponseAnalysisStringsResponse", "BaseResponseAnalysisTags", @@ -238,6 +241,7 @@ "FunctionInfoInputFuncDepsInner", "FunctionInfoOutput", "FunctionLocalVariableResponse", + "FunctionMapping", "FunctionMappingFull", "FunctionNameConfidenceBody", "FunctionNameHistory", @@ -376,6 +380,7 @@ from revengai.api.functions_threat_score_api import FunctionsThreatScoreApi as FunctionsThreatScoreApi from revengai.api.models_api import ModelsApi as ModelsApi from revengai.api.search_api import SearchApi as SearchApi +from revengai.api.default_api import DefaultApi as DefaultApi # import ApiClient from revengai.api_response import ApiResponse as ApiResponse @@ -398,6 +403,7 @@ from revengai.models.analysis_create_request import AnalysisCreateRequest as AnalysisCreateRequest from revengai.models.analysis_create_response import AnalysisCreateResponse as AnalysisCreateResponse from revengai.models.analysis_detail_response import AnalysisDetailResponse as AnalysisDetailResponse +from revengai.models.analysis_function_mapping import AnalysisFunctionMapping as AnalysisFunctionMapping from revengai.models.analysis_functions import AnalysisFunctions as AnalysisFunctions from revengai.models.analysis_record import AnalysisRecord as AnalysisRecord from revengai.models.analysis_scope import AnalysisScope as AnalysisScope @@ -422,6 +428,7 @@ from revengai.models.base_response import BaseResponse as BaseResponse from revengai.models.base_response_analysis_create_response import BaseResponseAnalysisCreateResponse as BaseResponseAnalysisCreateResponse from revengai.models.base_response_analysis_detail_response import BaseResponseAnalysisDetailResponse as BaseResponseAnalysisDetailResponse +from revengai.models.base_response_analysis_function_mapping import BaseResponseAnalysisFunctionMapping as BaseResponseAnalysisFunctionMapping from revengai.models.base_response_analysis_functions import BaseResponseAnalysisFunctions as BaseResponseAnalysisFunctions from revengai.models.base_response_analysis_strings_response import BaseResponseAnalysisStringsResponse as BaseResponseAnalysisStringsResponse from revengai.models.base_response_analysis_tags import BaseResponseAnalysisTags as BaseResponseAnalysisTags @@ -581,6 +588,7 @@ from revengai.models.function_info_input_func_deps_inner import FunctionInfoInputFuncDepsInner as FunctionInfoInputFuncDepsInner from revengai.models.function_info_output import FunctionInfoOutput as FunctionInfoOutput from revengai.models.function_local_variable_response import FunctionLocalVariableResponse as FunctionLocalVariableResponse +from revengai.models.function_mapping import FunctionMapping as FunctionMapping from revengai.models.function_mapping_full import FunctionMappingFull as FunctionMappingFull from revengai.models.function_name_confidence_body import FunctionNameConfidenceBody as FunctionNameConfidenceBody from revengai.models.function_name_history import FunctionNameHistory as FunctionNameHistory diff --git a/revengai/api/__init__.py b/revengai/api/__init__.py index 0199858..7cd5d0d 100644 --- a/revengai/api/__init__.py +++ b/revengai/api/__init__.py @@ -21,4 +21,5 @@ from revengai.api.functions_threat_score_api import FunctionsThreatScoreApi from revengai.api.models_api import ModelsApi from revengai.api.search_api import SearchApi +from revengai.api.default_api import DefaultApi diff --git a/revengai/api/default_api.py b/revengai/api/default_api.py new file mode 100644 index 0000000..013d6c5 --- /dev/null +++ b/revengai/api/default_api.py @@ -0,0 +1,317 @@ +# coding: utf-8 + +""" + RevEng.AI API + + RevEng.AI is Similarity Search Engine for executable binaries + + 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, StrictInt, StrictStr +from typing import Optional +from typing_extensions import Annotated +from revengai.models.base_response_analysis_function_mapping import BaseResponseAnalysisFunctionMapping + +from revengai.api_client import ApiClient, RequestSerialized +from revengai.api_response import ApiResponse +from revengai.rest import RESTResponseType + + +class DefaultApi: + """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 get_analysis_function_map( + self, + analysis_id: StrictInt, + authorization: Annotated[Optional[StrictStr], Field(description="API Key bearer token")] = 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, + ) -> BaseResponseAnalysisFunctionMapping: + """Get Analysis Function Map + + Returns the a map of function ids to function addresses for the analysis, and it's inverse. + + :param analysis_id: (required) + :type analysis_id: int + :param authorization: API Key bearer token + :type authorization: str + :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._get_analysis_function_map_serialize( + analysis_id=analysis_id, + authorization=authorization, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "BaseResponseAnalysisFunctionMapping", + '422': "BaseResponse", + } + 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 get_analysis_function_map_with_http_info( + self, + analysis_id: StrictInt, + authorization: Annotated[Optional[StrictStr], Field(description="API Key bearer token")] = 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[BaseResponseAnalysisFunctionMapping]: + """Get Analysis Function Map + + Returns the a map of function ids to function addresses for the analysis, and it's inverse. + + :param analysis_id: (required) + :type analysis_id: int + :param authorization: API Key bearer token + :type authorization: str + :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._get_analysis_function_map_serialize( + analysis_id=analysis_id, + authorization=authorization, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "BaseResponseAnalysisFunctionMapping", + '422': "BaseResponse", + } + 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 get_analysis_function_map_without_preload_content( + self, + analysis_id: StrictInt, + authorization: Annotated[Optional[StrictStr], Field(description="API Key bearer token")] = 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: + """Get Analysis Function Map + + Returns the a map of function ids to function addresses for the analysis, and it's inverse. + + :param analysis_id: (required) + :type analysis_id: int + :param authorization: API Key bearer token + :type authorization: str + :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._get_analysis_function_map_serialize( + analysis_id=analysis_id, + authorization=authorization, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "BaseResponseAnalysisFunctionMapping", + '422': "BaseResponse", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _get_analysis_function_map_serialize( + self, + analysis_id, + authorization, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _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 analysis_id is not None: + _path_params['analysis_id'] = analysis_id + # process the query parameters + # process the header parameters + if authorization is not None: + _header_params['authorization'] = authorization + # process the form parameters + # 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' + ] + ) + + + # authentication setting + _auth_settings: List[str] = [ + 'APIKey' + ] + + return self.api_client.param_serialize( + method='GET', + resource_path='/v2/analyses/{analysis_id}/func_maps', + 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 + ) + + diff --git a/revengai/api_client.py b/revengai/api_client.py index 7f14430..aea317b 100644 --- a/revengai/api_client.py +++ b/revengai/api_client.py @@ -90,7 +90,7 @@ def __init__( self.default_headers[header_name] = header_value self.cookie = cookie # Set default User-Agent. - self.user_agent = 'OpenAPI-Generator/v1.75.0/python' + self.user_agent = 'OpenAPI-Generator/v1.78.1/python' self.client_side_validation = configuration.client_side_validation def __enter__(self): diff --git a/revengai/configuration.py b/revengai/configuration.py index 5c7da8a..6bb3e12 100644 --- a/revengai/configuration.py +++ b/revengai/configuration.py @@ -529,8 +529,8 @@ def to_debug_report(self) -> str: return "Python SDK Debug Report:\n"\ "OS: {env}\n"\ "Python Version: {pyversion}\n"\ - "Version of the API: v1.75.0\n"\ - "SDK Package Version: v1.75.0".\ + "Version of the API: v1.78.1\n"\ + "SDK Package Version: v1.78.1".\ format(env=sys.platform, pyversion=sys.version) def get_host_settings(self) -> List[HostSetting]: diff --git a/revengai/models/__init__.py b/revengai/models/__init__.py index 2feef89..efc2f45 100644 --- a/revengai/models/__init__.py +++ b/revengai/models/__init__.py @@ -21,6 +21,7 @@ from revengai.models.analysis_create_request import AnalysisCreateRequest from revengai.models.analysis_create_response import AnalysisCreateResponse from revengai.models.analysis_detail_response import AnalysisDetailResponse +from revengai.models.analysis_function_mapping import AnalysisFunctionMapping from revengai.models.analysis_functions import AnalysisFunctions from revengai.models.analysis_record import AnalysisRecord from revengai.models.analysis_scope import AnalysisScope @@ -45,6 +46,7 @@ from revengai.models.base_response import BaseResponse from revengai.models.base_response_analysis_create_response import BaseResponseAnalysisCreateResponse from revengai.models.base_response_analysis_detail_response import BaseResponseAnalysisDetailResponse +from revengai.models.base_response_analysis_function_mapping import BaseResponseAnalysisFunctionMapping from revengai.models.base_response_analysis_functions import BaseResponseAnalysisFunctions from revengai.models.base_response_analysis_strings_response import BaseResponseAnalysisStringsResponse from revengai.models.base_response_analysis_tags import BaseResponseAnalysisTags @@ -204,6 +206,7 @@ from revengai.models.function_info_input_func_deps_inner import FunctionInfoInputFuncDepsInner from revengai.models.function_info_output import FunctionInfoOutput from revengai.models.function_local_variable_response import FunctionLocalVariableResponse +from revengai.models.function_mapping import FunctionMapping from revengai.models.function_mapping_full import FunctionMappingFull from revengai.models.function_name_confidence_body import FunctionNameConfidenceBody from revengai.models.function_name_history import FunctionNameHistory diff --git a/revengai/models/analysis_function_mapping.py b/revengai/models/analysis_function_mapping.py new file mode 100644 index 0000000..c86a9c9 --- /dev/null +++ b/revengai/models/analysis_function_mapping.py @@ -0,0 +1,90 @@ +# coding: utf-8 + +""" + RevEng.AI API + + RevEng.AI is Similarity Search Engine for executable binaries + + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field +from typing import Any, ClassVar, Dict, List +from revengai.models.function_mapping import FunctionMapping +from typing import Optional, Set +from typing_extensions import Self + +class AnalysisFunctionMapping(BaseModel): + """ + AnalysisFunctionMapping + """ # noqa: E501 + function_maps: FunctionMapping = Field(description="A map of function ids to function addresses for the analysis, and it's inverse.") + __properties: ClassVar[List[str]] = ["function_maps"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of AnalysisFunctionMapping from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + # override the default output from pydantic by calling `to_dict()` of function_maps + if self.function_maps: + _dict['function_maps'] = self.function_maps.to_dict() + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of AnalysisFunctionMapping from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "function_maps": FunctionMapping.from_dict(obj["function_maps"]) if obj.get("function_maps") is not None else None + }) + return _obj + + diff --git a/revengai/models/base_response_analysis_function_mapping.py b/revengai/models/base_response_analysis_function_mapping.py new file mode 100644 index 0000000..a20da7a --- /dev/null +++ b/revengai/models/base_response_analysis_function_mapping.py @@ -0,0 +1,125 @@ +# coding: utf-8 + +""" + RevEng.AI API + + RevEng.AI is Similarity Search Engine for executable binaries + + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr +from typing import Any, ClassVar, Dict, List, Optional +from revengai.models.analysis_function_mapping import AnalysisFunctionMapping +from revengai.models.error_model import ErrorModel +from revengai.models.meta_model import MetaModel +from typing import Optional, Set +from typing_extensions import Self + +class BaseResponseAnalysisFunctionMapping(BaseModel): + """ + BaseResponseAnalysisFunctionMapping + """ # noqa: E501 + status: Optional[StrictBool] = Field(default=True, description="Response status on whether the request succeeded") + data: Optional[AnalysisFunctionMapping] = None + message: Optional[StrictStr] = None + errors: Optional[List[ErrorModel]] = None + meta: Optional[MetaModel] = Field(default=None, description="Metadata") + __properties: ClassVar[List[str]] = ["status", "data", "message", "errors", "meta"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of BaseResponseAnalysisFunctionMapping from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + # override the default output from pydantic by calling `to_dict()` of data + if self.data: + _dict['data'] = self.data.to_dict() + # override the default output from pydantic by calling `to_dict()` of each item in errors (list) + _items = [] + if self.errors: + for _item_errors in self.errors: + if _item_errors: + _items.append(_item_errors.to_dict()) + _dict['errors'] = _items + # override the default output from pydantic by calling `to_dict()` of meta + if self.meta: + _dict['meta'] = self.meta.to_dict() + # set to None if data (nullable) is None + # and model_fields_set contains the field + if self.data is None and "data" in self.model_fields_set: + _dict['data'] = None + + # set to None if message (nullable) is None + # and model_fields_set contains the field + if self.message is None and "message" in self.model_fields_set: + _dict['message'] = None + + # set to None if errors (nullable) is None + # and model_fields_set contains the field + if self.errors is None and "errors" in self.model_fields_set: + _dict['errors'] = None + + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of BaseResponseAnalysisFunctionMapping from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "status": obj.get("status") if obj.get("status") is not None else True, + "data": AnalysisFunctionMapping.from_dict(obj["data"]) if obj.get("data") is not None else None, + "message": obj.get("message"), + "errors": [ErrorModel.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None, + "meta": MetaModel.from_dict(obj["meta"]) if obj.get("meta") is not None else None + }) + return _obj + + diff --git a/revengai/models/function_mapping.py b/revengai/models/function_mapping.py new file mode 100644 index 0000000..9eda874 --- /dev/null +++ b/revengai/models/function_mapping.py @@ -0,0 +1,88 @@ +# coding: utf-8 + +""" + RevEng.AI API + + RevEng.AI is Similarity Search Engine for executable binaries + + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictInt +from typing import Any, ClassVar, Dict, List +from typing import Optional, Set +from typing_extensions import Self + +class FunctionMapping(BaseModel): + """ + FunctionMapping + """ # noqa: E501 + function_map: Dict[str, StrictInt] = Field(description="Mapping of remote function ids to local function addresses") + inverse_function_map: Dict[str, StrictInt] = Field(description="Mapping of local function addresses to remote function ids") + __properties: ClassVar[List[str]] = ["function_map", "inverse_function_map"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of FunctionMapping from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of FunctionMapping from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "function_map": obj.get("function_map"), + "inverse_function_map": obj.get("inverse_function_map") + }) + return _obj + + diff --git a/test/test_analysis_function_mapping.py b/test/test_analysis_function_mapping.py new file mode 100644 index 0000000..cb69394 --- /dev/null +++ b/test/test_analysis_function_mapping.py @@ -0,0 +1,63 @@ +# coding: utf-8 + +""" + RevEng.AI API + + RevEng.AI is Similarity Search Engine for executable binaries + + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from revengai.models.analysis_function_mapping import AnalysisFunctionMapping + +class TestAnalysisFunctionMapping(unittest.TestCase): + """AnalysisFunctionMapping unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> AnalysisFunctionMapping: + """Test AnalysisFunctionMapping + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `AnalysisFunctionMapping` + """ + model = AnalysisFunctionMapping() + if include_optional: + return AnalysisFunctionMapping( + function_maps = revengai.models.function_mapping.FunctionMapping( + function_map = { + 'key' : 56 + }, + inverse_function_map = { + 'key' : 56 + }, ) + ) + else: + return AnalysisFunctionMapping( + function_maps = revengai.models.function_mapping.FunctionMapping( + function_map = { + 'key' : 56 + }, + inverse_function_map = { + 'key' : 56 + }, ), + ) + """ + + def testAnalysisFunctionMapping(self): + """Test AnalysisFunctionMapping""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_base_response_analysis_function_mapping.py b/test/test_base_response_analysis_function_mapping.py new file mode 100644 index 0000000..c8eb4ce --- /dev/null +++ b/test/test_base_response_analysis_function_mapping.py @@ -0,0 +1,69 @@ +# coding: utf-8 + +""" + RevEng.AI API + + RevEng.AI is Similarity Search Engine for executable binaries + + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from revengai.models.base_response_analysis_function_mapping import BaseResponseAnalysisFunctionMapping + +class TestBaseResponseAnalysisFunctionMapping(unittest.TestCase): + """BaseResponseAnalysisFunctionMapping unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> BaseResponseAnalysisFunctionMapping: + """Test BaseResponseAnalysisFunctionMapping + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `BaseResponseAnalysisFunctionMapping` + """ + model = BaseResponseAnalysisFunctionMapping() + if include_optional: + return BaseResponseAnalysisFunctionMapping( + status = True, + data = revengai.models.analysis_function_mapping.AnalysisFunctionMapping( + function_maps = revengai.models.function_mapping.FunctionMapping( + function_map = { + 'key' : 56 + }, + inverse_function_map = { + 'key' : 56 + }, ), ), + message = '', + errors = [ + revengai.models.error_model.ErrorModel( + code = '', + message = '', ) + ], + meta = revengai.models.meta_model.MetaModel( + pagination = revengai.models.pagination_model.PaginationModel( + page_size = 56, + page_number = 56, + has_next_page = True, ), ) + ) + else: + return BaseResponseAnalysisFunctionMapping( + ) + """ + + def testBaseResponseAnalysisFunctionMapping(self): + """Test BaseResponseAnalysisFunctionMapping""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_default_api.py b/test/test_default_api.py new file mode 100644 index 0000000..2690b8c --- /dev/null +++ b/test/test_default_api.py @@ -0,0 +1,37 @@ +# coding: utf-8 + +""" + RevEng.AI API + + RevEng.AI is Similarity Search Engine for executable binaries + + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from revengai.api.default_api import DefaultApi + + +class TestDefaultApi(unittest.TestCase): + """DefaultApi unit test stubs""" + + def setUp(self) -> None: + self.api = DefaultApi() + + def tearDown(self) -> None: + pass + + def test_get_analysis_function_map(self) -> None: + """Test case for get_analysis_function_map + + Get Analysis Function Map + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_function_mapping.py b/test/test_function_mapping.py new file mode 100644 index 0000000..14c3c6e --- /dev/null +++ b/test/test_function_mapping.py @@ -0,0 +1,61 @@ +# coding: utf-8 + +""" + RevEng.AI API + + RevEng.AI is Similarity Search Engine for executable binaries + + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from revengai.models.function_mapping import FunctionMapping + +class TestFunctionMapping(unittest.TestCase): + """FunctionMapping unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> FunctionMapping: + """Test FunctionMapping + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `FunctionMapping` + """ + model = FunctionMapping() + if include_optional: + return FunctionMapping( + function_map = { + 'key' : 56 + }, + inverse_function_map = { + 'key' : 56 + } + ) + else: + return FunctionMapping( + function_map = { + 'key' : 56 + }, + inverse_function_map = { + 'key' : 56 + }, + ) + """ + + def testFunctionMapping(self): + """Test FunctionMapping""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main()