plex-api-client 0.6.1__py3-none-any.whl

plex_api/plex.py

@@ -0,0 +1,154 @@
+"""Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT."""
+
+import requests as requests_http
+from .sdkconfiguration import SDKConfiguration
+from plex_api import utils
+from plex_api._hooks import AfterErrorContext, AfterSuccessContext, BeforeRequestContext, HookContext
+from plex_api.models import errors, operations
+from typing import Optional
+
+class Plex:
+    r"""API Calls that perform operations directly against https://Plex.tv"""
+    sdk_configuration: SDKConfiguration
+
+    def __init__(self, sdk_config: SDKConfiguration) -> None:
+        self.sdk_configuration = sdk_config
+        
+    
+    
+    def get_pin(self, strong: Optional[bool] = None, x_plex_client_identifier: Optional[str] = None, server_url: Optional[str] = None) -> operations.GetPinResponse:
+        r"""Get a Pin
+        Retrieve a Pin from Plex.tv for authentication flows
+        """
+        hook_ctx = HookContext(operation_id='getPin', oauth2_scopes=[], security_source=None)
+        request = operations.GetPinRequest(
+            strong=strong,
+            x_plex_client_identifier=x_plex_client_identifier,
+        )
+        
+        base_url = utils.template_url(operations.GET_PIN_SERVERS[0], {
+        })
+        if server_url is not None:
+            base_url = server_url
+        
+        url = base_url + '/pins'
+        
+        headers = {}
+        query_params = {}
+        
+        headers = { **utils.get_headers(request, self.sdk_configuration.globals), **headers }
+        query_params = { **utils.get_query_params(operations.GetPinRequest, request, self.sdk_configuration.globals), **query_params }
+        headers['Accept'] = 'application/json'
+        headers['user-agent'] = self.sdk_configuration.user_agent
+        client = self.sdk_configuration.client
+        
+        try:
+            req = client.prepare_request(requests_http.Request('POST', url, params=query_params, headers=headers))
+            req = self.sdk_configuration.get_hooks().before_request(BeforeRequestContext(hook_ctx), req)
+            http_res = client.send(req)
+        except Exception as e:
+            _, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), None, e)
+            if e is not None:
+                raise e
+
+        if utils.match_status_codes(['400','4XX','5XX'], http_res.status_code):
+            result, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), http_res, None)
+            if e is not None:
+                raise e
+            if result is not None:
+                http_res = result
+        else:
+            http_res = self.sdk_configuration.get_hooks().after_success(AfterSuccessContext(hook_ctx), http_res)
+            
+        
+        
+        res = operations.GetPinResponse(status_code=http_res.status_code, content_type=http_res.headers.get('Content-Type') or '', raw_response=http_res)
+        
+        if http_res.status_code == 200:
+            if utils.match_content_type(http_res.headers.get('Content-Type') or '', 'application/json'):                
+                out = utils.unmarshal_json(http_res.text, Optional[operations.GetPinResponseBody])
+                res.object = out
+            else:
+                content_type = http_res.headers.get('Content-Type')
+                raise errors.SDKError(f'unknown content-type received: {content_type}', http_res.status_code, http_res.text, http_res)
+        elif http_res.status_code == 400:
+            if utils.match_content_type(http_res.headers.get('Content-Type') or '', 'application/json'):                
+                out = utils.unmarshal_json(http_res.text, errors.GetPinResponseBody)
+                out.raw_response = http_res
+                raise out
+            else:
+                content_type = http_res.headers.get('Content-Type')
+                raise errors.SDKError(f'unknown content-type received: {content_type}', http_res.status_code, http_res.text, http_res)
+        elif http_res.status_code >= 400 and http_res.status_code < 500 or http_res.status_code >= 500 and http_res.status_code < 600:
+            raise errors.SDKError('API error occurred', http_res.status_code, http_res.text, http_res)
+        else:
+            raise errors.SDKError('unknown status code received', http_res.status_code, http_res.text, http_res)
+
+        return res
+
+    
+    
+    def get_token(self, pin_id: str, x_plex_client_identifier: Optional[str] = None, server_url: Optional[str] = None) -> operations.GetTokenResponse:
+        r"""Get Access Token
+        Retrieve an Access Token from Plex.tv after the Pin has already been authenticated
+        """
+        hook_ctx = HookContext(operation_id='getToken', oauth2_scopes=[], security_source=None)
+        request = operations.GetTokenRequest(
+            pin_id=pin_id,
+            x_plex_client_identifier=x_plex_client_identifier,
+        )
+        
+        base_url = utils.template_url(operations.GET_TOKEN_SERVERS[0], {
+        })
+        if server_url is not None:
+            base_url = server_url
+        
+        url = utils.generate_url(operations.GetTokenRequest, base_url, '/pins/{pinID}', request, self.sdk_configuration.globals)
+        
+        headers = {}
+        
+        headers = { **utils.get_headers(request, self.sdk_configuration.globals), **headers }
+        headers['Accept'] = 'application/json'
+        headers['user-agent'] = self.sdk_configuration.user_agent
+        client = self.sdk_configuration.client
+        
+        try:
+            req = client.prepare_request(requests_http.Request('GET', url, headers=headers))
+            req = self.sdk_configuration.get_hooks().before_request(BeforeRequestContext(hook_ctx), req)
+            http_res = client.send(req)
+        except Exception as e:
+            _, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), None, e)
+            if e is not None:
+                raise e
+
+        if utils.match_status_codes(['400','4XX','5XX'], http_res.status_code):
+            result, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), http_res, None)
+            if e is not None:
+                raise e
+            if result is not None:
+                http_res = result
+        else:
+            http_res = self.sdk_configuration.get_hooks().after_success(AfterSuccessContext(hook_ctx), http_res)
+            
+        
+        
+        res = operations.GetTokenResponse(status_code=http_res.status_code, content_type=http_res.headers.get('Content-Type') or '', raw_response=http_res)
+        
+        if http_res.status_code == 200:
+            pass
+        elif http_res.status_code == 400:
+            if utils.match_content_type(http_res.headers.get('Content-Type') or '', 'application/json'):                
+                out = utils.unmarshal_json(http_res.text, errors.GetTokenResponseBody)
+                out.raw_response = http_res
+                raise out
+            else:
+                content_type = http_res.headers.get('Content-Type')
+                raise errors.SDKError(f'unknown content-type received: {content_type}', http_res.status_code, http_res.text, http_res)
+        elif http_res.status_code >= 400 and http_res.status_code < 500 or http_res.status_code >= 500 and http_res.status_code < 600:
+            raise errors.SDKError('API error occurred', http_res.status_code, http_res.text, http_res)
+        else:
+            raise errors.SDKError('unknown status code received', http_res.status_code, http_res.text, http_res)
+
+        return res
+
+    

