deepgram.clients.listen_router

View Source

  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 .listen.v1 import (
 11    PreRecordedClient,
 12    AsyncPreRecordedClient,
 13    LiveClient,
 14    AsyncLiveClient,
 15)
 16from ..utils import verboselogs
 17from ..options import DeepgramClientOptions
 18from .errors import DeepgramModuleError
 19
 20
 21class ListenRouter:
 22    """
 23    Represents a client for interacting with the Deepgram API.
 24
 25    This class provides a client for making requests to the Deepgram API with various configuration options.
 26
 27    Attributes:
 28        config_options (DeepgramClientOptions): An optional configuration object specifying client options.
 29
 30    Raises:
 31        DeepgramApiKeyError: If the API key is missing or invalid.
 32
 33    Methods:
 34        live: (Preferred) Returns a Threaded LiveClient instance for interacting with Deepgram's transcription services.
 35        prerecorded: (Preferred) Returns an Threaded PreRecordedClient instance for interacting with Deepgram's prerecorded transcription services.
 36
 37        asynclive: Returns an (Async) LiveClient instance for interacting with Deepgram's transcription services.
 38        asyncprerecorded: Returns an (Async) PreRecordedClient instance for interacting with Deepgram's prerecorded transcription services.
 39    """
 40
 41    _logger: verboselogs.VerboseLogger
 42    _config: DeepgramClientOptions
 43
 44    def __init__(self, config: DeepgramClientOptions):
 45        self._logger = verboselogs.VerboseLogger(__name__)
 46        self._logger.addHandler(logging.StreamHandler())
 47        self._logger.setLevel(config.verbose)
 48        self._config = config
 49
 50    @property
 51    @deprecation.deprecated(
 52        deprecated_in="3.4.0",
 53        removed_in="4.0.0",
 54        current_version=__version__,
 55        details="deepgram.listen.prerecorded is deprecated. Use deepgram.listen.rest instead.",
 56    )
 57    def prerecorded(self):
 58        """
 59        DEPRECATED: deepgram.listen.prerecorded is deprecated. Use deepgram.listen.rest instead.
 60        """
 61        return self.Version(self._config, "prerecorded")
 62
 63    @property
 64    @deprecation.deprecated(
 65        deprecated_in="3.4.0",
 66        removed_in="4.0.0",
 67        current_version=__version__,
 68        details="deepgram.listen.asyncprerecorded is deprecated. Use deepgram.listen.asyncrest instead.",
 69    )
 70    def asyncprerecorded(self):
 71        """
 72        DEPRECATED: deepgram.listen.asyncprerecorded is deprecated. Use deepgram.listen.asyncrest instead.
 73        """
 74        return self.Version(self._config, "asyncprerecorded")
 75
 76    @property
 77    @deprecation.deprecated(
 78        deprecated_in="3.4.0",
 79        removed_in="4.0.0",
 80        current_version=__version__,
 81        details="deepgram.listen.live is deprecated. Use deepgram.listen.websocket instead.",
 82    )
 83    def live(self):
 84        """
 85        DEPRECATED: deepgram.listen.live is deprecated. Use deepgram.listen.websocket instead.
 86        """
 87        return self.Version(self._config, "live")
 88
 89    @property
 90    @deprecation.deprecated(
 91        deprecated_in="3.4.0",
 92        removed_in="4.0.0",
 93        current_version=__version__,
 94        details="deepgram.listen.asynclive is deprecated. Use deepgram.listen.asyncwebsocket instead.",
 95    )
 96    def asynclive(self):
 97        """
 98        DEPRECATED: deepgram.listen.asynclive is deprecated. Use deepgram.listen.asyncwebsocket instead.
 99        """
