revengai 1.85.0__py3-none-any.whl → 1.88.0__py3-none-any.whl

revengai/api/functions_core_api.py

@@ -19,6 +19,7 @@ from pydantic import Field, StrictBool, StrictInt, StrictStr, field_validator
 from typing import List, Optional, Union
 from typing_extensions import Annotated
 from revengai.models.ai_unstrip_request import AiUnstripRequest
+from revengai.models.analysis_function_matching_request import AnalysisFunctionMatchingRequest
 from revengai.models.auto_unstrip_request import AutoUnstripRequest
 from revengai.models.auto_unstrip_response import AutoUnstripResponse
 from revengai.models.base_response_analysis_strings_response import BaseResponseAnalysisStringsResponse
@@ -28,6 +29,8 @@ from revengai.models.base_response_function_capability_response import BaseRespo
 from revengai.models.base_response_function_strings_response import BaseResponseFunctionStringsResponse
 from revengai.models.base_response_functions_detail_response import BaseResponseFunctionsDetailResponse
 from revengai.models.base_response_list_similar_functions_response import BaseResponseListSimilarFunctionsResponse
+from revengai.models.function_matching_batch_request import FunctionMatchingBatchRequest
+from revengai.models.function_matching_batch_response import FunctionMatchingBatchResponse
 
 from revengai.api_client import ApiClient, RequestSerialized
 from revengai.api_response import ApiResponse
@@ -354,6 +357,313 @@ class FunctionsCoreApi:
 
 
 
