deepgram.clients.speak_router 

  1# Copyright 2023-2024 Deepgram SDK contributors. All Rights Reserved.
  2# Use of this source code is governed by a MIT license that can be found in the LICENSE file.
  3# SPDX-License-Identifier: MIT
  4
  5from importlib import import_module
  6import logging
  7import deprecation  # type: ignore
  8
  9from .. import __version__
 10from .speak.v1.rest.client import SpeakRESTClient
 11from ..utils import verboselogs
 12from ..options import DeepgramClientOptions
 13from .errors import DeepgramModuleError
 14
 15
 16class SpeakRouter:
 17    """
 18    This class provides a Speak Clients for making requests to the Deepgram API with various configuration options.
 19
 20    Attributes:
 21        config_options (DeepgramClientOptions): An optional configuration object specifying client options.
 22
 23    Methods:
 24        rest: (Preferred) Returns a Threaded REST Client instance for interacting with Deepgram's transcription services.
 25        websocket: (Preferred) Returns an Threaded WebSocket Client instance for interacting with Deepgram's prerecorded transcription services.
 26
 27        asyncrest: Returns an Async REST Client instance for interacting with Deepgram's transcription services.
 28        asyncwebsocket: Returns an Async WebSocket Client instance for interacting with Deepgram's prerecorded transcription services.
 29    """
 30
 31    _logger: verboselogs.VerboseLogger
 32    _config: DeepgramClientOptions
 33
 34    def __init__(self, config: DeepgramClientOptions):
 35        self._logger = verboselogs.VerboseLogger(__name__)
 36        self._logger.addHandler(logging.StreamHandler())
 37        self._logger.setLevel(config.verbose)
 38        self._config = config
 39
 40    # when this is removed, remove --disable=W0622 from Makefile
 41    # pylint: disable=unused-argument
 42    @deprecation.deprecated(
 43        deprecated_in="3.4.0",
 44        removed_in="4.0.0",
 45        current_version=__version__,
 46        details="deepgram.speak.v1 is deprecated. Use deepgram.speak.rest or deepgram.speak.websocket instead.",
 47    )
 48    def v(self, version: str = ""):
 49        """
 50        DEPRECATED: deepgram.speak.v1 is deprecated. Use deepgram.speak.rest or deepgram.speak.websocket instead.
 51        """
 52        return SpeakRESTClient(self._config)
 53
 54    # pylint: enable=unused-argument
 55
 56    @property
 57    def rest(self):
 58        """
 59        Returns a Threaded REST Client instance for interacting with Deepgram's prerecorded Text-to-Speech services.
 60        """
 61        return self.Version(self._config, "rest")
 62
 63    @property
 64    def asyncrest(self):
 65        """
 66        Returns an Async REST Client instance for interacting with Deepgram's prerecorded Text-to-Speech services.
 67        """
 68        return self.Version(self._config, "asyncrest")
 69
 70    @property
 71    def websocket(self):
 72        """
 73        Returns a Threaded WebSocket Client instance for interacting with Deepgram's Text-to-Speech services.
 74        """
 75        return self.Version(self._config, "websocket")
 76
 77    @property
 78    def asyncwebsocket(self):
 79        """
 80        Returns an Async WebSocket Client instance for interacting with Deepgram's Text-to-Speech services.
 81        """
 82        return self.Version(self._config, "asyncwebsocket")
 83
 84    # INTERNAL CLASSES
 85    class Version:
 86        """
 87        Represents a version of the Deepgram API.
 88        """
 89
 90        _logger: verboselogs.VerboseLogger
 91        _config: DeepgramClientOptions
 92        _parent: str
 93
 94        def __init__(self, config, parent: str):
 95            self._logger = verboselogs.VerboseLogger(__name__)
 96            self._logger.addHandler(logging.StreamHandler())
 97            self._logger.setLevel(config.verbose)
 98            self._config = config
 99            self._parent = parent