100        return self.Version(self._config, "asynclive")
101
102    @property
103    def rest(self):
104        """
105        Returns a ListenRESTClient instance for interacting with Deepgram's prerecorded transcription services.
106        """
107        return self.Version(self._config, "rest")
108
109    @property
110    def asyncrest(self):
111        """
112        Returns an AsyncListenRESTClient instance for interacting with Deepgram's prerecorded transcription services.
113        """
114        return self.Version(self._config, "asyncrest")
115
116    @property
117    def websocket(self):
118        """
119        Returns a ListenWebSocketClient instance for interacting with Deepgram's transcription services.
120        """
121        return self.Version(self._config, "websocket")
122
123    @property
124    def asyncwebsocket(self):
125        """
126        Returns an AsyncListenWebSocketClient instance for interacting with Deepgram's transcription services.
127        """
128        return self.Version(self._config, "asyncwebsocket")
129
130    # INTERNAL CLASSES
131    class Version:
132        """
133        Represents a version of the Deepgram API.
134        """
135
136        _logger: verboselogs.VerboseLogger
137        _config: DeepgramClientOptions
138        _parent: str
139
140        def __init__(self, config, parent: str):
141            self._logger = verboselogs.VerboseLogger(__name__)
142            self._logger.addHandler(logging.StreamHandler())
143            self._logger.setLevel(config.verbose)
144            self._config = config
145            self._parent = parent
146
147        # FUTURE VERSIONING:
148        # When v2 or v1.1beta1 or etc. This allows easy access to the latest version of the API.
149        # @property
150        # def latest(self):
151        #     match self._parent:
152        #         case "live":
153        #             return LiveClient(self._config)
154        #         case "prerecorded":
155        #             return PreRecordedClient(self._config)
156        #         case _:
157        #             raise DeepgramModuleError("Invalid parent")
158
159        def v(self, version: str = ""):
160            """
161            Returns a specific version of the Deepgram API.
162            """
163            self._logger.debug("Version.v ENTER")
164            self._logger.info("version: %s", version)
165            if len(version) == 0:
166                self._logger.error("version is empty")
167                self._logger.debug("Version.v LEAVE")
168                raise DeepgramModuleError("Invalid module version")
169
170            protocol = ""
171            file_name = ""
172            class_name = ""
173            match self._parent:
174                case "live":
175                    return LiveClient(self._config)
176                case "asynclive":
177                    return AsyncLiveClient(self._config)
178                case "prerecorded":
179                    return PreRecordedClient(self._config)
180                case "asyncprerecorded":
181                    return AsyncPreRecordedClient(self._config)
182                case "websocket":
183                    protocol = "websocket"
184                    file_name = "client"
185                    class_name = "ListenWebSocketClient"
186                case "asyncwebsocket":
187                    protocol = "websocket"
188                    file_name = "async_client"
189                    class_name = "AsyncListenWebSocketClient"
190                case "rest":
191                    protocol = "rest"
192                    file_name = "client"
193                    class_name = "ListenRESTClient"
194                case "asyncrest":
195                    protocol = "rest"
196                    file_name = "async_client"
197                    class_name = "AsyncListenRESTClient"
198                case _:
199                    self._logger.error("parent unknown: %s", self._parent)
200                    self._logger.debug("Version.v LEAVE")
201                    raise DeepgramModuleError("Invalid parent type")
202
203            # create class path
204            path = f"deepgram.clients.listen.v{version}.{protocol}.{file_name}"
205            self._logger.info("path: %s", path)
206            self._logger.info("class_name: %s", class_name)
207
208            # import class
209            mod = import_module(path)
210            if mod is None:
211                self._logger.error("module path is None")
212                self._logger.debug("Version.v LEAVE")
213                raise DeepgramModuleError("Unable to find package")
214
215            my_class = getattr(mod, class_name)
216            if my_class is None:
217                self._logger.error("my_class is None")
218                self._logger.debug("Version.v LEAVE")
219                raise DeepgramModuleError("Unable to find class")
220
221            # instantiate class
222            my_class = my_class(self._config)
223            self._logger.notice("Version.v succeeded")
224            self._logger.debug("Version.v LEAVE")
225            return my_class