plex_api/sdk.py

@@ -0,0 +1,180 @@
+"""Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT."""
+
+import requests as requests_http
+from .activities import Activities
+from .authentication import Authentication
+from .butler import Butler
+from .hubs import Hubs
+from .library import Library
+from .log import Log
+from .media import Media
+from .playlists import Playlists
+from .plex import Plex
+from .sdkconfiguration import SDKConfiguration, ServerProtocol
+from .search import Search
+from .server import Server
+from .sessions import Sessions
+from .statistics import Statistics
+from .updater import Updater
+from .utils.retries import RetryConfig
+from .video import Video
+from plex_api import utils
+from plex_api._hooks import SDKHooks
+from plex_api.models import components
+from typing import Callable, Dict, Optional, Union
+
+class PlexAPI:
+    r"""Plex-API: A Plex Media Server API Map
+    An Open API Spec for interacting with Plex.tv and Plex Servers
+    """
+    server: Server
+    r"""Operations against the Plex Media Server System."""
+    media: Media
+    r"""API Calls interacting with Plex Media Server Media"""
+    video: Video
+    r"""API Calls that perform operations with Plex Media Server Videos"""
+    activities: Activities
+    r"""Activities are awesome. They provide a way to monitor and control asynchronous operations on the server. In order to receive real-time updates for activities, a client would normally subscribe via either EventSource or Websocket endpoints.
+    Activities are associated with HTTP replies via a special `X-Plex-Activity` header which contains the UUID of the activity.
+    Activities are optional cancellable. If cancellable, they may be cancelled via the `DELETE` endpoint. Other details:
+    - They can contain a `progress` (from 0 to 100) marking the percent completion of the activity.
+    - They must contain an `type` which is used by clients to distinguish the specific activity.
+    - They may contain a `Context` object with attributes which associate the activity with various specific entities (items, libraries, etc.)
+    - The may contain a `Response` object which attributes which represent the result of the asynchronous operation.
+    """
+    butler: Butler
+    r"""Butler is the task manager of the Plex Media Server Ecosystem."""
+    hubs: Hubs
+    r"""Hubs are a structured two-dimensional container for media, generally represented by multiple horizontal rows."""
+    search: Search
+    r"""API Calls that perform search operations with Plex Media Server"""
+    library: Library
+    r"""API Calls interacting with Plex Media Server Libraries"""
+    log: Log
+    r"""Submit logs to the Log Handler for Plex Media Server"""
+    plex: Plex
+    r"""API Calls that perform operations directly against https://Plex.tv"""
+    playlists: Playlists
+    r"""Playlists are ordered collections of media. They can be dumb (just a list of media) or smart (based on a media query, such as \\"all albums from 2017\\").
+    They can be organized in (optionally nesting) folders.
+    Retrieving a playlist, or its items, will trigger a refresh of its metadata. 
+    This may cause the duration and number of items to change.
+    """
+    authentication: Authentication
+    r"""API Calls regarding authentication for Plex Media Server"""
+    statistics: Statistics
+    r"""API Calls that perform operations with Plex Media Server Statistics"""
+    sessions: Sessions
+    r"""API Calls that perform search operations with Plex Media Server Sessions"""
+    updater: Updater
+    r"""This describes the API for searching and applying updates to the Plex Media Server.
+    Updates to the status can be observed via the Event API.
+    """
+
+    sdk_configuration: SDKConfiguration
+
+    def __init__(self,
+                 access_token: Union[str, Callable[[], str]],
+                 x_plex_client_identifier: str = None,
+                 protocol: ServerProtocol = None,
+                 ip: str = None,
+                 port: str = None,
+                 server_idx: Optional[int] = None,
+                 server_url: Optional[str] = None,
+                 url_params: Optional[Dict[str, str]] = None,
+                 client: Optional[requests_http.Session] = None,
+                 retry_config: Optional[RetryConfig] = None
+                 ) -> None:
+        """Instantiates the SDK configuring it with the provided parameters.
+
+        :param access_token: The access_token required for authentication
+        :type access_token: Union[str, Callable[[], str]]
+        :param x_plex_client_identifier: Configures the x_plex_client_identifier parameter for all supported operations
+        :type x_plex_client_identifier: str
+        :param protocol: Allows setting the protocol variable for url substitution
+        :type protocol: ServerProtocol
+        :param ip: Allows setting the ip variable for url substitution
+        :type ip: str
+        :param port: Allows setting the port variable for url substitution
+        :type port: str
+        :param server_idx: The index of the server to use for all operations
+        :type server_idx: int
+        :param server_url: The server URL to use for all operations
+        :type server_url: str
+        :param url_params: Parameters to optionally template the server URL with
+        :type url_params: Dict[str, str]
+        :param client: The requests.Session HTTP client to use for all operations
+        :type client: requests_http.Session
+        :param retry_config: The utils.RetryConfig to use globally
+        :type retry_config: RetryConfig
+        """
+        if client is None:
+            client = requests_http.Session()
+
+        if callable(access_token):
+            def security():
+                return components.Security(access_token = access_token())
+        else:
+            security = components.Security(access_token = access_token)
+
+        if server_url is not None:
+            if url_params is not None:
+                server_url = utils.template_url(server_url, url_params)
+        server_defaults = [
+            {
+                'protocol': protocol or 'http',
+                'ip': ip or '10.10.10.47',
+                'port': port or '32400',
+            },
+        ]
+        global_params = {
+            'parameters': {
+                'queryParam': {
+                },
+                'pathParam': {
+                },
+                'header': {
+                    'x_plex_client_identifier': x_plex_client_identifier,
+                },
+            },
+        }
+
+        self.sdk_configuration = SDKConfiguration(
+            client,
+            security,
+            server_url,
+            server_idx,
+            server_defaults,
+            global_params,
+            retry_config=retry_config
+        )
+
+        hooks = SDKHooks()
+
+        current_server_url, *_ = self.sdk_configuration.get_server_details()
+        server_url, self.sdk_configuration.client = hooks.sdk_init(current_server_url, self.sdk_configuration.client)
+        if current_server_url != server_url:
+            self.sdk_configuration.server_url = server_url
+
+        # pylint: disable=protected-access
+        self.sdk_configuration._hooks = hooks
+
+        self._init_sdks()
+
+
+    def _init_sdks(self):
+        self.server = Server(self.sdk_configuration)
+        self.media = Media(self.sdk_configuration)
+        self.video = Video(self.sdk_configuration)
+        self.activities = Activities(self.sdk_configuration)
+        self.butler = Butler(self.sdk_configuration)
+        self.hubs = Hubs(self.sdk_configuration)
+        self.search = Search(self.sdk_configuration)
+        self.library = Library(self.sdk_configuration)
+        self.log = Log(self.sdk_configuration)
+        self.plex = Plex(self.sdk_configuration)
+        self.playlists = Playlists(self.sdk_configuration)
+        self.authentication = Authentication(self.sdk_configuration)
+        self.statistics = Statistics(self.sdk_configuration)
+        self.sessions = Sessions(self.sdk_configuration)
+        self.updater = Updater(self.sdk_configuration)

