# coding: utf-8

"""
ME TT DataPortal Data Portal API

ME TT DataPortal Data Portal APIs to fetch Gut Microbes Genomes / Genes information.

The version of the OpenAPI document: 1.0.0
Generated by OpenAPI Generator (https://openapi-generator.tech)

Do not edit the class manually.
"""  # noqa: E501

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 StrictBool
from mett_dataportal_sdk.models.ppi_all_neighbors_response_schema import (
    PPIAllNeighborsResponseSchema,
)
from mett_dataportal_sdk.models.ppi_network_properties_response_schema import (
    PPINetworkPropertiesResponseSchema,
)
from mett_dataportal_sdk.models.ppi_network_response_schema import (
    PPINetworkResponseSchema,
)
from mett_dataportal_sdk.models.ppi_score_types_response_schema import (
    PPIScoreTypesResponseSchema,
)
from mett_dataportal_sdk.models.ppi_search_response_schema import (
    PPISearchResponseSchema,
)

from mett_dataportal_sdk.api_client import ApiClient, RequestSerialized
from mett_dataportal_sdk.api_response import ApiResponse
from mett_dataportal_sdk.rest import RESTResponseType


class ProteinProteinInteractionsApi:
    """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 dataportal_api_interactions_ppi_endpoints_get_all_protein_neighbors(
        self,
        protein_id: Annotated[
            Optional[StrictStr], Field(description="UniProt ID of the protein")
        ] = None,
        locus_tag: Annotated[
            Optional[StrictStr], Field(description="Locus tag of the protein")
        ] = None,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym filter")
        ] = 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,
    ) -> PPIAllNeighborsResponseSchema:
        """Get all protein neighbors (raw data)

        Get all neighbors for a specific protein without algorithm processing. Returns raw interaction data for custom analysis in Jupyter notebooks. Can search by protein_id (UniProt ID) or locus_tag.

        :param protein_id: UniProt ID of the protein
        :type protein_id: str
        :param locus_tag: Locus tag of the protein
        :type locus_tag: str
        :param species_acronym: Species acronym filter
        :type species_acronym: 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._dataportal_api_interactions_ppi_endpoints_get_all_protein_neighbors_serialize(
            protein_id=protein_id,
            locus_tag=locus_tag,
            species_acronym=species_acronym,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPIAllNeighborsResponseSchema",
        }
        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 dataportal_api_interactions_ppi_endpoints_get_all_protein_neighbors_with_http_info(
        self,
        protein_id: Annotated[
            Optional[StrictStr], Field(description="UniProt ID of the protein")
        ] = None,
        locus_tag: Annotated[
            Optional[StrictStr], Field(description="Locus tag of the protein")
        ] = None,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym filter")
        ] = 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[PPIAllNeighborsResponseSchema]:
        """Get all protein neighbors (raw data)

        Get all neighbors for a specific protein without algorithm processing. Returns raw interaction data for custom analysis in Jupyter notebooks. Can search by protein_id (UniProt ID) or locus_tag.

        :param protein_id: UniProt ID of the protein
        :type protein_id: str
        :param locus_tag: Locus tag of the protein
        :type locus_tag: str
        :param species_acronym: Species acronym filter
        :type species_acronym: 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._dataportal_api_interactions_ppi_endpoints_get_all_protein_neighbors_serialize(
            protein_id=protein_id,
            locus_tag=locus_tag,
            species_acronym=species_acronym,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPIAllNeighborsResponseSchema",
        }
        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 dataportal_api_interactions_ppi_endpoints_get_all_protein_neighbors_without_preload_content(
        self,
        protein_id: Annotated[
            Optional[StrictStr], Field(description="UniProt ID of the protein")
        ] = None,
        locus_tag: Annotated[
            Optional[StrictStr], Field(description="Locus tag of the protein")
        ] = None,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym filter")
        ] = 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 all protein neighbors (raw data)

        Get all neighbors for a specific protein without algorithm processing. Returns raw interaction data for custom analysis in Jupyter notebooks. Can search by protein_id (UniProt ID) or locus_tag.

        :param protein_id: UniProt ID of the protein
        :type protein_id: str
        :param locus_tag: Locus tag of the protein
        :type locus_tag: str
        :param species_acronym: Species acronym filter
        :type species_acronym: 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._dataportal_api_interactions_ppi_endpoints_get_all_protein_neighbors_serialize(
            protein_id=protein_id,
            locus_tag=locus_tag,
            species_acronym=species_acronym,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPIAllNeighborsResponseSchema",
        }
        response_data = self.api_client.call_api(
            *_param, _request_timeout=_request_timeout
        )
        return response_data.response

    def _dataportal_api_interactions_ppi_endpoints_get_all_protein_neighbors_serialize(
        self,
        protein_id,
        locus_tag,
        species_acronym,
        _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
        # process the query parameters
        if protein_id is not None:
            _query_params.append(("protein_id", protein_id))

        if locus_tag is not None:
            _query_params.append(("locus_tag", locus_tag))

        if species_acronym is not None:
            _query_params.append(("species_acronym", species_acronym))

        # process the header parameters
        # 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] = ["RoleBasedJWTAuth"]

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/api/ppi/neighbors",
            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 dataportal_api_interactions_ppi_endpoints_get_available_score_types(
        self,
        _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,
    ) -> PPIScoreTypesResponseSchema:
        """Get available score types

        Get list of available score types for PPI filtering

        :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._dataportal_api_interactions_ppi_endpoints_get_available_score_types_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPIScoreTypesResponseSchema",
        }
        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 dataportal_api_interactions_ppi_endpoints_get_available_score_types_with_http_info(
        self,
        _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[PPIScoreTypesResponseSchema]:
        """Get available score types

        Get list of available score types for PPI filtering

        :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._dataportal_api_interactions_ppi_endpoints_get_available_score_types_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPIScoreTypesResponseSchema",
        }
        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 dataportal_api_interactions_ppi_endpoints_get_available_score_types_without_preload_content(
        self,
        _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 available score types

        Get list of available score types for PPI filtering

        :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._dataportal_api_interactions_ppi_endpoints_get_available_score_types_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPIScoreTypesResponseSchema",
        }
        response_data = self.api_client.call_api(
            *_param, _request_timeout=_request_timeout
        )
        return response_data.response

    def _dataportal_api_interactions_ppi_endpoints_get_available_score_types_serialize(
        self,
        _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
        # process the query parameters
        # process the header parameters
        # 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] = ["RoleBasedJWTAuth"]

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/api/ppi/scores/available",
            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 dataportal_api_interactions_ppi_endpoints_get_ppi_network(
        self,
        score_type: StrictStr,
        score_threshold: Annotated[
            Optional[
                Union[
                    Annotated[float, Field(le=1, strict=True, ge=0)],
                    Annotated[int, Field(le=1, strict=True, ge=0)],
                ]
            ],
            Field(description="Score threshold for network construction"),
        ] = None,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym filter")
        ] = None,
        include_properties: Annotated[
            Optional[StrictBool],
            Field(description="Whether to include network properties"),
        ] = 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,
    ) -> PPINetworkResponseSchema:
        """Get PPI network data

        Get network data for a specific score type and threshold

        :param score_type: (required)
        :type score_type: str
        :param score_threshold: Score threshold for network construction
        :type score_threshold: float
        :param species_acronym: Species acronym filter
        :type species_acronym: str
        :param include_properties: Whether to include network properties
        :type include_properties: bool
        :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._dataportal_api_interactions_ppi_endpoints_get_ppi_network_serialize(
                score_type=score_type,
                score_threshold=score_threshold,
                species_acronym=species_acronym,
                include_properties=include_properties,
                _request_auth=_request_auth,
                _content_type=_content_type,
                _headers=_headers,
                _host_index=_host_index,
            )
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPINetworkResponseSchema",
        }
        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 dataportal_api_interactions_ppi_endpoints_get_ppi_network_with_http_info(
        self,
        score_type: StrictStr,
        score_threshold: Annotated[
            Optional[
                Union[
                    Annotated[float, Field(le=1, strict=True, ge=0)],
                    Annotated[int, Field(le=1, strict=True, ge=0)],
                ]
            ],
            Field(description="Score threshold for network construction"),
        ] = None,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym filter")
        ] = None,
        include_properties: Annotated[
            Optional[StrictBool],
            Field(description="Whether to include network properties"),
        ] = 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[PPINetworkResponseSchema]:
        """Get PPI network data

        Get network data for a specific score type and threshold

        :param score_type: (required)
        :type score_type: str
        :param score_threshold: Score threshold for network construction
        :type score_threshold: float
        :param species_acronym: Species acronym filter
        :type species_acronym: str
        :param include_properties: Whether to include network properties
        :type include_properties: bool
        :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._dataportal_api_interactions_ppi_endpoints_get_ppi_network_serialize(
                score_type=score_type,
                score_threshold=score_threshold,
                species_acronym=species_acronym,
                include_properties=include_properties,
                _request_auth=_request_auth,
                _content_type=_content_type,
                _headers=_headers,
                _host_index=_host_index,
            )
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPINetworkResponseSchema",
        }
        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 dataportal_api_interactions_ppi_endpoints_get_ppi_network_without_preload_content(
        self,
        score_type: StrictStr,
        score_threshold: Annotated[
            Optional[
                Union[
                    Annotated[float, Field(le=1, strict=True, ge=0)],
                    Annotated[int, Field(le=1, strict=True, ge=0)],
                ]
            ],
            Field(description="Score threshold for network construction"),
        ] = None,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym filter")
        ] = None,
        include_properties: Annotated[
            Optional[StrictBool],
            Field(description="Whether to include network properties"),
        ] = 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 PPI network data

        Get network data for a specific score type and threshold

        :param score_type: (required)
        :type score_type: str
        :param score_threshold: Score threshold for network construction
        :type score_threshold: float
        :param species_acronym: Species acronym filter
        :type species_acronym: str
        :param include_properties: Whether to include network properties
        :type include_properties: bool
        :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._dataportal_api_interactions_ppi_endpoints_get_ppi_network_serialize(
                score_type=score_type,
                score_threshold=score_threshold,
                species_acronym=species_acronym,
                include_properties=include_properties,
                _request_auth=_request_auth,
                _content_type=_content_type,
                _headers=_headers,
                _host_index=_host_index,
            )
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPINetworkResponseSchema",
        }
        response_data = self.api_client.call_api(
            *_param, _request_timeout=_request_timeout
        )
        return response_data.response

    def _dataportal_api_interactions_ppi_endpoints_get_ppi_network_serialize(
        self,
        score_type,
        score_threshold,
        species_acronym,
        include_properties,
        _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 score_type is not None:
            _path_params["score_type"] = score_type
        # process the query parameters
        if score_threshold is not None:
            _query_params.append(("score_threshold", score_threshold))

        if species_acronym is not None:
            _query_params.append(("species_acronym", species_acronym))

        if include_properties is not None:
            _query_params.append(("include_properties", include_properties))

        # process the header parameters
        # 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] = ["RoleBasedJWTAuth"]

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/api/ppi/network/{score_type}",
            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 dataportal_api_interactions_ppi_endpoints_get_ppi_network_properties(
        self,
        score_type: Annotated[
            StrictStr, Field(description="Score type for network construction")
        ],
        score_threshold: Annotated[
            Optional[
                Union[
                    Annotated[float, Field(le=1, strict=True, ge=0)],
                    Annotated[int, Field(le=1, strict=True, ge=0)],
                ]
            ],
            Field(description="Score threshold for network construction"),
        ] = None,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym filter")
        ] = 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,
    ) -> PPINetworkPropertiesResponseSchema:
        """Get PPI network properties

        Get network properties (nodes, edges, density, clustering) for a specific score type and threshold

        :param score_type: Score type for network construction (required)
        :type score_type: str
        :param score_threshold: Score threshold for network construction
        :type score_threshold: float
        :param species_acronym: Species acronym filter
        :type species_acronym: 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._dataportal_api_interactions_ppi_endpoints_get_ppi_network_properties_serialize(
            score_type=score_type,
            score_threshold=score_threshold,
            species_acronym=species_acronym,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPINetworkPropertiesResponseSchema",
        }
        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 dataportal_api_interactions_ppi_endpoints_get_ppi_network_properties_with_http_info(
        self,
        score_type: Annotated[
            StrictStr, Field(description="Score type for network construction")
        ],
        score_threshold: Annotated[
            Optional[
                Union[
                    Annotated[float, Field(le=1, strict=True, ge=0)],
                    Annotated[int, Field(le=1, strict=True, ge=0)],
                ]
            ],
            Field(description="Score threshold for network construction"),
        ] = None,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym filter")
        ] = 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[PPINetworkPropertiesResponseSchema]:
        """Get PPI network properties

        Get network properties (nodes, edges, density, clustering) for a specific score type and threshold

        :param score_type: Score type for network construction (required)
        :type score_type: str
        :param score_threshold: Score threshold for network construction
        :type score_threshold: float
        :param species_acronym: Species acronym filter
        :type species_acronym: 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._dataportal_api_interactions_ppi_endpoints_get_ppi_network_properties_serialize(
            score_type=score_type,
            score_threshold=score_threshold,
            species_acronym=species_acronym,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPINetworkPropertiesResponseSchema",
        }
        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 dataportal_api_interactions_ppi_endpoints_get_ppi_network_properties_without_preload_content(
        self,
        score_type: Annotated[
            StrictStr, Field(description="Score type for network construction")
        ],
        score_threshold: Annotated[
            Optional[
                Union[
                    Annotated[float, Field(le=1, strict=True, ge=0)],
                    Annotated[int, Field(le=1, strict=True, ge=0)],
                ]
            ],
            Field(description="Score threshold for network construction"),
        ] = None,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym filter")
        ] = 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 PPI network properties

        Get network properties (nodes, edges, density, clustering) for a specific score type and threshold

        :param score_type: Score type for network construction (required)
        :type score_type: str
        :param score_threshold: Score threshold for network construction
        :type score_threshold: float
        :param species_acronym: Species acronym filter
        :type species_acronym: 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._dataportal_api_interactions_ppi_endpoints_get_ppi_network_properties_serialize(
            score_type=score_type,
            score_threshold=score_threshold,
            species_acronym=species_acronym,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPINetworkPropertiesResponseSchema",
        }
        response_data = self.api_client.call_api(
            *_param, _request_timeout=_request_timeout
        )
        return response_data.response

    def _dataportal_api_interactions_ppi_endpoints_get_ppi_network_properties_serialize(
        self,
        score_type,
        score_threshold,
        species_acronym,
        _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
        # process the query parameters
        if score_type is not None:
            _query_params.append(("score_type", score_type))

        if score_threshold is not None:
            _query_params.append(("score_threshold", score_threshold))

        if species_acronym is not None:
            _query_params.append(("species_acronym", species_acronym))

        # process the header parameters
        # 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] = ["RoleBasedJWTAuth"]

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/api/ppi/network-properties",
            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 dataportal_api_interactions_ppi_endpoints_search_ppi_interactions(
        self,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym (e.g., 'PV', 'BU')")
        ] = None,
        isolate_name: Annotated[
            Optional[StrictStr],
            Field(description="Isolate name (e.g., 'BU_ATCC8492', 'PV_ATCC8482')"),
        ] = None,
        score_type: Annotated[
            Optional[StrictStr], Field(description="Score type to filter by")
        ] = None,
        score_threshold: Annotated[
            Optional[Union[StrictFloat, StrictInt]],
            Field(description="Minimum score threshold"),
        ] = None,
        has_xlms: Annotated[
            Optional[StrictBool], Field(description="Filter by XL-MS evidence")
        ] = None,
        has_string: Annotated[
            Optional[StrictBool], Field(description="Filter by STRING evidence")
        ] = None,
        has_operon: Annotated[
            Optional[StrictBool], Field(description="Filter by operon evidence")
        ] = None,
        has_ecocyc: Annotated[
            Optional[StrictBool], Field(description="Filter by EcoCyc evidence")
        ] = None,
        protein_id: Annotated[
            Optional[StrictStr],
            Field(description="Filter interactions involving specific protein"),
        ] = None,
        locus_tag: Annotated[
            Optional[StrictStr],
            Field(description="Filter interactions involving specific locus tag"),
        ] = None,
        page: Annotated[
            Optional[Annotated[int, Field(strict=True, ge=1)]],
            Field(description="Page number"),
        ] = None,
        per_page: Annotated[
            Optional[Annotated[int, Field(le=100000, strict=True, ge=1)]],
            Field(description="Results per page"),
        ] = 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,
    ) -> PPISearchResponseSchema:
        """Search protein-protein interactions

        Search for protein-protein interactions with various filtering options. Can search by protein_id (UniProt ID) or locus_tag.

        :param species_acronym: Species acronym (e.g., 'PV', 'BU')
        :type species_acronym: str
        :param isolate_name: Isolate name (e.g., 'BU_ATCC8492', 'PV_ATCC8482')
        :type isolate_name: str
        :param score_type: Score type to filter by
        :type score_type: str
        :param score_threshold: Minimum score threshold
        :type score_threshold: float
        :param has_xlms: Filter by XL-MS evidence
        :type has_xlms: bool
        :param has_string: Filter by STRING evidence
        :type has_string: bool
        :param has_operon: Filter by operon evidence
        :type has_operon: bool
        :param has_ecocyc: Filter by EcoCyc evidence
        :type has_ecocyc: bool
        :param protein_id: Filter interactions involving specific protein
        :type protein_id: str
        :param locus_tag: Filter interactions involving specific locus tag
        :type locus_tag: str
        :param page: Page number
        :type page: int
        :param per_page: Results per page
        :type per_page: int
        :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._dataportal_api_interactions_ppi_endpoints_search_ppi_interactions_serialize(
            species_acronym=species_acronym,
            isolate_name=isolate_name,
            score_type=score_type,
            score_threshold=score_threshold,
            has_xlms=has_xlms,
            has_string=has_string,
            has_operon=has_operon,
            has_ecocyc=has_ecocyc,
            protein_id=protein_id,
            locus_tag=locus_tag,
            page=page,
            per_page=per_page,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPISearchResponseSchema",
        }
        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 dataportal_api_interactions_ppi_endpoints_search_ppi_interactions_with_http_info(
        self,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym (e.g., 'PV', 'BU')")
        ] = None,
        isolate_name: Annotated[
            Optional[StrictStr],
            Field(description="Isolate name (e.g., 'BU_ATCC8492', 'PV_ATCC8482')"),
        ] = None,
        score_type: Annotated[
            Optional[StrictStr], Field(description="Score type to filter by")
        ] = None,
        score_threshold: Annotated[
            Optional[Union[StrictFloat, StrictInt]],
            Field(description="Minimum score threshold"),
        ] = None,
        has_xlms: Annotated[
            Optional[StrictBool], Field(description="Filter by XL-MS evidence")
        ] = None,
        has_string: Annotated[
            Optional[StrictBool], Field(description="Filter by STRING evidence")
        ] = None,
        has_operon: Annotated[
            Optional[StrictBool], Field(description="Filter by operon evidence")
        ] = None,
        has_ecocyc: Annotated[
            Optional[StrictBool], Field(description="Filter by EcoCyc evidence")
        ] = None,
        protein_id: Annotated[
            Optional[StrictStr],
            Field(description="Filter interactions involving specific protein"),
        ] = None,
        locus_tag: Annotated[
            Optional[StrictStr],
            Field(description="Filter interactions involving specific locus tag"),
        ] = None,
        page: Annotated[
            Optional[Annotated[int, Field(strict=True, ge=1)]],
            Field(description="Page number"),
        ] = None,
        per_page: Annotated[
            Optional[Annotated[int, Field(le=100000, strict=True, ge=1)]],
            Field(description="Results per page"),
        ] = 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[PPISearchResponseSchema]:
        """Search protein-protein interactions

        Search for protein-protein interactions with various filtering options. Can search by protein_id (UniProt ID) or locus_tag.

        :param species_acronym: Species acronym (e.g., 'PV', 'BU')
        :type species_acronym: str
        :param isolate_name: Isolate name (e.g., 'BU_ATCC8492', 'PV_ATCC8482')
        :type isolate_name: str
        :param score_type: Score type to filter by
        :type score_type: str
        :param score_threshold: Minimum score threshold
        :type score_threshold: float
        :param has_xlms: Filter by XL-MS evidence
        :type has_xlms: bool
        :param has_string: Filter by STRING evidence
        :type has_string: bool
        :param has_operon: Filter by operon evidence
        :type has_operon: bool
        :param has_ecocyc: Filter by EcoCyc evidence
        :type has_ecocyc: bool
        :param protein_id: Filter interactions involving specific protein
        :type protein_id: str
        :param locus_tag: Filter interactions involving specific locus tag
        :type locus_tag: str
        :param page: Page number
        :type page: int
        :param per_page: Results per page
        :type per_page: int
        :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._dataportal_api_interactions_ppi_endpoints_search_ppi_interactions_serialize(
            species_acronym=species_acronym,
            isolate_name=isolate_name,
            score_type=score_type,
            score_threshold=score_threshold,
            has_xlms=has_xlms,
            has_string=has_string,
            has_operon=has_operon,
            has_ecocyc=has_ecocyc,
            protein_id=protein_id,
            locus_tag=locus_tag,
            page=page,
            per_page=per_page,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPISearchResponseSchema",
        }
        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 dataportal_api_interactions_ppi_endpoints_search_ppi_interactions_without_preload_content(
        self,
        species_acronym: Annotated[
            Optional[StrictStr], Field(description="Species acronym (e.g., 'PV', 'BU')")
        ] = None,
        isolate_name: Annotated[
            Optional[StrictStr],
            Field(description="Isolate name (e.g., 'BU_ATCC8492', 'PV_ATCC8482')"),
        ] = None,
        score_type: Annotated[
            Optional[StrictStr], Field(description="Score type to filter by")
        ] = None,
        score_threshold: Annotated[
            Optional[Union[StrictFloat, StrictInt]],
            Field(description="Minimum score threshold"),
        ] = None,
        has_xlms: Annotated[
            Optional[StrictBool], Field(description="Filter by XL-MS evidence")
        ] = None,
        has_string: Annotated[
            Optional[StrictBool], Field(description="Filter by STRING evidence")
        ] = None,
        has_operon: Annotated[
            Optional[StrictBool], Field(description="Filter by operon evidence")
        ] = None,
        has_ecocyc: Annotated[
            Optional[StrictBool], Field(description="Filter by EcoCyc evidence")
        ] = None,
        protein_id: Annotated[
            Optional[StrictStr],
            Field(description="Filter interactions involving specific protein"),
        ] = None,
        locus_tag: Annotated[
            Optional[StrictStr],
            Field(description="Filter interactions involving specific locus tag"),
        ] = None,
        page: Annotated[
            Optional[Annotated[int, Field(strict=True, ge=1)]],
            Field(description="Page number"),
        ] = None,
        per_page: Annotated[
            Optional[Annotated[int, Field(le=100000, strict=True, ge=1)]],
            Field(description="Results per page"),
        ] = 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:
        """Search protein-protein interactions

        Search for protein-protein interactions with various filtering options. Can search by protein_id (UniProt ID) or locus_tag.

        :param species_acronym: Species acronym (e.g., 'PV', 'BU')
        :type species_acronym: str
        :param isolate_name: Isolate name (e.g., 'BU_ATCC8492', 'PV_ATCC8482')
        :type isolate_name: str
        :param score_type: Score type to filter by
        :type score_type: str
        :param score_threshold: Minimum score threshold
        :type score_threshold: float
        :param has_xlms: Filter by XL-MS evidence
        :type has_xlms: bool
        :param has_string: Filter by STRING evidence
        :type has_string: bool
        :param has_operon: Filter by operon evidence
        :type has_operon: bool
        :param has_ecocyc: Filter by EcoCyc evidence
        :type has_ecocyc: bool
        :param protein_id: Filter interactions involving specific protein
        :type protein_id: str
        :param locus_tag: Filter interactions involving specific locus tag
        :type locus_tag: str
        :param page: Page number
        :type page: int
        :param per_page: Results per page
        :type per_page: int
        :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._dataportal_api_interactions_ppi_endpoints_search_ppi_interactions_serialize(
            species_acronym=species_acronym,
            isolate_name=isolate_name,
            score_type=score_type,
            score_threshold=score_threshold,
            has_xlms=has_xlms,
            has_string=has_string,
            has_operon=has_operon,
            has_ecocyc=has_ecocyc,
            protein_id=protein_id,
            locus_tag=locus_tag,
            page=page,
            per_page=per_page,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "PPISearchResponseSchema",
        }
        response_data = self.api_client.call_api(
            *_param, _request_timeout=_request_timeout
        )
        return response_data.response

    def _dataportal_api_interactions_ppi_endpoints_search_ppi_interactions_serialize(
        self,
        species_acronym,
        isolate_name,
        score_type,
        score_threshold,
        has_xlms,
        has_string,
        has_operon,
        has_ecocyc,
        protein_id,
        locus_tag,
        page,
        per_page,
        _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
        # process the query parameters
        if species_acronym is not None:
            _query_params.append(("species_acronym", species_acronym))

        if isolate_name is not None:
            _query_params.append(("isolate_name", isolate_name))

        if score_type is not None:
            _query_params.append(("score_type", score_type))

        if score_threshold is not None:
            _query_params.append(("score_threshold", score_threshold))

        if has_xlms is not None:
            _query_params.append(("has_xlms", has_xlms))

        if has_string is not None:
            _query_params.append(("has_string", has_string))

        if has_operon is not None:
            _query_params.append(("has_operon", has_operon))

        if has_ecocyc is not None:
            _query_params.append(("has_ecocyc", has_ecocyc))

        if protein_id is not None:
            _query_params.append(("protein_id", protein_id))

        if locus_tag is not None:
            _query_params.append(("locus_tag", locus_tag))

        if page is not None:
            _query_params.append(("page", page))

        if per_page is not None:
            _query_params.append(("per_page", per_page))

        # process the header parameters
        # 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] = ["RoleBasedJWTAuth"]

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/api/ppi/interactions",
            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,
        )