class ListenRouter: View Source

 22class ListenRouter:
 23    """
 24    Represents a client for interacting with the Deepgram API.
 25
 26    This class provides a client for making requests to the Deepgram API with various configuration options.
 27
 28    Attributes:
 29        config_options (DeepgramClientOptions): An optional configuration object specifying client options.
 30
 31    Raises:
 32        DeepgramApiKeyError: If the API key is missing or invalid.
 33
 34    Methods:
 35        live: (Preferred) Returns a Threaded LiveClient instance for interacting with Deepgram's transcription services.
 36        prerecorded: (Preferred) Returns an Threaded PreRecordedClient instance for interacting with Deepgram's prerecorded transcription services.
 37
 38        asynclive: Returns an (Async) LiveClient instance for interacting with Deepgram's transcription services.
 39        asyncprerecorded: Returns an (Async) PreRecordedClient instance for interacting with Deepgram's prerecorded transcription services.
 40    """
 41
 42    _logger: verboselogs.VerboseLogger
 43    _config: DeepgramClientOptions
 44
 45    def __init__(self, config: DeepgramClientOptions):
 46        self._logger = verboselogs.VerboseLogger(__name__)
 47        self._logger.addHandler(logging.StreamHandler())
 48        self._logger.setLevel(config.verbose)
 49        self._config = config
 50
 51    @property
 52    @deprecation.deprecated(
 53        deprecated_in="3.4.0",
 54        removed_in="4.0.0",
 55        current_version=__version__,
 56        details="deepgram.listen.prerecorded is deprecated. Use deepgram.listen.rest instead.",
 57    )
 58    def prerecorded(self):
 59        """
 60        DEPRECATED: deepgram.listen.prerecorded is deprecated. Use deepgram.listen.rest instead.
 61        """
 62        return self.Version(self._config, "prerecorded")
 63
 64    @property
 65    @deprecation.deprecated(
 66        deprecated_in="3.4.0",
 67        removed_in="4.0.0",
 68        current_version=__version__,
 69        details="deepgram.listen.asyncprerecorded is deprecated. Use deepgram.listen.asyncrest instead.",
 70    )
 71    def asyncprerecorded(self):
 72        """
 73        DEPRECATED: deepgram.listen.asyncprerecorded is deprecated. Use deepgram.listen.asyncrest instead.
 74        """
 75        return self.Version(self._config, "asyncprerecorded")
 76
 77    @property
 78    @deprecation.deprecated(
 79        deprecated_in="3.4.0",
 80        removed_in="4.0.0",
 81        current_version=__version__,
 82        details="deepgram.listen.live is deprecated. Use deepgram.listen.websocket instead.",
 83    )
 84    def live(self):
 85        """
 86        DEPRECATED: deepgram.listen.live is deprecated. Use deepgram.listen.websocket instead.
 87        """
 88        return self.Version(self._config, "live")
 89
 90    @property
 91    @deprecation.deprecated(
 92        deprecated_in="3.4.0",
 93        removed_in="4.0.0",
 94        current_version=__version__,
 95        details="deepgram.listen.asynclive is deprecated. Use deepgram.listen.asyncwebsocket instead.",
 96    )
 97    def asynclive(self):
 98        """
 99        DEPRECATED: deepgram.listen.asynclive is deprecated. Use deepgram.listen.asyncwebsocket instead.
100        """
101        return self.Version(self._config, "asynclive")
102
103    @property
104    def rest(self):
105        """
106        Returns a ListenRESTClient instance for interacting with Deepgram's prerecorded transcription services.
107        """
108        return self.Version(self._config, "rest")
109
110    @property
111    def asyncrest(self):
112        """
113        Returns an AsyncListenRESTClient instance for interacting with Deepgram's prerecorded transcription services.
114        """
115        return self.Version(self._config, "asyncrest")
116
117    @property
118    def websocket(self):
119        """
120        Returns a ListenWebSocketClient instance for interacting with Deepgram's transcription services.
121        """
122        return self.Version(self._config, "websocket")
123
124    @property
125    def asyncwebsocket(self):
126        """
127        Returns an AsyncListenWebSocketClient instance for interacting with Deepgram's transcription services.
128        """
129        return self.Version(self._config, "asyncwebsocket")
130
131    # INTERNAL CLASSES
132    class Version:
133        """
134        Represents a version of the Deepgram API.
135        """
136
137        _logger: verboselogs.VerboseLogger
138        _config: DeepgramClientOptions
139        _parent: str
140
141        def __init__(self, config, parent: str):
142            self._logger = verboselogs.VerboseLogger(__name__)
143            self._logger.addHandler(logging.StreamHandler())
144            self._logger.setLevel(config.verbose)
145            self._config = config
146            self._parent = parent
147
148        # FUTURE VERSIONING:
149        # When v2 or v1.1beta1 or etc. This allows easy access to the latest version of the API.
150        # @property
151        # def latest(self):
152        #     match self._parent:
153        #         case "live":
154        #             return LiveClient(self._config)
155        #         case "prerecorded":
156        #             return PreRecordedClient(self._config)
157        #         case _:
158        #             raise DeepgramModuleError("Invalid parent")
159
160        def v(self, version: str = ""):
161            """
162            Returns a specific version of the Deepgram API.
163            """
164            self._logger.debug("Version.v ENTER")
165            self._logger.info("version: %s", version)
166            if len(version) == 0:
167                self._logger.error("version is empty")
168                self._logger.debug("Version.v LEAVE")
169                raise DeepgramModuleError("Invalid module version")
170
171            protocol = ""
172            file_name = ""
173            class_name = ""
174            match self._parent:
175                case "live":
176                    return LiveClient(self._config)
177                case "asynclive":
178                    return AsyncLiveClient(self._config)
179                case "prerecorded":
180                    return PreRecordedClient(self._config)
181                case "asyncprerecorded":
182                    return AsyncPreRecordedClient(self._config)
183                case "websocket":
184                    protocol = "websocket"
185                    file_name = "client"
186                    class_name = "ListenWebSocketClient"
187                case "asyncwebsocket":
188                    protocol = "websocket"
189                    file_name = "async_client"
190                    class_name = "AsyncListenWebSocketClient"
191                case "rest":
192                    protocol = "rest"
193                    file_name = "client"
194                    class_name = "ListenRESTClient"
195                case "asyncrest":
196                    protocol = "rest"
197                    file_name = "async_client"
198                    class_name = "AsyncListenRESTClient"
199                case _:
200                    self._logger.error("parent unknown: %s", self._parent)
201                    self._logger.debug("Version.v LEAVE")
202                    raise DeepgramModuleError("Invalid parent type")
203
204            # create class path
205            path = f"deepgram.clients.listen.v{version}.{protocol}.{file_name}"
206            self._logger.info("path: %s", path)
207            self._logger.info("class_name: %s", class_name)
208
209            # import class
210            mod = import_module(path)
211            if mod is None:
212                self._logger.error("module path is None")
213                self._logger.debug("Version.v LEAVE")
214                raise DeepgramModuleError("Unable to find package")
215
216            my_class = getattr(mod, class_name)
217            if my_class is None:
218                self._logger.error("my_class is None")
219                self._logger.debug("Version.v LEAVE")
220                raise DeepgramModuleError("Unable to find class")
221
222            # instantiate class
223            my_class = my_class(self._config)
224            self._logger.notice("Version.v succeeded")
225            self._logger.debug("Version.v LEAVE")
226            return my_class

