changing audio streamer -> audio connector, fixing typos

Author: maxkahan

CHANGES.md

@@ -1,6 +1,6 @@
 # Release v3.4.0
 
-- Support for Audio Streamer (lite) API via `stream_audio_to_websocket` method
+- Support for Audio Connector API via `connect_audio_to_websocket` method
 
 # Release v3.3.0
 

README.rst

@@ -551,18 +551,18 @@ For more information about OpenTok live streaming broadcasts, see the
 `Broadcast developer guide <https://tokbox.com/developer/guides/broadcast/>`_.
 
 
-Streaming audio to a websocket
+Streaming audio to a WebSocket
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-You can stream audio to a websocket with the ``opentok.stream_audio_to_websocket`` method.
+You can stream audio to a WebSocket with the ``opentok.connect_audio_to_websocket`` method.
 For more information, see the
-`Audio Streamer developer guide <https://tokbox.com/developer/guides/audio-streamer/>`_.
+`Audio Connector developer guide <https://tokbox.com/developer/guides/audio-streamer/>`_.
 
 .. code:: python
 
   websocket_options = {"uri": "wss://service.com/ws-endpoint"}
-  websocket_audio_connection = opentok.stream_audio_to_websocket(session_id, opentok_token, websocket_options)
+  websocket_audio_connection = opentok.connect_audio_to_websocket(session_id, opentok_token, websocket_options)
 
-Additionally, you can list only the specific streams you want to send to the websocket, and/or the additional headers that are sent, 
+Additionally, you can list only the specific streams you want to send to the WebSocket, and/or the additional headers that are sent, 
 by adding these fields to the ``websocket_options`` object.
 
 .. code:: python

opentok/__init__.py

@@ -15,4 +15,4 @@
 from .sip_call import SipCall
 from .broadcast import Broadcast, BroadcastStreamModes
 from .render import Render, RenderList
-from .websocket_audio_connection import WebsocketAudioConnection
+from .websocket_audio_connection import WebSocketAudioConnection

opentok/endpoints.py

@@ -209,8 +209,8 @@ def get_render_url(self, render_id: str = None):
 
         return url
 
-    def get_audio_streamer_url(self):
-        """Returns URLs for working with the Audio Streamer (lite) API."""
+    def get_audio_connector_url(self):
+        """Returns URLs for working with the Audio Connector API."""
         url = self.api_url + "/v2/project/" + self.api_key + "/connect"
 
         return url

opentok/exceptions.py

@@ -107,8 +107,6 @@ class BroadcastStreamModeError(OpenTokException):
     Indicates that the broadcast is configured with a streamMode that does not support stream manipulation.
     """
 
-    pass
-
 
 class BroadcastHLSOptionsError(OpenTokException):
     """
@@ -118,9 +116,9 @@ class BroadcastHLSOptionsError(OpenTokException):
     """
 
 
-class InvalidWebsocketOptionsError(OpenTokException):
+class InvalidWebSocketOptionsError(OpenTokException):
     """
-    Indicates that the websocket options selected are invalid.
+    Indicates that the WebSocket options selected are invalid.
     """
 
 

opentok/opentok.py

@@ -32,7 +32,7 @@
 from .streamlist import StreamList
 from .sip_call import SipCall
 from .broadcast import Broadcast, BroadcastStreamModes
-from .websocket_audio_connection import WebsocketAudioConnection
+from .websocket_audio_connection import WebSocketAudioConnection
 from .exceptions import (
     ArchiveStreamModeError,
     BroadcastHLSOptionsError,
@@ -49,7 +49,7 @@
     SetStreamClassError,
     BroadcastError,
     DTMFError,
-    InvalidWebsocketOptionsError,
+    InvalidWebSocketOptionsError,
     InvalidMediaModeError  
 )
 
@@ -1804,14 +1804,14 @@ def list_renders(self, offset=0, count=50):
         else:
             raise RequestError("An unexpected error occurred", response.status_code)
 
-    def stream_audio_to_websocket(self, session_id: str, opentok_token: str, websocket_options: dict):
+    def connect_audio_to_websocket(self, session_id: str, opentok_token: str, websocket_options: dict):
         """
-        Connects audio streams to a specified websocket URI.
-        For more information, see the `Audio Streamer developer guide <https://tokbox.com/developer/guides/audio-streamer/>`.
+        Connects audio streams to a specified WebSocket URI.
+        For more information, see the `Audio Connector developer guide <https://tokbox.com/developer/guides/audio-streamer/>`.
 