100
101        # FUTURE VERSIONING:
102        # When v2 or v1.1beta1 or etc. This allows easy access to the latest version of the API.
103        # @property
104        # def latest(self):
105        #     match self._parent:
106        #         case "live":
107        #             return LiveClient(self._config)
108        #         case "prerecorded":
109        #             return PreRecordedClient(self._config)
110        #         case _:
111        #             raise DeepgramModuleError("Invalid parent")
112
113        def v(self, version: str = ""):
114            """
115            Returns a specific version of the Deepgram API.
116            """
117            self._logger.debug("Version.v ENTER")
118            self._logger.info("version: %s", version)
119            if len(version) == 0:
120                self._logger.error("version is empty")
121                self._logger.debug("Version.v LEAVE")
122                raise DeepgramModuleError("Invalid module version")
123
124            type = ""
125            file_name = ""
126            class_name = ""
127            match self._parent:
128                case "websocket":
129                    type = "websocket"
130                    file_name = "client"
131                    class_name = "SpeakWebSocketClient"
132                case "asyncwebsocket":
133                    type = "websocket"
134                    file_name = "async_client"
135                    class_name = "AsyncSpeakWebSocketClient"
136                case "rest":
137                    type = "rest"
138                    file_name = "client"
139                    class_name = "SpeakRESTClient"
140                case "asyncrest":
141                    type = "rest"
142                    file_name = "async_client"
143                    class_name = "AsyncSpeakRESTClient"
144                case _:
145                    self._logger.error("parent unknown: %s", self._parent)
146                    self._logger.debug("Version.v LEAVE")
147                    raise DeepgramModuleError("Invalid parent type")
148
149            # create class path
150            path = f"deepgram.clients.speak.v{version}.{type}.{file_name}"
151            self._logger.info("path: %s", path)
152            self._logger.info("class_name: %s", class_name)
153
154            # import class
155            mod = import_module(path)
156            if mod is None:
157                self._logger.error("module path is None")
158                self._logger.debug("Version.v LEAVE")
159                raise DeepgramModuleError("Unable to find package")
160
161            my_class = getattr(mod, class_name)
162            if my_class is None:
163                self._logger.error("my_class is None")
164                self._logger.debug("Version.v LEAVE")
165                raise DeepgramModuleError("Unable to find class")
166
167            # instantiate class
168            my_class = my_class(self._config)
169            self._logger.notice("Version.v succeeded")
170            self._logger.debug("Version.v LEAVE")
171            return my_class
class SpeakRouter: 
 17class SpeakRouter:
 18    """
 19    This class provides a Speak Clients for making requests to the Deepgram API with various configuration options.
 20
 21    Attributes:
 22        config_options (DeepgramClientOptions): An optional configuration object specifying client options.
 23
 24    Methods:
 25        rest: (Preferred) Returns a Threaded REST Client instance for interacting with Deepgram's transcription services.
 26        websocket: (Preferred) Returns an Threaded WebSocket Client instance for interacting with Deepgram's prerecorded transcription services.
 27
 28        asyncrest: Returns an Async REST Client instance for interacting with Deepgram's transcription services.
 29        asyncwebsocket: Returns an Async WebSocket Client instance for interacting with Deepgram's prerecorded transcription services.
 30    """
 31
 32    _logger: verboselogs.VerboseLogger
 33    _config: DeepgramClientOptions
 34
 35    def __init__(self, config: DeepgramClientOptions):
 36        self._logger = verboselogs.VerboseLogger(__name__)
 37        self._logger.addHandler(logging.StreamHandler())
 38        self._logger.setLevel(config.verbose)
 39        self._config = config
 40
 41    # when this is removed, remove --disable=W0622 from Makefile
 42    # pylint: disable=unused-argument
 43    @deprecation.deprecated(
 44        deprecated_in="3.4.0",
 45        removed_in="4.0.0",
 46        current_version=__version__,
 47        details="deepgram.speak.v1 is deprecated. Use deepgram.speak.rest or deepgram.speak.websocket instead.",
 48    )
 49    def v(self, version: str = ""):
 50        """
 51        DEPRECATED: deepgram.speak.v1 is deprecated. Use deepgram.speak.rest or deepgram.speak.websocket instead.
 52        """
 53        return SpeakRESTClient(self._config)
 54
 55    # pylint: enable=unused-argument
 56
 57    @property
 58    def rest(self):
 59        """
 60        Returns a Threaded REST Client instance for interacting with Deepgram's prerecorded Text-to-Speech services.
 61        """
 62        return self.Version(self._config, "rest")
 63
 64    @property
 65    def asyncrest(self):
 66        """
 67        Returns an Async REST Client instance for interacting with Deepgram's prerecorded Text-to-Speech services.
 68        """
 69        return self.Version(self._config, "asyncrest")
 70
 71    @property
 72    def websocket(self):
 73        """
 74        Returns a Threaded WebSocket Client instance for interacting with Deepgram's Text-to-Speech services.
 75        """
 76        return self.Version(self._config, "websocket")
 77
 78    @property
 79    def asyncwebsocket(self):
 80        """
 81        Returns an Async WebSocket Client instance for interacting with Deepgram's Text-to-Speech services.
 82        """
 83        return self.Version(self._config, "asyncwebsocket")
 84
 85    # INTERNAL CLASSES
 86    class Version:
 87        """
 88        Represents a version of the Deepgram API.
 89        """
 90
 91        _logger: verboselogs.VerboseLogger
 92        _config: DeepgramClientOptions
 93        _parent: str
 94
 95        def __init__(self, config, parent: str):
 96            self._logger = verboselogs.VerboseLogger(__name__)
 97            self._logger.addHandler(logging.StreamHandler())
 98            self._logger.setLevel(config.verbose)
 99            self._config = config