Represents a client for interacting with the Deepgram API.

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

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

Raises: DeepgramApiKeyError: If the API key is missing or invalid.

Methods: live: (Preferred) Returns a Threaded LiveClient instance for interacting with Deepgram's transcription services. prerecorded: (Preferred) Returns an Threaded PreRecordedClient instance for interacting with Deepgram's prerecorded transcription services.

asynclive: Returns an (Async) LiveClient instance for interacting with Deepgram's transcription services.
asyncprerecorded: Returns an (Async) PreRecordedClient instance for interacting with Deepgram's prerecorded transcription services.

ListenRouter(config: deepgram.options.DeepgramClientOptions) View Source

45    def __init__(self, config: DeepgramClientOptions):
46        self._logger = verboselogs.VerboseLogger(__name__)
47        self._logger.addHandler(logging.StreamHandler())
48        self._logger.setLevel(config.verbose)
49        self._config = config

prerecorded View Source

51    @property
52    @deprecation.deprecated(
53        deprecated_in="3.4.0",
54        removed_in="4.0.0",
55        current_version=__version__,
56        details="deepgram.listen.prerecorded is deprecated. Use deepgram.listen.rest instead.",
57    )
58    def prerecorded(self):
59        """
60        DEPRECATED: deepgram.listen.prerecorded is deprecated. Use deepgram.listen.rest instead.
61        """
62        return self.Version(self._config, "prerecorded")

DEPRECATED: deepgram.listen.prerecorded is deprecated. Use deepgram.listen.rest instead.

asyncprerecorded View Source

64    @property
65    @deprecation.deprecated(
66        deprecated_in="3.4.0",
67        removed_in="4.0.0",
68        current_version=__version__,
69        details="deepgram.listen.asyncprerecorded is deprecated. Use deepgram.listen.asyncrest instead.",
70    )
71    def asyncprerecorded(self):
72        """
73        DEPRECATED: deepgram.listen.asyncprerecorded is deprecated. Use deepgram.listen.asyncrest instead.
74        """
75        return self.Version(self._config, "asyncprerecorded")