-        :param String 'session_id': The OpenTok session ID that includes the OpenTok streams you want to include in the WebSocket stream. The Audio Streamer feature is only supported in routed sessions (sessions that use the OpenTok Media Router).
-        :param String 'opentok_token': The OpenTok token to be used for the Audio Streamer connection to the OpenTok session.
-        :param Dictionary 'websocket_options': Included options for the websocket.
+        :param String 'session_id': The OpenTok session ID that includes the OpenTok streams you want to include in the WebSocket stream. The Audio Connector feature is only supported in routed sessions (sessions that use the OpenTok Media Router).
+        :param String 'opentok_token': The OpenTok token to be used for the Audio Connector connection to the OpenTok session.
+        :param Dictionary 'websocket_options': Included options for the WebSocket.
             String 'uri': A publicly reachable WebSocket URI to be used for the destination of the audio stream (such as "wss://example.com/ws-endpoint").
             List 'streams' Optional: A list of stream IDs for the OpenTok streams you want to include in the WebSocket audio. If you omit this property, all streams in the session will be included.
             Dictionary 'headers' Optional: An object of key-value pairs of headers to be sent to your WebSocket server with each message, with a maximum length of 512 bytes.
@@ -1826,22 +1826,22 @@ def stream_audio_to_websocket(self, session_id: str, opentok_token: str, websock
 
         logger.debug(
             "POST to %r with params %r, headers %r, proxies %r",
-            self.endpoints.get_audio_streamer_url(),
+            self.endpoints.get_audio_connector_url(),
             json.dumps(payload),
             self.get_json_headers(),
             self.proxies,
         )
 
         response = requests.post(
-            self.endpoints.get_audio_streamer_url(),
+            self.endpoints.get_audio_connector_url(),
             json=payload,
             headers=self.get_json_headers(),
             proxies=self.proxies,
             timeout=self.timeout,
         )
 
         if response and response.status_code == 200:
-            return WebsocketAudioConnection(response.json())
+            return WebSocketAudioConnection(response.json())
         elif response.status_code == 400:
             """
             The HTTP response has a 400 status code in the following cases:
@@ -1852,15 +1852,15 @@ def stream_audio_to_websocket(self, session_id: str, opentok_token: str, websock
         elif response.status_code == 403:
             raise AuthError("You passed in an invalid OpenTok API key or JWT token.")
         elif response.status_code == 409:
-            raise InvalidMediaModeError("Only routed sessions are allowed to initiate Audio Streamer WebSocket connections.")
+            raise InvalidMediaModeError("Only routed sessions are allowed to initiate Audio Connector WebSocket connections.")
         else:
             raise RequestError("An unexpected error occurred", response.status_code)
 
     def validate_websocket_options(self, options):
         if type(options) is not dict:
-            raise InvalidWebsocketOptionsError('Must pass websocket options as a dictionary.')
+            raise InvalidWebSocketOptionsError('Must pass WebSocket options as a dictionary.')
         if 'uri' not in options:
-            raise InvalidWebsocketOptionsError('Provide a websocket URI.')
+            raise InvalidWebSocketOptionsError('Provide a WebSocket URI.')
 
     def _sign_string(self, string, secret):
         return hmac.new(

opentok/websocket_audio_connection.py

@@ -1,19 +1,19 @@
 import json
 from six import iteritems
 
-class WebsocketAudioConnection:
-    """Represents information about the audio streaming of an OpenTok session to a websocket."""
+class WebSocketAudioConnection:
+    """Represents information about the audio connection of an OpenTok session to a WebSocket."""
 
     def __init__(self, kwargs):
         self.id = kwargs.get("id")
         self.connectionId = kwargs.get("connectionId")
 
     def json(self):
-        """Returns a JSON representation of the websocket audio connection information."""
+        """Returns a JSON representation of the WebSocket audio connection information."""
         return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
 
     def attrs(self):
         """
-        Returns a dictionary of the websocket audio connection's attributes.
+        Returns a dictionary of the WebSocket audio connection's attributes.
         """
         return dict((k, v) for k, v in iteritems(self.__dict__))

tests/test_audio_streamer.py

@@ -6,8 +6,8 @@
 
 from six import u, PY2, PY3
 from expects import *
-from opentok import Client, WebsocketAudioConnection, __version__
-from opentok.exceptions import InvalidWebsocketOptionsError, InvalidMediaModeError
+from opentok import Client, WebSocketAudioConnection, __version__
+from opentok.exceptions import InvalidWebSocketOptionsError, InvalidMediaModeError
 from .validate_jwt import validate_jwt_header
 
 
@@ -30,7 +30,7 @@ def setUp(self):
         )
 
     @httpretty.activate
-    def test_stream_audio_to_websocket(self):
+    def test_connect_audio_to_websocket(self):
         httpretty.register_uri(
             httpretty.POST,
             u(f"https://api.opentok.com/v2/project/{self.api_key}/connect"),
@@ -43,7 +43,7 @@ def test_stream_audio_to_websocket(self):
             "uri": "wss://service.com/ws-endpoint"
         }
 
-        websocket_audio_connection = self.opentok.stream_audio_to_websocket(self.session_id, self.token, websocket_options)
+        websocket_audio_connection = self.opentok.connect_audio_to_websocket(self.session_id, self.token, websocket_options)
 
         validate_jwt_header(self, httpretty.last_request().headers[u("x-opentok-auth")])
         expect(httpretty.last_request().headers[u("user-agent")]).to(
@@ -60,7 +60,7 @@ def test_stream_audio_to_websocket(self):
             body = json.loads(httpretty.last_request().body.decode("utf-8"))
 
         expect(body).to(have_key(u("token")))
-        expect(websocket_audio_connection).to(be_a(WebsocketAudioConnection))
+        expect(websocket_audio_connection).to(be_a(WebSocketAudioConnection))
         expect(websocket_audio_connection).to(
             have_property(u("id"), u("b0a5a8c7-dc38-459f-a48d-a7f2008da853"))
         )
@@ -69,7 +69,7 @@ def test_stream_audio_to_websocket(self):
         )
 
     @httpretty.activate
-    def test_stream_audio_to_websocket_custom_options(self):
+    def test_connect_audio_to_websocket_custom_options(self):
         httpretty.register_uri(
             httpretty.POST,
             u(f"https://api.opentok.com/v2/project/{self.api_key}/connect"),
@@ -82,11 +82,11 @@ def test_stream_audio_to_websocket_custom_options(self):
             "uri": "wss://service.com/ws-endpoint",
             "streams": ["stream-id-1", "stream-id-2"],
             "headers": {
-                "websocketHeader": "Sent via Audio Streamer API"
+                "WebSocketHeader": "Sent via Audio Connector API"
             }
         }
 
-        websocket_audio_connection = self.opentok.stream_audio_to_websocket(self.session_id, self.token, websocket_options)
+        websocket_audio_connection = self.opentok.connect_audio_to_websocket(self.session_id, self.token, websocket_options)
 
         validate_jwt_header(self, httpretty.last_request().headers[u("x-opentok-auth")])
         expect(httpretty.last_request().headers[u("user-agent")]).to(
@@ -103,7 +103,7 @@ def test_stream_audio_to_websocket_custom_options(self):
             body = json.loads(httpretty.last_request().body.decode("utf-8"))
 
         expect(body).to(have_key(u("token")))
-        expect(websocket_audio_connection).to(be_a(WebsocketAudioConnection))
+        expect(websocket_audio_connection).to(be_a(WebSocketAudioConnection))
         expect(websocket_audio_connection).to(
             have_property(u("id"), u("b0a5a8c7-dc38-459f-a48d-a7f2008da853"))
         )
@@ -112,7 +112,7 @@ def test_stream_audio_to_websocket_custom_options(self):
         )
 
     @httpretty.activate
-    def test_stream_audio_to_websocket_media_mode_error(self):
+    def test_connect_audio_to_websocket_media_mode_error(self):
         httpretty.register_uri(
             httpretty.POST,
             u(f"https://api.opentok.com/v2/project/{self.api_key}/connect"),
@@ -128,8 +128,8 @@ def test_stream_audio_to_websocket_media_mode_error(self):
         session_id = "session-where-mediaMode=relayed-was-selected"
 
         with self.assertRaises(InvalidMediaModeError) as context:
-            self.opentok.stream_audio_to_websocket(session_id, self.token, websocket_options)
-        self.assertTrue("Only routed sessions are allowed to initiate Audio Streamer WebSocket connections." in str(context.exception))
+            self.opentok.connect_audio_to_websocket(session_id, self.token, websocket_options)
+        self.assertTrue("Only routed sessions are allowed to initiate Audio Connector WebSocket connections." in str(context.exception))
 
         validate_jwt_header(self, httpretty.last_request().headers[u("x-opentok-auth")])
         expect(httpretty.last_request().headers[u("user-agent")]).to(
@@ -139,14 +139,14 @@ def test_stream_audio_to_websocket_media_mode_error(self):
             equal(u("application/json"))
         )
 
-    def test_stream_audio_to_websocket_invalid_options_type_error(self):
+    def test_connect_audio_to_websocket_invalid_options_type_error(self):
         websocket_options = "wss://service.com/ws-endpoint"
-        with self.assertRaises(InvalidWebsocketOptionsError) as context:
-            self.opentok.stream_audio_to_websocket(self.session_id, self.token, websocket_options)
-        self.assertTrue("Must pass websocket options as a dictionary." in str(context.exception))
+        with self.assertRaises(InvalidWebSocketOptionsError) as context:
+            self.opentok.connect_audio_to_websocket(self.session_id, self.token, websocket_options)
+        self.assertTrue("Must pass WebSocket options as a dictionary." in str(context.exception))
 
-    def test_stream_audio_to_websocket_missing_uri_error(self):
+    def test_connect_audio_to_websocket_missing_uri_error(self):
         websocket_options = {}
-        with self.assertRaises(InvalidWebsocketOptionsError) as context:
-            self.opentok.stream_audio_to_websocket(self.session_id, self.token, websocket_options)
-        self.assertTrue("Provide a websocket URI." in str(context.exception))
+        with self.assertRaises(InvalidWebSocketOptionsError) as context:
+            self.opentok.connect_audio_to_websocket(self.session_id, self.token, websocket_options)
+        self.assertTrue("Provide a WebSocket URI." in str(context.exception))