100            self._parent = parent
101
102        # FUTURE VERSIONING:
103        # When v2 or v1.1beta1 or etc. This allows easy access to the latest version of the API.
104        # @property
105        # def latest(self):
106        #     match self._parent:
107        #         case "live":
108        #             return LiveClient(self._config)
109        #         case "prerecorded":
110        #             return PreRecordedClient(self._config)
111        #         case _:
112        #             raise DeepgramModuleError("Invalid parent")
113
114        def v(self, version: str = ""):
115            """
116            Returns a specific version of the Deepgram API.
117            """
118            self._logger.debug("Version.v ENTER")
119            self._logger.info("version: %s", version)
120            if len(version) == 0:
121                self._logger.error("version is empty")
122                self._logger.debug("Version.v LEAVE")
123                raise DeepgramModuleError("Invalid module version")
124
125            type = ""
126            file_name = ""
127            class_name = ""
128            match self._parent:
129                case "websocket":
130                    type = "websocket"
131                    file_name = "client"
132                    class_name = "SpeakWebSocketClient"
133                case "asyncwebsocket":
134                    type = "websocket"
135                    file_name = "async_client"
136                    class_name = "AsyncSpeakWebSocketClient"
137                case "rest":
138                    type = "rest"
139                    file_name = "client"
140                    class_name = "SpeakRESTClient"
141                case "asyncrest":
142                    type = "rest"
143                    file_name = "async_client"
144                    class_name = "AsyncSpeakRESTClient"
145                case _:
146                    self._logger.error("parent unknown: %s", self._parent)
147                    self._logger.debug("Version.v LEAVE")
148                    raise DeepgramModuleError("Invalid parent type")
149
150            # create class path
151            path = f"deepgram.clients.speak.v{version}.{type}.{file_name}"
152            self._logger.info("path: %s", path)
153            self._logger.info("class_name: %s", class_name)
154
155            # import class
156            mod = import_module(path)
157            if mod is None:
158                self._logger.error("module path is None")
159                self._logger.debug("Version.v LEAVE")
160                raise DeepgramModuleError("Unable to find package")
161
162            my_class = getattr(mod, class_name)
163            if my_class is None:
164                self._logger.error("my_class is None")
165                self._logger.debug("Version.v LEAVE")
166                raise DeepgramModuleError("Unable to find class")
167
168            # instantiate class
169            my_class = my_class(self._config)
170            self._logger.notice("Version.v succeeded")
171            self._logger.debug("Version.v LEAVE")
172            return my_class

This class provides a Speak Clients for making requests to the Deepgram API with various configuration options.

Attributes: config_options (DeepgramClientOptions): An optional configuration object specifying client options.

Methods: rest: (Preferred) Returns a Threaded REST Client instance for interacting with Deepgram's transcription services. websocket: (Preferred) Returns an Threaded WebSocket Client instance for interacting with Deepgram's prerecorded transcription services.