DEPRECATED: deepgram.listen.asyncprerecorded is deprecated. Use deepgram.listen.asyncrest instead.

live View Source

77    @property
78    @deprecation.deprecated(
79        deprecated_in="3.4.0",
80        removed_in="4.0.0",
81        current_version=__version__,
82        details="deepgram.listen.live is deprecated. Use deepgram.listen.websocket instead.",
83    )
84    def live(self):
85        """
86        DEPRECATED: deepgram.listen.live is deprecated. Use deepgram.listen.websocket instead.
87        """
88        return self.Version(self._config, "live")

DEPRECATED: deepgram.listen.live is deprecated. Use deepgram.listen.websocket instead.

asynclive View Source

 90    @property
 91    @deprecation.deprecated(
 92        deprecated_in="3.4.0",
 93        removed_in="4.0.0",
 94        current_version=__version__,
 95        details="deepgram.listen.asynclive is deprecated. Use deepgram.listen.asyncwebsocket instead.",
 96    )
 97    def asynclive(self):
 98        """
 99        DEPRECATED: deepgram.listen.asynclive is deprecated. Use deepgram.listen.asyncwebsocket instead.
100        """
101        return self.Version(self._config, "asynclive")

DEPRECATED: deepgram.listen.asynclive is deprecated. Use deepgram.listen.asyncwebsocket instead.

rest View Source

103    @property
104    def rest(self):
105        """
106        Returns a ListenRESTClient instance for interacting with Deepgram's prerecorded transcription services.
107        """
108        return self.Version(self._config, "rest")

Returns a ListenRESTClient instance for interacting with Deepgram's prerecorded transcription services.

asyncrest View Source

110    @property
111    def asyncrest(self):
112        """
113        Returns an AsyncListenRESTClient instance for interacting with Deepgram's prerecorded transcription services.
114        """
115        return self.Version(self._config, "asyncrest")

Returns an AsyncListenRESTClient instance for interacting with Deepgram's prerecorded transcription services.

websocket View Source

117    @property
118    def websocket(self):
119        """
120        Returns a ListenWebSocketClient instance for interacting with Deepgram's transcription services.
121        """
122        return self.Version(self._config, "websocket")

Returns a ListenWebSocketClient instance for interacting with Deepgram's transcription services.

asyncwebsocket View Source

124    @property
125    def asyncwebsocket(self):
126        """
127        Returns an AsyncListenWebSocketClient instance for interacting with Deepgram's transcription services.
128        """
129        return self.Version(self._config, "asyncwebsocket")

Returns an AsyncListenWebSocketClient instance for interacting with Deepgram's transcription services.

class ListenRouter.Version: View Source

132    class Version:
133        """
134        Represents a version of the Deepgram API.
135        """
136
137        _logger: verboselogs.VerboseLogger
138        _config: DeepgramClientOptions
139        _parent: str
140
141        def __init__(self, config, parent: str):
142            self._logger = verboselogs.VerboseLogger(__name__)
143            self._logger.addHandler(logging.StreamHandler())
144            self._logger.setLevel(config.verbose)
145            self._config = config
146            self._parent = parent
147
148        # FUTURE VERSIONING:
149        # When v2 or v1.1beta1 or etc. This allows easy access to the latest version of the API.
150        # @property
151        # def latest(self):
152        #     match self._parent:
153        #         case "live":
154        #             return LiveClient(self._config)
155        #         case "prerecorded":
156        #             return PreRecordedClient(self._config)
157        #         case _:
158        #             raise DeepgramModuleError("Invalid parent")
159
160        def v(self, version: str = ""):
161            """
162            Returns a specific version of the Deepgram API.
163            """
164            self._logger.debug("Version.v ENTER")
165            self._logger.info("version: %s", version)
166            if len(version) == 0:
167                self._logger.error("version is empty")
168                self._logger.debug("Version.v LEAVE")
169                raise DeepgramModuleError("Invalid module version")
170
171            protocol = ""
172            file_name = ""
173            class_name = ""
174            match self._parent:
175                case "live":
176                    return LiveClient(self._config)
177                case "asynclive":
178                    return AsyncLiveClient(self._config)
179                case "prerecorded":
180                    return PreRecordedClient(self._config)
181                case "asyncprerecorded":
182                    return AsyncPreRecordedClient(self._config)
183                case "websocket":
184                    protocol = "websocket"
185                    file_name = "client"
186                    class_name = "ListenWebSocketClient"
187                case "asyncwebsocket":
188                    protocol = "websocket"
189                    file_name = "async_client"
190                    class_name = "AsyncListenWebSocketClient"
191                case "rest":
192                    protocol = "rest"
193                    file_name = "client"
194                    class_name = "ListenRESTClient"
195                case "asyncrest":
196                    protocol = "rest"
197                    file_name = "async_client"
198                    class_name = "AsyncListenRESTClient"
199                case _:
200                    self._logger.error("parent unknown: %s", self._parent)
201                    self._logger.debug("Version.v LEAVE")
202                    raise DeepgramModuleError("Invalid parent type")
203
204            # create class path
205            path = f"deepgram.clients.listen.v{version}.{protocol}.{file_name}"
206            self._logger.info("path: %s", path)
207            self._logger.info("class_name: %s", class_name)
208
209            # import class
210            mod = import_module(path)
211            if mod is None:
212                self._logger.error("module path is None")
213                self._logger.debug("Version.v LEAVE")
214                raise DeepgramModuleError("Unable to find package")
215
216            my_class = getattr(mod, class_name)
217            if my_class is None:
218                self._logger.error("my_class is None")
219                self._logger.debug("Version.v LEAVE")
220                raise DeepgramModuleError("Unable to find class")
221
222            # instantiate class
223            my_class = my_class(self._config)
224            self._logger.notice("Version.v succeeded")
225            self._logger.debug("Version.v LEAVE")
226            return my_class