+    @validate_call
+    def analysis_function_matching(
+        self,
+        analysis_id: StrictInt,
+        analysis_function_matching_request: AnalysisFunctionMatchingRequest,
+        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,
+    ) -> FunctionMatchingBatchResponse:
+        """Perform matching for the functions of an analysis
+
+        Takes in an analysis id and settings and finds the nearest functions for each function that's within the system
+
+        :param analysis_id: (required)
+        :type analysis_id: int
+        :param analysis_function_matching_request: (required)
+        :type analysis_function_matching_request: AnalysisFunctionMatchingRequest
+        :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._analysis_function_matching_serialize(
+            analysis_id=analysis_id,
+            analysis_function_matching_request=analysis_function_matching_request,
+            authorization=authorization,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "FunctionMatchingBatchResponse",
+            '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 analysis_function_matching_with_http_info(
+        self,
+        analysis_id: StrictInt,
+        analysis_function_matching_request: AnalysisFunctionMatchingRequest,
+        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[FunctionMatchingBatchResponse]:
+        """Perform matching for the functions of an analysis
+
+        Takes in an analysis id and settings and finds the nearest functions for each function that's within the system
+
+        :param analysis_id: (required)
+        :type analysis_id: int
+        :param analysis_function_matching_request: (required)
+        :type analysis_function_matching_request: AnalysisFunctionMatchingRequest
+        :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._analysis_function_matching_serialize(
+            analysis_id=analysis_id,
+            analysis_function_matching_request=analysis_function_matching_request,
+            authorization=authorization,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "FunctionMatchingBatchResponse",
+            '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 analysis_function_matching_without_preload_content(
+        self,
+        analysis_id: StrictInt,
+        analysis_function_matching_request: AnalysisFunctionMatchingRequest,
+        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:
+        """Perform matching for the functions of an analysis
+
+        Takes in an analysis id and settings and finds the nearest functions for each function that's within the system
+
+        :param analysis_id: (required)
+        :type analysis_id: int
+        :param analysis_function_matching_request: (required)
+        :type analysis_function_matching_request: AnalysisFunctionMatchingRequest
+        :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._analysis_function_matching_serialize(
+            analysis_id=analysis_id,
+            analysis_function_matching_request=analysis_function_matching_request,
+            authorization=authorization,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "FunctionMatchingBatchResponse",
+            '422': "BaseResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _analysis_function_matching_serialize(
+        self,
+        analysis_id,
+        analysis_function_matching_request,
+        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
+        if analysis_function_matching_request is not None:
+            _body_params = analysis_function_matching_request
+
+
+        # 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(
+                    [
+                        'application/json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'APIKey'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/v2/analyses/{analysis_id}/functions/matches',
+            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
+        )
+
+
+
+
     @validate_call
     def auto_unstrip(
         self,
@@ -372,7 +682,83 @@ class FunctionsCoreApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> AutoUnstripResponse:
+    ) -> AutoUnstripResponse:
+        """Performs matching and auto-unstrip for an analysis and its functions
+
+        Takes in the analysis ID, uses the functions ID's from it and settings to find the nearest function for each function that's within the system
+
+        :param analysis_id: (required)
+        :type analysis_id: int
+        :param auto_unstrip_request: (required)
+        :type auto_unstrip_request: AutoUnstripRequest
+        :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._auto_unstrip_serialize(
+            analysis_id=analysis_id,
+            auto_unstrip_request=auto_unstrip_request,
+            authorization=authorization,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "AutoUnstripResponse",
+            '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 auto_unstrip_with_http_info(
+        self,
+        analysis_id: StrictInt,
+        auto_unstrip_request: AutoUnstripRequest,
+        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[AutoUnstripResponse]:
         """Performs matching and auto-unstrip for an analysis and its functions
 
         Takes in the analysis ID, uses the functions ID's from it and settings to find the nearest function for each function that's within the system
@@ -427,11 +813,11 @@ class FunctionsCoreApi:
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
-        ).data
+        )
 
 
     @validate_call
-    def auto_unstrip_with_http_info(
+    def auto_unstrip_without_preload_content(
         self,
         analysis_id: StrictInt,
         auto_unstrip_request: AutoUnstripRequest,
@@ -448,7 +834,7 @@ class FunctionsCoreApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[AutoUnstripResponse]:
+    ) -> RESTResponseType:
         """Performs matching and auto-unstrip for an analysis and its functions
 
         Takes in the analysis ID, uses the functions ID's from it and settings to find the nearest function for each function that's within the system
@@ -499,6 +885,229 @@ class FunctionsCoreApi:
             *_param,
             _request_timeout=_request_timeout
         )
+        return response_data.response
+
+
+    def _auto_unstrip_serialize(
+        self,
+        analysis_id,
+        auto_unstrip_request,
+        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
+        if auto_unstrip_request is not None:
+            _body_params = auto_unstrip_request
+
+
+        # 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(
+                    [
+                        'application/json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'APIKey'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/v2/analyses/{analysis_id}/functions/auto-unstrip',
+            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
+        )
+
+
+
+
+    @validate_call
+    def batch_function_matching(
+        self,
+        function_matching_batch_request: FunctionMatchingBatchRequest,
+        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,
+    ) -> FunctionMatchingBatchResponse:
+        """Perform function matching for an arbitrary batch of functions, binaries or collections
+
+        Takes in an input of functions ID's and settings and finds the nearest functions for each function that's within the system
+
+        :param function_matching_batch_request: (required)
+        :type function_matching_batch_request: FunctionMatchingBatchRequest
+        :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._batch_function_matching_serialize(
+            function_matching_batch_request=function_matching_batch_request,
+            authorization=authorization,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "FunctionMatchingBatchResponse",
+            '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 batch_function_matching_with_http_info(
+        self,
+        function_matching_batch_request: FunctionMatchingBatchRequest,
+        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[FunctionMatchingBatchResponse]:
+        """Perform function matching for an arbitrary batch of functions, binaries or collections
+
+        Takes in an input of functions ID's and settings and finds the nearest functions for each function that's within the system
+
+        :param function_matching_batch_request: (required)
+        :type function_matching_batch_request: FunctionMatchingBatchRequest
+        :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._batch_function_matching_serialize(
+            function_matching_batch_request=function_matching_batch_request,
+            authorization=authorization,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "FunctionMatchingBatchResponse",
+            '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,
@@ -507,10 +1116,9 @@ class FunctionsCoreApi:
 
 
     @validate_call
-    def auto_unstrip_without_preload_content(
+    def batch_function_matching_without_preload_content(
         self,
-        analysis_id: StrictInt,
-        auto_unstrip_request: AutoUnstripRequest,
+        function_matching_batch_request: FunctionMatchingBatchRequest,
         authorization: Annotated[Optional[StrictStr], Field(description="API Key bearer token")] = None,
         _request_timeout: Union[
             None,
@@ -525,14 +1133,12 @@ class FunctionsCoreApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Performs matching and auto-unstrip for an analysis and its functions
+        """Perform function matching for an arbitrary batch of functions, binaries or collections
 
-        Takes in the analysis ID, uses the functions ID's from it and settings to find the nearest function for each function that's within the system
+        Takes in an input of functions ID's and settings and finds the nearest functions for each function that's within the system
 
-        :param analysis_id: (required)
-        :type analysis_id: int
-        :param auto_unstrip_request: (required)
-        :type auto_unstrip_request: AutoUnstripRequest
+        :param function_matching_batch_request: (required)
+        :type function_matching_batch_request: FunctionMatchingBatchRequest
         :param authorization: API Key bearer token
         :type authorization: str
         :param _request_timeout: timeout setting for this request. If one
@@ -557,9 +1163,8 @@ class FunctionsCoreApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._auto_unstrip_serialize(
-            analysis_id=analysis_id,
-            auto_unstrip_request=auto_unstrip_request,
+        _param = self._batch_function_matching_serialize(
+            function_matching_batch_request=function_matching_batch_request,
             authorization=authorization,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -568,7 +1173,7 @@ class FunctionsCoreApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "AutoUnstripResponse",
+            '200': "FunctionMatchingBatchResponse",
             '422': "BaseResponse",
         }
         response_data = self.api_client.call_api(
@@ -578,10 +1183,9 @@ class FunctionsCoreApi:
         return response_data.response
 
 
-    def _auto_unstrip_serialize(
+    def _batch_function_matching_serialize(
         self,
-        analysis_id,
-        auto_unstrip_request,
+        function_matching_batch_request,
         authorization,
         _request_auth,
         _content_type,
@@ -604,16 +1208,14 @@ class FunctionsCoreApi:
         _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
-        if auto_unstrip_request is not None:
-            _body_params = auto_unstrip_request
+        if function_matching_batch_request is not None:
+            _body_params = function_matching_batch_request
 
 
         # set the HTTP header `Accept`
@@ -645,7 +1247,7 @@ class FunctionsCoreApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/v2/analyses/{analysis_id}/functions/auto-unstrip',
+            resource_path='/v2/functions/matches',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,