asyncrest: Returns an Async REST Client instance for interacting with Deepgram's transcription services.
asyncwebsocket: Returns an Async WebSocket Client instance for interacting with Deepgram's prerecorded transcription services.
SpeakRouter(config: deepgram.options.DeepgramClientOptions) 
35    def __init__(self, config: DeepgramClientOptions):
36        self._logger = verboselogs.VerboseLogger(__name__)
37        self._logger.addHandler(logging.StreamHandler())
38        self._logger.setLevel(config.verbose)
39        self._config = config
@deprecation.deprecated(deprecated_in='3.4.0', removed_in='4.0.0', current_version=__version__, details='deepgram.speak.v1 is deprecated. Use deepgram.speak.rest or deepgram.speak.websocket instead.')
def v(self, version: str = ''): 
43    @deprecation.deprecated(
44        deprecated_in="3.4.0",
45        removed_in="4.0.0",
46        current_version=__version__,
47        details="deepgram.speak.v1 is deprecated. Use deepgram.speak.rest or deepgram.speak.websocket instead.",
48    )
49    def v(self, version: str = ""):
50        """
51        DEPRECATED: deepgram.speak.v1 is deprecated. Use deepgram.speak.rest or deepgram.speak.websocket instead.
52        """
53        return SpeakRESTClient(self._config)

DEPRECATED: deepgram.speak.v1 is deprecated. Use deepgram.speak.rest or deepgram.speak.websocket instead.

rest 
57    @property
58    def rest(self):
59        """
60        Returns a Threaded REST Client instance for interacting with Deepgram's prerecorded Text-to-Speech services.
61        """
62        return self.Version(self._config, "rest")

Returns a Threaded REST Client instance for interacting with Deepgram's prerecorded Text-to-Speech services.

asyncrest 
64    @property
65    def asyncrest(self):
66        """
67        Returns an Async REST Client instance for interacting with Deepgram's prerecorded Text-to-Speech services.
68        """
69        return self.Version(self._config, "asyncrest")

Returns an Async REST Client instance for interacting with Deepgram's prerecorded Text-to-Speech services.

websocket 
71    @property
72    def websocket(self):
73        """
74        Returns a Threaded WebSocket Client instance for interacting with Deepgram's Text-to-Speech services.
75        """
76        return self.Version(self._config, "websocket")

Returns a Threaded WebSocket Client instance for interacting with Deepgram's Text-to-Speech services.

asyncwebsocket 
78    @property
79    def asyncwebsocket(self):
80        """
81        Returns an Async WebSocket Client instance for interacting with Deepgram's Text-to-Speech services.
82        """
83        return self.Version(self._config, "asyncwebsocket")

Returns an Async WebSocket Client instance for interacting with Deepgram's Text-to-Speech services.

class SpeakRouter.Version: 
 86    class Version:
 87        """
 88        Represents a version of the Deepgram API.
 89        """
 90
 91        _logger: verboselogs.VerboseLogger
 92        _config: DeepgramClientOptions
 93        _parent: str
 94
 95        def __init__(self, config, parent: str):
 96            self._logger = verboselogs.VerboseLogger(__name__)
 97            self._logger.addHandler(logging.StreamHandler())
 98            self._logger.setLevel(config.verbose)
 99            self._config = config