Represents a version of the Deepgram API.

ListenRouter.Version(config, parent: str) View Source

141        def __init__(self, config, parent: str):
142            self._logger = verboselogs.VerboseLogger(__name__)
143            self._logger.addHandler(logging.StreamHandler())
144            self._logger.setLevel(config.verbose)
145            self._config = config
146            self._parent = parent

def v(self, version: str = ''): View Source

160        def v(self, version: str = ""):
161            """
162            Returns a specific version of the Deepgram API.
163            """
164            self._logger.debug("Version.v ENTER")
165            self._logger.info("version: %s", version)
166            if len(version) == 0:
167                self._logger.error("version is empty")
168                self._logger.debug("Version.v LEAVE")
169                raise DeepgramModuleError("Invalid module version")
170
171            protocol = ""
172            file_name = ""
173            class_name = ""
174            match self._parent:
175                case "live":
176                    return LiveClient(self._config)
177                case "asynclive":
178                    return AsyncLiveClient(self._config)
179                case "prerecorded":
180                    return PreRecordedClient(self._config)
181                case "asyncprerecorded":
182                    return AsyncPreRecordedClient(self._config)
183                case "websocket":
184                    protocol = "websocket"
185                    file_name = "client"
186                    class_name = "ListenWebSocketClient"
187                case "asyncwebsocket":
188                    protocol = "websocket"
189                    file_name = "async_client"
190                    class_name = "AsyncListenWebSocketClient"
191                case "rest":
192                    protocol = "rest"
193                    file_name = "client"
194                    class_name = "ListenRESTClient"
195                case "asyncrest":
196                    protocol = "rest"
197                    file_name = "async_client"
198                    class_name = "AsyncListenRESTClient"
199                case _:
200                    self._logger.error("parent unknown: %s", self._parent)
201                    self._logger.debug("Version.v LEAVE")
202                    raise DeepgramModuleError("Invalid parent type")
203
204            # create class path
205            path = f"deepgram.clients.listen.v{version}.{protocol}.{file_name}"
206            self._logger.info("path: %s", path)
207            self._logger.info("class_name: %s", class_name)
208
209            # import class
210            mod = import_module(path)
211            if mod is None:
212                self._logger.error("module path is None")
213                self._logger.debug("Version.v LEAVE")
214                raise DeepgramModuleError("Unable to find package")
215
216            my_class = getattr(mod, class_name)
217            if my_class is None:
218                self._logger.error("my_class is None")
219                self._logger.debug("Version.v LEAVE")
220                raise DeepgramModuleError("Unable to find class")
221
222            # instantiate class
223            my_class = my_class(self._config)
224            self._logger.notice("Version.v succeeded")
225            self._logger.debug("Version.v LEAVE")
226            return my_class

Returns a specific version of the Deepgram API.