plex_api/sdkconfiguration.py

@@ -0,0 +1,52 @@
+"""Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT."""
+
+
+import requests as requests_http
+from ._hooks import SDKHooks
+from .utils import utils
+from .utils.retries import RetryConfig
+from dataclasses import dataclass, field
+from enum import Enum
+from plex_api.models import components
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+
+SERVERS = [
+    '{protocol}://{ip}:{port}',
+    # The full address of your Plex Server
+]
+"""Contains the list of servers available to the SDK"""
+
+class ServerProtocol(str, Enum):
+    r"""The protocol to use when connecting to your plex server."""
+    HTTP = 'http'
+    HTTPS = 'https'
+
+
+@dataclass
+class SDKConfiguration:
+    client: requests_http.Session
+    security: Union[components.Security,Callable[[], components.Security]] = None
+    server_url: Optional[str] = ''
+    server_idx: Optional[int] = 0
+    server_defaults: List[Dict[str, str]] = field(default_factory=List)
+    globals: Dict[str, Dict[str, Dict[str, Any]]] = field(default_factory=Dict)
+    language: str = 'python'
+    openapi_doc_version: str = '0.0.3'
+    sdk_version: str = '0.6.1'
+    gen_version: str = '2.298.2'
+    user_agent: str = 'speakeasy-sdk/python 0.6.1 2.298.2 0.0.3 plex-api-client'
+    retry_config: Optional[RetryConfig] = None
+    _hooks: Optional[SDKHooks] = None
+
+    def get_server_details(self) -> Tuple[str, Dict[str, str]]:
+        if self.server_url is not None and self.server_url != '':
+            return utils.remove_suffix(self.server_url, '/'), {}
+        if self.server_idx is None:
+            self.server_idx = 0
+
+        return SERVERS[self.server_idx], self.server_defaults[self.server_idx]
+
+
+    def get_hooks(self) -> SDKHooks:
+        return self._hooks

