chore: refactor base initialization (#686)

Provides for better type checking.

Author: childish-sambino

tests/unit/base/test_version.py

@@ -5,9 +5,6 @@
 
 
 class TestPage(Page):
-    def __init__(self, version, response, *_args, **_kwargs):
-        super(TestPage, self).__init__(version, response)
-
     def get_instance(self, payload):
         return payload
 
@@ -65,7 +62,7 @@ def setUp(self):
         self.response = self.version.page(
             method="GET", uri="/Accounts/AC123/Messages.json"
         )
-        self.page = TestPage(self.version, self.response)
+        self.page = TestPage(self.version, self.response, {})
 
     def test_stream(self):
         messages = list(self.version.stream(self.page))

tests/unit/http/test_http_client.py

@@ -1,13 +1,13 @@
 # -*- coding: utf-8 -*-
-import unittest
 import os
+import unittest
 from collections import OrderedDict
 
-from mock import patch, Mock
+from mock import Mock, patch
 from requests import Session
 
-from twilio.base.version import Version
 from twilio.base.exceptions import TwilioRestException
+from twilio.base.version import Version
 from twilio.http.http_client import TwilioHttpClient
 from twilio.http.response import Response
 
@@ -269,6 +269,5 @@ def test_session_not_preserved(self):
 
 class MyVersion(Version):
     def __init__(self, domain):
-        super(MyVersion, self).__init__(domain)
-        self.version = "v1"
+        super().__init__(domain, "v1")
         self._credentials = None

twilio/base/client_base.py

@@ -1,12 +1,13 @@
 import os
 import platform
+from typing import Dict, Optional, Tuple
+from urllib.parse import urlparse, urlunparse
+
 from twilio import __version__
 from twilio.base.exceptions import TwilioException
+from twilio.http import HttpClient
 from twilio.http.http_client import TwilioHttpClient
-from urllib.parse import (
-    urlparse,
-    urlunparse,
-)
+from twilio.http.response import Response
 
 
 class ClientBase(object):
@@ -34,18 +35,13 @@ def __init__(
         :param dict environment: Environment to look for auth details, defaults to os.environ
         :param str edge: Twilio Edge to make requests to, defaults to None
         :param list[str] user_agent_extensions: Additions to the user agent string
-
-        :returns: Twilio Client
-        :rtype: twilio.rest.Client
         """
         environment = environment or os.environ
 
         self.username = username or environment.get("TWILIO_ACCOUNT_SID")
         """ :type : str """
         self.password = password or environment.get("TWILIO_AUTH_TOKEN")
         """ :type : str """
-        self.account_sid = account_sid or self.username
-        """ :type : str """
         self.edge = edge or environment.get("TWILIO_EDGE")
         """ :type : str """
         self.region = region or environment.get("TWILIO_REGION")
@@ -56,9 +52,11 @@ def __init__(
         if not self.username or not self.password:
             raise TwilioException("Credentials are required to create a TwilioClient")
 
+        self.account_sid = account_sid or self.username
+        """ :type : str """
         self.auth = (self.username, self.password)
         """ :type : tuple(str, str) """
-        self.http_client = http_client or TwilioHttpClient()
+        self.http_client: HttpClient = http_client or TwilioHttpClient()
         """ :type : HttpClient """
 
     def request(
@@ -71,7 +69,7 @@ def request(
         auth=None,
         timeout=None,
         allow_redirects=False,
-    ):
+    ) -> Response:
         """
         Makes a request to the Twilio API using the configured http client
         Authentication information is automatically added if none is provided
@@ -86,7 +84,6 @@ def request(
         :param bool allow_redirects: Should the client follow redirects
 
         :returns: Response from the Twilio API
-        :rtype: twilio.http.response.Response
         """
         auth = self.get_auth(auth)
         headers = self.get_headers(method, headers)
@@ -113,7 +110,7 @@ async def request_async(
         auth=None,
         timeout=None,
         allow_redirects=False,
-    ):
+    ) -> Response:
         """
         Asynchronously makes a request to the Twilio API  using the configured http client
         The configured http client must be an asynchronous http client
@@ -129,7 +126,6 @@ async def request_async(
         :param bool allow_redirects: Should the client follow redirects
 
         :returns: Response from the Twilio API
-        :rtype: twilio.http.response.Response
         """
         if not self.http_client.is_async:
             raise RuntimeError(
@@ -151,22 +147,22 @@ async def request_async(
             allow_redirects=allow_redirects,
         )
 
-    def get_auth(self, auth):
+    def get_auth(self, auth: Optional[Tuple[str, str]]) -> Tuple[str, str]:
         """
         Get the request authentication object
-        :param tuple(str, str) auth: Authentication (username, password)
+        :param auth: Authentication (username, password)
         :returns: The authentication object
-        :rtype: tuple(str, str)
         """
         return auth or self.auth
 
-    def get_headers(self, method, headers):
+    def get_headers(
+        self, method: str, headers: Optional[Dict[str, str]]
+    ) -> Dict[str, str]:
         """
         Get the request headers including user-agent, extensions, encoding, content-type, MIME type
-        :param str method: HTTP method
-        :param dict[str, str] headers: HTTP headers
+        :param method: HTTP method
+        :param headers: HTTP headers
         :returns: HTTP headers
-        :rtype: dict[str, str]
         """
         headers = headers or {}
 
@@ -195,15 +191,14 @@ def get_headers(self, method, headers):
 
         return headers
 
-    def get_hostname(self, uri):
+    def get_hostname(self, uri: str) -> str:
         """
         Determines the proper hostname given edge and region preferences
         via client configuration or uri.
 
-        :param str uri: Fully qualified url
+        :param uri: Fully qualified url
 
         :returns: The final uri used to make the request
-        :rtype: str
         """
         if not self.edge and not self.region:
             return uri
@@ -228,13 +223,12 @@ def get_hostname(self, uri):
         parsed_url = parsed_url._replace(
             netloc=".".join([part for part in [prefix, edge, region, suffix] if part])
         )
-        return urlunparse(parsed_url)
+        return str(urlunparse(parsed_url))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """
         Provide a friendly representation
 
         :returns: Machine friendly representation
-        :rtype: str
         """
         return "<Twilio {}>".format(self.account_sid)

twilio/base/domain.py

@@ -1,19 +1,18 @@
+from twilio.rest import Client
+
+
 class Domain(object):
     """
     This represents at Twilio API subdomain.
 
     Like, `api.twilio.com` or `lookups.twilio.com'.
     """
 
-    def __init__(self, twilio):
-        """
-        :param Twilio twilio:
-        :return:
-        """
+    def __init__(self, twilio: Client, base_url: str):
         self.twilio = twilio
-        self.base_url = None
+        self.base_url = base_url
 
-    def absolute_url(self, uri):
+    def absolute_url(self, uri: str) -> str:
         """
         Converts a relative `uri` to an absolute url.
         :param string uri: The relative uri to make absolute.

twilio/base/page.py

@@ -25,12 +25,12 @@ class Page(object):
         "uri",
     }
 
-    def __init__(self, version, response):
+    def __init__(self, version, response, solution):
         payload = self.process_response(response)
 
         self._version = version
         self._payload = payload
-        self._solution = {}
+        self._solution = solution
         self._records = iter(self.load_page(payload))
 
     def __iter__(self):

twilio/base/version.py

@@ -1,6 +1,7 @@
 import json
 
 from twilio.base import values
+from twilio.base.domain import Domain
 from twilio.base.exceptions import TwilioRestException
 
 
@@ -9,13 +10,9 @@ class Version(object):
     Represents an API version.
     """
 
-    def __init__(self, domain):
-        """
-        :param Domain domain:
-        :return:
-        """
+    def __init__(self, domain: Domain, version: str):
         self.domain = domain
-        self.version = None
+        self.version = version
 
     def absolute_url(self, uri):
         """

twilio/rest/accounts/AccountsBase.py

@@ -19,26 +19,22 @@ def __init__(self, twilio):
         Initialize the Accounts Domain
 
         :returns: Domain for Accounts
-        :rtype: twilio.rest.accounts.Accounts
         """
-        super().__init__(twilio)
-        self.base_url = "https://accounts.twilio.com"
+        super().__init__(twilio, "https://accounts.twilio.com")
         self._v1 = None
 
     @property
-    def v1(self):
+    def v1(self) -> V1:
         """
         :returns: Versions v1 of Accounts
-        :rtype: twilio.rest.accounts.v1.V1
         """
         if self._v1 is None:
             self._v1 = V1(self)
         return self._v1
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """
         Provide a friendly representation
         :returns: Machine friendly representation
-        :rtype: str
         """
         return "<Twilio.Accounts>"

twilio/rest/accounts/v1/__init__.py

@@ -26,35 +26,25 @@ def __init__(self, domain: Domain):
 
         :param domain: The Twilio.accounts domain
         """
-        super().__init__(domain)
-        self.version = "v1"
+        super().__init__(domain, "v1")
         self._auth_token_promotion = None
         self._credentials = None
         self._secondary_auth_token = None
 
     @property
     def auth_token_promotion(self) -> AuthTokenPromotionList:
-        """
-        :rtype: twilio.rest.accounts.v1.auth_token_promotion.AuthTokenPromotionList
-        """
         if self._auth_token_promotion is None:
             self._auth_token_promotion = AuthTokenPromotionList(self)
         return self._auth_token_promotion
 
     @property
     def credentials(self) -> CredentialList:
-        """
-        :rtype: twilio.rest.accounts.v1.credential.CredentialList
-        """
         if self._credentials is None:
             self._credentials = CredentialList(self)
         return self._credentials
 
     @property
     def secondary_auth_token(self) -> SecondaryAuthTokenList:
-        """
-        :rtype: twilio.rest.accounts.v1.secondary_auth_token.SecondaryAuthTokenList
-        """
         if self._secondary_auth_token is None:
             self._secondary_auth_token = SecondaryAuthTokenList(self)
         return self._secondary_auth_token
@@ -63,6 +53,5 @@ def __repr__(self) -> str:
         """
         Provide a friendly representation
         :returns: Machine friendly representation
-        :rtype: str
         """
         return "<Twilio.Accounts.V1>"

twilio/rest/accounts/v1/credential/aws.py

@@ -296,21 +296,6 @@ def __repr__(self):
 
 
 class AwsPage(Page):
-    def __init__(self, version, response, solution):
-        """
-        Initialize the AwsPage
-
-        :param Version version: Version that contains the resource
-        :param Response response: Response from the API
-
-        :returns: twilio.rest.accounts.v1.credential.aws.AwsPage
-        :rtype: twilio.rest.accounts.v1.credential.aws.AwsPage
-        """
-        super().__init__(version, response)
-
-        # Path solution
-        self._solution = solution
-
     def get_instance(self, payload):
         """
         Build an instance of AwsInstance
@@ -322,12 +307,11 @@ def get_instance(self, payload):
         """
         return AwsInstance(self._version, payload)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """
         Provide a friendly representation
 
         :returns: Machine friendly representation
-        :rtype: str
         """
         return "<Twilio.Accounts.V1.AwsPage>"