100            self._parent = parent
101
102        # FUTURE VERSIONING:
103        # When v2 or v1.1beta1 or etc. This allows easy access to the latest version of the API.
104        # @property
105        # def latest(self):
106        #     match self._parent:
107        #         case "live":
108        #             return LiveClient(self._config)
109        #         case "prerecorded":
110        #             return PreRecordedClient(self._config)
111        #         case _:
112        #             raise DeepgramModuleError("Invalid parent")
113
114        def v(self, version: str = ""):
115            """
116            Returns a specific version of the Deepgram API.
117            """
118            self._logger.debug("Version.v ENTER")
119            self._logger.info("version: %s", version)
120            if len(version) == 0:
121                self._logger.error("version is empty")
122                self._logger.debug("Version.v LEAVE")
123                raise DeepgramModuleError("Invalid module version")
124
125            type = ""
126            file_name = ""
127            class_name = ""
128            match self._parent:
129                case "websocket":
130                    type = "websocket"
131                    file_name = "client"
132                    class_name = "SpeakWebSocketClient"
133                case "asyncwebsocket":
134                    type = "websocket"
135                    file_name = "async_client"
136                    class_name = "AsyncSpeakWebSocketClient"
137                case "rest":
138                    type = "rest"
139                    file_name = "client"
140                    class_name = "SpeakRESTClient"
141                case "asyncrest":
142                    type = "rest"
143                    file_name = "async_client"
144                    class_name = "AsyncSpeakRESTClient"
145                case _:
146                    self._logger.error("parent unknown: %s", self._parent)
147                    self._logger.debug("Version.v LEAVE")
148                    raise DeepgramModuleError("Invalid parent type")
149
150            # create class path
151            path = f"deepgram.clients.speak.v{version}.{type}.{file_name}"
152            self._logger.info("path: %s", path)
153            self._logger.info("class_name: %s", class_name)
154
155            # import class
156            mod = import_module(path)
157            if mod is None:
158                self._logger.error("module path is None")
159                self._logger.debug("Version.v LEAVE")
160                raise DeepgramModuleError("Unable to find package")
161
162            my_class = getattr(mod, class_name)
163            if my_class is None:
164                self._logger.error("my_class is None")
165                self._logger.debug("Version.v LEAVE")
166                raise DeepgramModuleError("Unable to find class")
167
168            # instantiate class
169            my_class = my_class(self._config)
170            self._logger.notice("Version.v succeeded")
171            self._logger.debug("Version.v LEAVE")
172            return my_class

Represents a version of the Deepgram API.

SpeakRouter.Version(config, parent: str) 
 95        def __init__(self, config, parent: str):
 96            self._logger = verboselogs.VerboseLogger(__name__)
 97            self._logger.addHandler(logging.StreamHandler())
 98            self._logger.setLevel(config.verbose)
 99            self._config = config
100            self._parent = parent
def v(self, version: str = ''): 
114        def v(self, version: str = ""):
115            """
116            Returns a specific version of the Deepgram API.
117            """
118            self._logger.debug("Version.v ENTER")
119            self._logger.info("version: %s", version)
120            if len(version) == 0:
121                self._logger.error("version is empty")
122                self._logger.debug("Version.v LEAVE")
123                raise DeepgramModuleError("Invalid module version")
124
125            type = ""
126            file_name = ""
127            class_name = ""
128            match self._parent:
129                case "websocket":
130                    type = "websocket"
131                    file_name = "client"
132                    class_name = "SpeakWebSocketClient"
133                case "asyncwebsocket":
134                    type = "websocket"
135                    file_name = "async_client"
136                    class_name = "AsyncSpeakWebSocketClient"
137                case "rest":
138                    type = "rest"
139                    file_name = "client"
140                    class_name = "SpeakRESTClient"
141                case "asyncrest":
142                    type = "rest"
143                    file_name = "async_client"
144                    class_name = "AsyncSpeakRESTClient"
145                case _:
146                    self._logger.error("parent unknown: %s", self._parent)
147                    self._logger.debug("Version.v LEAVE")
148                    raise DeepgramModuleError("Invalid parent type")
149
150            # create class path
151            path = f"deepgram.clients.speak.v{version}.{type}.{file_name}"
152            self._logger.info("path: %s", path)
153            self._logger.info("class_name: %s", class_name)
154
155            # import class
156            mod = import_module(path)
157            if mod is None:
158                self._logger.error("module path is None")
159                self._logger.debug("Version.v LEAVE")
160                raise DeepgramModuleError("Unable to find package")
161
162            my_class = getattr(mod, class_name)
163            if my_class is None:
164                self._logger.error("my_class is None")
165                self._logger.debug("Version.v LEAVE")
166                raise DeepgramModuleError("Unable to find class")
167
168            # instantiate class
169            my_class = my_class(self._config)
170            self._logger.notice("Version.v succeeded")
171            self._logger.debug("Version.v LEAVE")
172            return my_class

Returns a specific version of the Deepgram API.