plex_api/search.py

@@ -0,0 +1,232 @@
+"""Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT."""
+
+import requests as requests_http
+from .sdkconfiguration import SDKConfiguration
+from plex_api import utils
+from plex_api._hooks import AfterErrorContext, AfterSuccessContext, BeforeRequestContext, HookContext
+from plex_api.models import errors, operations
+from typing import Optional
+
+class Search:
+    r"""API Calls that perform search operations with Plex Media Server"""
+    sdk_configuration: SDKConfiguration
+
+    def __init__(self, sdk_config: SDKConfiguration) -> None:
+        self.sdk_configuration = sdk_config
+        
+    
+    
+    def perform_search(self, query: str, section_id: Optional[float] = None, limit: Optional[float] = None) -> operations.PerformSearchResponse:
+        r"""Perform a search
+        This endpoint performs a search across all library sections, or a single section, and returns matches as hubs, split up by type. It performs spell checking, looks for partial matches, and orders the hubs based on quality of results. In addition, based on matches, it will return other related matches (e.g. for a genre match, it may return movies in that genre, or for an actor match, movies with that actor).
+
+        In the response's items, the following extra attributes are returned to further describe or disambiguate the result:
+
+        - `reason`: The reason for the result, if not because of a direct search term match; can be either:
+          - `section`: There are multiple identical results from different sections.
+          - `originalTitle`: There was a search term match from the original title field (sometimes those can be very different or in a foreign language).
+          - `<hub identifier>`: If the reason for the result is due to a result in another hub, the source hub identifier is returned. For example, if the search is for \"dylan\" then Bob Dylan may be returned as an artist result, an a few of his albums returned as album results with a reason code of `artist` (the identifier of that particular hub). Or if the search is for \"arnold\", there might be movie results returned with a reason of `actor`
+        - `reasonTitle`: The string associated with the reason code. For a section reason, it'll be the section name; For a hub identifier, it'll be a string associated with the match (e.g. `Arnold Schwarzenegger` for movies which were returned because the search was for \"arnold\").
+        - `reasonID`: The ID of the item associated with the reason for the result. This might be a section ID, a tag ID, an artist ID, or a show ID.
+
+        This request is intended to be very fast, and called as the user types.
+        """
+        hook_ctx = HookContext(operation_id='performSearch', oauth2_scopes=[], security_source=self.sdk_configuration.security)
+        request = operations.PerformSearchRequest(
+            query=query,
+            section_id=section_id,
+            limit=limit,
+        )
+        
+        base_url = utils.template_url(*self.sdk_configuration.get_server_details())
+        
+        url = base_url + '/hubs/search'
+        
+        if callable(self.sdk_configuration.security):
+            headers, query_params = utils.get_security(self.sdk_configuration.security())
+        else:
+            headers, query_params = utils.get_security(self.sdk_configuration.security)
+        
+        query_params = { **utils.get_query_params(operations.PerformSearchRequest, request, self.sdk_configuration.globals), **query_params }
+        headers['Accept'] = 'application/json'
+        headers['user-agent'] = self.sdk_configuration.user_agent
+        client = self.sdk_configuration.client
+        
+        try:
+            req = client.prepare_request(requests_http.Request('GET', url, params=query_params, headers=headers))
+            req = self.sdk_configuration.get_hooks().before_request(BeforeRequestContext(hook_ctx), req)
+            http_res = client.send(req)
+        except Exception as e:
+            _, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), None, e)
+            if e is not None:
+                raise e
+
+        if utils.match_status_codes(['400','401','4XX','5XX'], http_res.status_code):
+            result, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), http_res, None)
+            if e is not None:
+                raise e
+            if result is not None:
+                http_res = result
+        else:
+            http_res = self.sdk_configuration.get_hooks().after_success(AfterSuccessContext(hook_ctx), http_res)
+            
+        
+        
+        res = operations.PerformSearchResponse(status_code=http_res.status_code, content_type=http_res.headers.get('Content-Type') or '', raw_response=http_res)
+        
+        if http_res.status_code == 200:
+            pass
+        elif http_res.status_code == 400 or http_res.status_code >= 400 and http_res.status_code < 500 or http_res.status_code >= 500 and http_res.status_code < 600:
+            raise errors.SDKError('API error occurred', http_res.status_code, http_res.text, http_res)
+        elif http_res.status_code == 401:
+            if utils.match_content_type(http_res.headers.get('Content-Type') or '', 'application/json'):                
+                out = utils.unmarshal_json(http_res.text, errors.PerformSearchResponseBody)
+                out.raw_response = http_res
+                raise out
+            else:
+                content_type = http_res.headers.get('Content-Type')
+                raise errors.SDKError(f'unknown content-type received: {content_type}', http_res.status_code, http_res.text, http_res)
+        else:
+            raise errors.SDKError('unknown status code received', http_res.status_code, http_res.text, http_res)
+
+        return res
+
+    
+    
+    def perform_voice_search(self, query: str, section_id: Optional[float] = None, limit: Optional[float] = None) -> operations.PerformVoiceSearchResponse:
+        r"""Perform a voice search
+        This endpoint performs a search specifically tailored towards voice or other imprecise input which may work badly with the substring and spell-checking heuristics used by the `/hubs/search` endpoint. 
+        It uses a [Levenshtein distance](https://en.wikipedia.org/wiki/Levenshtein_distance) heuristic to search titles, and as such is much slower than the other search endpoint. 
+        Whenever possible, clients should limit the search to the appropriate type. 
+        Results, as well as their containing per-type hubs, contain a `distance` attribute which can be used to judge result quality.
+        """
+        hook_ctx = HookContext(operation_id='performVoiceSearch', oauth2_scopes=[], security_source=self.sdk_configuration.security)
+        request = operations.PerformVoiceSearchRequest(
+            query=query,
+            section_id=section_id,
+            limit=limit,
+        )
+        
+        base_url = utils.template_url(*self.sdk_configuration.get_server_details())
+        
+        url = base_url + '/hubs/search/voice'
+        
+        if callable(self.sdk_configuration.security):
+            headers, query_params = utils.get_security(self.sdk_configuration.security())
+        else:
+            headers, query_params = utils.get_security(self.sdk_configuration.security)
+        
+        query_params = { **utils.get_query_params(operations.PerformVoiceSearchRequest, request, self.sdk_configuration.globals), **query_params }
+        headers['Accept'] = 'application/json'
+        headers['user-agent'] = self.sdk_configuration.user_agent
+        client = self.sdk_configuration.client
+        
+        try:
+            req = client.prepare_request(requests_http.Request('GET', url, params=query_params, headers=headers))
+            req = self.sdk_configuration.get_hooks().before_request(BeforeRequestContext(hook_ctx), req)
+            http_res = client.send(req)
+        except Exception as e:
+            _, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), None, e)
+            if e is not None:
+                raise e
+
+        if utils.match_status_codes(['400','401','4XX','5XX'], http_res.status_code):
+            result, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), http_res, None)
+            if e is not None:
+                raise e
+            if result is not None:
+                http_res = result
+        else:
+            http_res = self.sdk_configuration.get_hooks().after_success(AfterSuccessContext(hook_ctx), http_res)
+            
+        
+        
+        res = operations.PerformVoiceSearchResponse(status_code=http_res.status_code, content_type=http_res.headers.get('Content-Type') or '', raw_response=http_res)
+        
+        if http_res.status_code == 200:
+            pass
+        elif http_res.status_code == 400 or http_res.status_code >= 400 and http_res.status_code < 500 or http_res.status_code >= 500 and http_res.status_code < 600:
+            raise errors.SDKError('API error occurred', http_res.status_code, http_res.text, http_res)
+        elif http_res.status_code == 401:
+            if utils.match_content_type(http_res.headers.get('Content-Type') or '', 'application/json'):                
+                out = utils.unmarshal_json(http_res.text, errors.PerformVoiceSearchResponseBody)
+                out.raw_response = http_res
+                raise out
+            else:
+                content_type = http_res.headers.get('Content-Type')
+                raise errors.SDKError(f'unknown content-type received: {content_type}', http_res.status_code, http_res.text, http_res)
+        else:
+            raise errors.SDKError('unknown status code received', http_res.status_code, http_res.text, http_res)
+
+        return res
+
+    
+    
+    def get_search_results(self, query: str) -> operations.GetSearchResultsResponse:
+        r"""Get Search Results
+        This will search the database for the string provided.
+        """
+        hook_ctx = HookContext(operation_id='getSearchResults', oauth2_scopes=[], security_source=self.sdk_configuration.security)
+        request = operations.GetSearchResultsRequest(
+            query=query,
+        )
+        
+        base_url = utils.template_url(*self.sdk_configuration.get_server_details())
+        
+        url = base_url + '/search'
+        
+        if callable(self.sdk_configuration.security):
+            headers, query_params = utils.get_security(self.sdk_configuration.security())
+        else:
+            headers, query_params = utils.get_security(self.sdk_configuration.security)
+        
+        query_params = { **utils.get_query_params(operations.GetSearchResultsRequest, request, self.sdk_configuration.globals), **query_params }
+        headers['Accept'] = 'application/json'
+        headers['user-agent'] = self.sdk_configuration.user_agent
+        client = self.sdk_configuration.client
+        
+        try:
+            req = client.prepare_request(requests_http.Request('GET', url, params=query_params, headers=headers))
+            req = self.sdk_configuration.get_hooks().before_request(BeforeRequestContext(hook_ctx), req)
+            http_res = client.send(req)
+        except Exception as e:
+            _, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), None, e)
+            if e is not None:
+                raise e
+
+        if utils.match_status_codes(['400','401','4XX','5XX'], http_res.status_code):
+            result, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), http_res, None)
+            if e is not None:
+                raise e
+            if result is not None:
+                http_res = result
+        else:
+            http_res = self.sdk_configuration.get_hooks().after_success(AfterSuccessContext(hook_ctx), http_res)
+            
+        
+        
+        res = operations.GetSearchResultsResponse(status_code=http_res.status_code, content_type=http_res.headers.get('Content-Type') or '', raw_response=http_res)
+        
+        if http_res.status_code == 200:
+            if utils.match_content_type(http_res.headers.get('Content-Type') or '', 'application/json'):                
+                out = utils.unmarshal_json(http_res.text, Optional[operations.GetSearchResultsResponseBody])
+                res.object = out
+            else:
+                content_type = http_res.headers.get('Content-Type')
+                raise errors.SDKError(f'unknown content-type received: {content_type}', http_res.status_code, http_res.text, http_res)
+        elif http_res.status_code == 400 or http_res.status_code >= 400 and http_res.status_code < 500 or http_res.status_code >= 500 and http_res.status_code < 600:
+            raise errors.SDKError('API error occurred', http_res.status_code, http_res.text, http_res)
+        elif http_res.status_code == 401:
+            if utils.match_content_type(http_res.headers.get('Content-Type') or '', 'application/json'):                
+                out = utils.unmarshal_json(http_res.text, errors.GetSearchResultsResponseBody)
+                out.raw_response = http_res
+                raise out
+            else:
+                content_type = http_res.headers.get('Content-Type')
+                raise errors.SDKError(f'unknown content-type received: {content_type}', http_res.status_code, http_res.text, http_res)
+        else:
+            raise errors.SDKError('unknown status code received', http_res.status_code, http_res.text, http_res)
+
+        return res
+
+