telesign 2.2.2__tar.gz → 2.2.4__tar.gz

{telesign-2.2.2 → telesign-2.2.4}/LICENSE.txt

@@ -1,11 +1,11 @@
-Copyright (c) 2017 TeleSign Corp.
+Copyright (c) 2023 Telesign Corp.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.

{telesign-2.2.2/telesign.egg-info → telesign-2.2.4}/PKG-INFO

@@ -1,25 +1,25 @@
 Metadata-Version: 1.1
 Name: telesign
-Version: 2.2.2
+Version: 2.2.4
 Summary: TeleSign SDK
 Home-page: https://github.com/telesign/python_telesign
 Author: TeleSign Corp.
 Author-email: support@telesign.com
 License: MIT
 Description: .. image:: https://raw.github.com/TeleSign/python_telesign/master/python_banner.jpg
-            :target: https://developer.telesign.com
+               :target: https://standard.telesign.com
         
         .. image:: https://img.shields.io/travis/TeleSign/python_telesign.svg
-            :target: https://travis-ci.org/TeleSign/python_telesign
+               :target: https://travis-ci.org/TeleSign/python_telesign
         
         .. image:: https://img.shields.io/codecov/c/github/TeleSign/python_telesign.svg
-            :target: https://codecov.io/gh/TeleSign/python_telesign
+               :target: https://codecov.io/gh/TeleSign/python_telesign
         
         .. image:: https://img.shields.io/pypi/v/telesign.svg
-            :target: https://pypi.python.org/pypi/telesign
+               :target: https://pypi.python.org/pypi/telesign
         
         .. image:: https://img.shields.io/pypi/l/telesign.svg
-            :target: https://github.com/TeleSign/python_telesign/blob/master/LICENSE
+               :target: https://github.com/TeleSign/python_telesign/blob/master/LICENSE
         
         ===================
         TeleSign Python SDK
@@ -36,7 +36,7 @@ Description: .. image:: https://raw.github.com/TeleSign/python_telesign/master/p
         -------------
         
         Code documentation is included in the SDK. Complete documentation, quick start guides and reference material
-        for the TeleSign API is available within the `TeleSign Developer Center <https://developer.telesign.com/>`_.
+        for the TeleSign API is available within the `TeleSign Standard Documentation <https://standard.telesign.com/>`_.
         
         Installation
         ------------
@@ -88,14 +88,14 @@ Description: .. image:: https://raw.github.com/TeleSign/python_telesign/master/p
             print(response.json)
         
         .. code-block:: javascript
-            
+               
             {'reference_id': 'DGFDF6E11AB86303ASDFD425BE00000657',
              'status': {'code': 103,
                 'description': 'Call in progress',
                 'updated_on': '2016-12-12T00:39:58.325559Z'}}
         
         For more examples, see the `examples <https://github.com/TeleSign/python_telesign/tree/master/examples>`_ folder or
-        visit the `TeleSign Developer Center <https://developer.telesign.com/>`_.
+        visit the `TeleSign Standard Documentation <https://standard.telesign.com/>`_.
         
 Keywords: telesign,sms,voice,mobile,authentication,identity,messaging
 Platform: UNKNOWN

{telesign-2.2.2 → telesign-2.2.4}/README.rst

@@ -1,17 +1,17 @@
 .. image:: https://raw.github.com/TeleSign/python_telesign/master/python_banner.jpg
-    :target: https://developer.telesign.com
+       :target: https://standard.telesign.com
 
 .. image:: https://img.shields.io/travis/TeleSign/python_telesign.svg
-    :target: https://travis-ci.org/TeleSign/python_telesign
+       :target: https://travis-ci.org/TeleSign/python_telesign
 
 .. image:: https://img.shields.io/codecov/c/github/TeleSign/python_telesign.svg
-    :target: https://codecov.io/gh/TeleSign/python_telesign
+       :target: https://codecov.io/gh/TeleSign/python_telesign
 
 .. image:: https://img.shields.io/pypi/v/telesign.svg
-    :target: https://pypi.python.org/pypi/telesign
+       :target: https://pypi.python.org/pypi/telesign
 
 .. image:: https://img.shields.io/pypi/l/telesign.svg
-    :target: https://github.com/TeleSign/python_telesign/blob/master/LICENSE
+       :target: https://github.com/TeleSign/python_telesign/blob/master/LICENSE
 
 ===================
 TeleSign Python SDK
@@ -28,7 +28,7 @@ Documentation
 -------------
 
 Code documentation is included in the SDK. Complete documentation, quick start guides and reference material
-for the TeleSign API is available within the `TeleSign Developer Center <https://developer.telesign.com/>`_.
+for the TeleSign API is available within the `TeleSign Standard Documentation <https://standard.telesign.com/>`_.
 
 Installation
 ------------
@@ -80,11 +80,11 @@ Here is a basic code example with the JSON response.
     print(response.json)
 
 .. code-block:: javascript
-    
+       
     {'reference_id': 'DGFDF6E11AB86303ASDFD425BE00000657',
      'status': {'code': 103,
         'description': 'Call in progress',
         'updated_on': '2016-12-12T00:39:58.325559Z'}}
 
 For more examples, see the `examples <https://github.com/TeleSign/python_telesign/tree/master/examples>`_ folder or
-visit the `TeleSign Developer Center <https://developer.telesign.com/>`_.
+visit the `TeleSign Standard Documentation <https://standard.telesign.com/>`_.

telesign-2.2.4/examples/intelligence/1_get_risk_score_and_related_insights.py

@@ -0,0 +1,29 @@
+"""Example code that makes requests to intelligence API."""
+from __future__ import print_function
+from telesign.intelligence import IntelligenceClient
+
+customer_1 = "your_customer_id-44ZA-47B5-95B9-ACXM9B1E5CAA"
+api_key_1 = "your_api_key_or_password"
+
+phone_number = "15555551212"
+account_lifecycle_event = "create"
+
+body = {
+    "contact_details": {"email": "ghopper@gmail.com", "phone_number": "15555551212"},
+    "external_id": "REG432538",
+    "account_lifecycle_event": "create",
+    "ip": "1.1.1.1",
+    "device_id": "2e4fa042234d",
+}
+
+client = IntelligenceClient(customer_1, api_key_1)
+response = client.intelligence(body)
+
+if response.ok:
+    print(
+        "Phone number {} has a '{}' risk level and the score is '{}'.".format(
+            response.json["phone_details"]["numbering"]["original"]["phone_number"],
+            response.json["risk"]["level"],
+            response.json["risk"]["score"],
+        )
+    )

{telesign-2.2.2 → telesign-2.2.4}/setup.py

@@ -11,7 +11,7 @@ mock = ['mock'] if needs_mock else []
 
 here = path.abspath(path.dirname(__file__))
 
-version = "2.2.2"
+version = "2.2.4"
 
 with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
     long_description = f.read()

telesign-2.2.4/telesign/intelligence.py

@@ -0,0 +1,39 @@
+"""Client to make requests to intelligence API."""
+from __future__ import unicode_literals
+
+from telesign.rest import RestClient
+from telesign.util import AuthMethod
+
+INTELLIGENCE_BASE_URL = "https://detect.telesign.com"
+INTELLIGENCE_ENDPOINT_PATH = "/intelligence"
+
+
+class IntelligenceClient(RestClient):
+    """
+    It is critical today to evaluate fraud risk throughout the entire customer journey.
+
+    Telesign Intelligence makes it easy to understand the risk and the reason behind it with tailored scoring models
+    and comprehensive reason codes.
+    """
+
+    def __init__(self, customer_id, api_key, **kwargs):
+        super(IntelligenceClient, self).__init__(
+            customer_id=customer_id,
+            api_key=api_key,
+            rest_endpoint=INTELLIGENCE_BASE_URL,
+            auth_method=AuthMethod.BASIC.value,
+            **kwargs
+        )
+
+    def intelligence(self, params):
+        """
+        Telesign Intelligence is like a credit check for digital profiles.
+
+        You submit a phone number, IP, and email to the service, the individual
+        identifiers are each evaluated, and then a score is returned telling you how risky
+        that user is. You decide whether to proceed based on the score.
+
+        See https://developer.telesign.com/enterprise/docs/intelligence-overview
+        for detailed API documentation.
+        """
+        return self.post(INTELLIGENCE_ENDPOINT_PATH, body=params, query_params=None)

telesign-2.2.4/telesign/phoneid.py

@@ -0,0 +1,28 @@
+from __future__ import unicode_literals
+
+import json
+
+from telesign.rest import RestClient
+
+PHONEID_RESOURCE = "/v1/phoneid/{phone_number}"
+
+
+class PhoneIdClient(RestClient):
+    """
+    A set of APIs that deliver deep phone number data attributes that help optimize the end user
+    verification process and evaluate risk.
+    """
+
+    def __init__(self, customer_id, api_key, **kwargs):
+        super(PhoneIdClient, self).__init__(customer_id, api_key, **kwargs)
+
+    def phoneid(self, phone_number, **params):
+        """
+        The PhoneID API provides a cleansed phone number, phone type, and telecom carrier information to determine the
+        best communication method - SMS or voice.
+
+        See https://developer.telesign.com/docs/phoneid-api for detailed API documentation.
+        """
+        return self.post(PHONEID_RESOURCE.format(phone_number=phone_number),
+                        json_fields=params,
+                        **params)

{telesign-2.2.2 → telesign-2.2.4}/telesign/rest.py

@@ -1,6 +1,5 @@
 from __future__ import unicode_literals
 
-from requests import post
 import hmac
 import uuid
 from base64 import b64encode, b64decode
@@ -9,8 +8,10 @@ from hashlib import sha256
 from platform import python_version
 
 import requests
+import json
 
 import telesign
+from telesign.util import AuthMethod
 
 
 class RestClient(requests.models.RequestEncodingMixin):
@@ -51,7 +52,8 @@ class RestClient(requests.models.RequestEncodingMixin):
                  api_key,
                  rest_endpoint='https://rest-api.telesign.com',
                  proxies=None,
-                 timeout=10):
+                 timeout=10,
+                 auth_method=None):
         """
         TeleSign RestClient useful for making generic RESTful requests against our API.
 
@@ -73,6 +75,8 @@ class RestClient(requests.models.RequestEncodingMixin):
 
         self.timeout = timeout
 
+        self.auth_method = auth_method
+
     @staticmethod
     def generate_telesign_headers(customer_id,
                                   api_key,
@@ -82,7 +86,8 @@ class RestClient(requests.models.RequestEncodingMixin):
                                   date_rfc2616=None,
                                   nonce=None,
                                   user_agent=None,
-                                  content_type=None):
+                                  content_type=None,
+                                  auth_method=None):
         """
         Generates the TeleSign REST API headers used to authenticate requests.
 
@@ -101,6 +106,7 @@ class RestClient(requests.models.RequestEncodingMixin):
         :param nonce: A unique cryptographic nonce for the request, as a string.
         :param user_agent: (optional) User Agent associated with the request, as a string.
         :param content_type: (optional) ContentType of the request, as a string.
+        :param auth_method: (optional) Authentication type ex: Basic, HMAC etc
         :return: The TeleSign authentication headers.
         """
         if date_rfc2616 is None:
@@ -112,31 +118,39 @@ class RestClient(requests.models.RequestEncodingMixin):
         if not content_type:
             content_type = "application/x-www-form-urlencoded" if method_name in ("POST", "PUT") else ""
 
-        auth_method = "HMAC-SHA256"
+        # Default auth_method is Digest if not explicitly specified
+        if auth_method == AuthMethod.BASIC:
+            usr_apikey = "{customer_id}:{api_key}".format(customer_id=customer_id,
+                                                          api_key=api_key)
+            b64val = b64encode(usr_apikey.encode())
+            authorization = "{auth_method} {b64val}".format(auth_method=AuthMethod.BASIC,
+                                                            b64val=b64val.decode())
+        else:
+            auth_method = AuthMethod.HMAC_SHA256
 
-        string_to_sign_builder = ["{method}".format(method=method_name)]
+            string_to_sign_builder = ["{method}".format(method=method_name)]
 
-        string_to_sign_builder.append("\n{content_type}".format(content_type=content_type))
+            string_to_sign_builder.append("\n{content_type}".format(content_type=content_type))
 
-        string_to_sign_builder.append("\n{date}".format(date=date_rfc2616))
+            string_to_sign_builder.append("\n{date}".format(date=date_rfc2616))
 
-        string_to_sign_builder.append("\nx-ts-auth-method:{auth_method}".format(auth_method=auth_method))
+            string_to_sign_builder.append("\nx-ts-auth-method:{auth_method}".format(auth_method=auth_method))
 
-        string_to_sign_builder.append("\nx-ts-nonce:{nonce}".format(nonce=nonce))
+            string_to_sign_builder.append("\nx-ts-nonce:{nonce}".format(nonce=nonce))
 
-        if content_type and url_encoded_fields:
-            string_to_sign_builder.append("\n{fields}".format(fields=url_encoded_fields))
+            if content_type and url_encoded_fields:
+                string_to_sign_builder.append("\n{fields}".format(fields=url_encoded_fields))
 
-        string_to_sign_builder.append("\n{resource}".format(resource=resource))
+            string_to_sign_builder.append("\n{resource}".format(resource=resource))
 
-        string_to_sign = "".join(string_to_sign_builder)
+            string_to_sign = "".join(string_to_sign_builder)
 
-        signer = hmac.new(b64decode(api_key), string_to_sign.encode("utf-8"), sha256)
-        signature = b64encode(signer.digest()).decode("utf-8")
+            signer = hmac.new(b64decode(api_key), string_to_sign.encode("utf-8"), sha256)
+            signature = b64encode(signer.digest()).decode("utf-8")
 
-        authorization = "TSA {customer_id}:{signature}".format(
-            customer_id=customer_id,
-            signature=signature)
+            authorization = "TSA {customer_id}:{signature}".format(
+                customer_id=customer_id,
+                signature=signature)
 
         headers = {
             "Authorization": authorization,
@@ -151,69 +165,89 @@ class RestClient(requests.models.RequestEncodingMixin):
 
         return headers
 
-    def post(self, resource, **params):
+    def post(self, resource, body=None, json_fields=None, **query_params):
         """
         Generic TeleSign REST API POST handler.
 
         :param resource: The partial resource URI to perform the request against, as a string.
-        :param params: Body params to perform the POST request with, as a dictionary.
+        :param body: (optional) A dictionary sent as a part of request body.
+        :param query_params: query_params to perform the POST request with, as a dictionary.
         :return: The RestClient Response object.
         """
-        return self._execute(self.session.post, 'POST', resource, **params)
+        return self._execute(self.session.post, 'POST', resource, body, json_fields, **query_params)
 
-    def get(self, resource, **params):
+    def get(self, resource, body=None, json_fields=None, **query_params):
         """
         Generic TeleSign REST API GET handler.
 
         :param resource: The partial resource URI to perform the request against, as a string.
-        :param params: Body params to perform the GET request with, as a dictionary.
+        :param body: (optional) A dictionary sent as a part of request body.
+        :param query_params: query_params to perform the GET request with, as a dictionary.
         :return: The RestClient Response object.
         """
-        return self._execute(self.session.get, 'GET', resource, **params)
+        return self._execute(self.session.get, 'GET', resource, body, json_fields, **query_params)
 
-    def put(self, resource, **params):
+    def put(self, resource, body=None, json_fields=None, **query_params):
         """
         Generic TeleSign REST API PUT handler.
 
         :param resource: The partial resource URI to perform the request against, as a string.
-        :param params: Body params to perform the PUT request with, as a dictionary.
+        :param body: (optional) A dictionary sent as a part of request body.
+        :param query_params: query_params to perform the PUT request with, as a dictionary.
         :return: The RestClient Response object.
         """
-        return self._execute(self.session.put, 'PUT', resource, **params)
+        return self._execute(self.session.put, 'PUT', resource, body, json_fields, **query_params)
 
-    def delete(self, resource, **params):
+    def delete(self, resource, body=None, json_fields=None, **query_params):
         """
         Generic TeleSign REST API DELETE handler.
 
         :param resource: The partial resource URI to perform the request against, as a string.
-        :param params: Body params to perform the DELETE request with, as a dictionary.
+        :param body: (optional) A dictionary sent as a part of request body.
+        :param query_params: query_params to perform the DELETE request with, as a dictionary.
         :return: The RestClient Response object.
         """
-        return self._execute(self.session.delete, 'DELETE', resource, **params)
+        return self._execute(self.session.delete, 'DELETE', resource, body, json_fields, **query_params)
 
-    def _execute(self, method_function, method_name, resource, **params):
+    def _execute(self, method_function, method_name, resource, body=None, json_fields=None, **query_params):
         """
         Generic TeleSign REST API request handler.
 
         :param method_function: The Requests HTTP request function to perform the request.
         :param method_name: The HTTP method name, as an upper case string.
         :param resource: The partial resource URI to perform the request against, as a string.
-        :param params: Body params to perform the HTTP request with, as a dictionary.
+        :param body: (optional) A dictionary sent as a part of request body.
+        :param query_params: query_params to perform the HTTP request with, as a dictionary.
         :return: The RestClient Response object.
         """
         resource_uri = "{api_host}{resource}".format(api_host=self.api_host, resource=resource)
 
-        url_encoded_fields = self._encode_params(params)
+        url_encoded_fields = self._encode_params(query_params)
+        if json_fields:
+            fields = json.dumps(json_fields)
+            url_encoded_fields = fields
+
+        if body or json_fields:
+            content_type = "application/json"
+        else:
+            content_type = None  # set later
 
         headers = RestClient.generate_telesign_headers(self.customer_id,
                                                        self.api_key,
                                                        method_name,
                                                        resource,
                                                        url_encoded_fields,
-                                                       user_agent=self.user_agent)
-
+                                                       user_agent=self.user_agent,
+                                                       content_type=content_type,
+                                                       auth_method=self.auth_method)
         if method_name in ['POST', 'PUT']:
-            payload = {'data': url_encoded_fields}
+            payload = {}
+            if body:
+                payload['json'] = body
+            if query_params:
+                payload['data'] = url_encoded_fields
+            if json_fields:
+                payload = {'data': url_encoded_fields}
         else:
             payload = {'params': url_encoded_fields}
 

{telesign-2.2.2 → telesign-2.2.4}/telesign/util.py

@@ -4,6 +4,7 @@ from hmac import HMAC
 from base64 import b64decode, b64encode
 from hashlib import sha256
 from random import SystemRandom
+from enum import Enum
 
 
 def to_utc_rfc3339(a_datetime):
@@ -40,3 +41,8 @@ def verify_telesign_callback_signature(api_key, signature, json_str):
             signatures_equal = False
 
     return signatures_equal
+
+
+class AuthMethod(Enum):
+    BASIC = "Basic"
+    HMAC_SHA256 = "HMAC-SHA256"

{telesign-2.2.2 → telesign-2.2.4/telesign.egg-info}/PKG-INFO

@@ -1,25 +1,25 @@
 Metadata-Version: 1.1
 Name: telesign
-Version: 2.2.2
+Version: 2.2.4
 Summary: TeleSign SDK
 Home-page: https://github.com/telesign/python_telesign
 Author: TeleSign Corp.
 Author-email: support@telesign.com
 License: MIT
 Description: .. image:: https://raw.github.com/TeleSign/python_telesign/master/python_banner.jpg
-            :target: https://developer.telesign.com
+               :target: https://standard.telesign.com
         
         .. image:: https://img.shields.io/travis/TeleSign/python_telesign.svg
-            :target: https://travis-ci.org/TeleSign/python_telesign
+               :target: https://travis-ci.org/TeleSign/python_telesign
         
         .. image:: https://img.shields.io/codecov/c/github/TeleSign/python_telesign.svg
-            :target: https://codecov.io/gh/TeleSign/python_telesign
+               :target: https://codecov.io/gh/TeleSign/python_telesign
         
         .. image:: https://img.shields.io/pypi/v/telesign.svg
-            :target: https://pypi.python.org/pypi/telesign
+               :target: https://pypi.python.org/pypi/telesign
         
         .. image:: https://img.shields.io/pypi/l/telesign.svg
-            :target: https://github.com/TeleSign/python_telesign/blob/master/LICENSE
+               :target: https://github.com/TeleSign/python_telesign/blob/master/LICENSE
         
         ===================
         TeleSign Python SDK
@@ -36,7 +36,7 @@ Description: .. image:: https://raw.github.com/TeleSign/python_telesign/master/p
         -------------
         
         Code documentation is included in the SDK. Complete documentation, quick start guides and reference material
-        for the TeleSign API is available within the `TeleSign Developer Center <https://developer.telesign.com/>`_.
+        for the TeleSign API is available within the `TeleSign Standard Documentation <https://standard.telesign.com/>`_.
         
         Installation
         ------------
@@ -88,14 +88,14 @@ Description: .. image:: https://raw.github.com/TeleSign/python_telesign/master/p
             print(response.json)
         
         .. code-block:: javascript
-            
+               
             {'reference_id': 'DGFDF6E11AB86303ASDFD425BE00000657',
              'status': {'code': 103,
                 'description': 'Call in progress',
                 'updated_on': '2016-12-12T00:39:58.325559Z'}}
         
         For more examples, see the `examples <https://github.com/TeleSign/python_telesign/tree/master/examples>`_ folder or
-        visit the `TeleSign Developer Center <https://developer.telesign.com/>`_.
+        visit the `TeleSign Standard Documentation <https://standard.telesign.com/>`_.
         
 Keywords: telesign,sms,voice,mobile,authentication,identity,messaging
 Platform: UNKNOWN

{telesign-2.2.2 → telesign-2.2.4}/telesign.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.rst
 setup.cfg
 setup.py
 examples/appverify/1_get_status_by_external_id.py
+examples/intelligence/1_get_risk_score_and_related_insights.py
 examples/messaging/1_send_message.py
 examples/messaging/2_send_message_with_verification_code.py
 examples/phoneid/1_check_phone_type_to_block_voip.py
@@ -14,6 +15,7 @@ examples/voice/2_send_voice_call_with_verification_code.py
 examples/voice/3_send_voice_call_french.py
 telesign/__init__.py
 telesign/appverify.py
+telesign/intelligence.py
 telesign/messaging.py
 telesign/phoneid.py
 telesign/rest.py
@@ -26,5 +28,6 @@ telesign.egg-info/dependency_links.txt
 telesign.egg-info/requires.txt
 telesign.egg-info/top_level.txt
 tests/__init__.py
+tests/test_phoneid.py
 tests/test_rest.py
 tests/test_util.py

telesign-2.2.4/tests/test_phoneid.py

@@ -0,0 +1,48 @@
+from __future__ import unicode_literals
+import os
+from unittest import TestCase
+from telesign.phoneid import PhoneIdClient
+
+class TestPhoneId(TestCase):
+    def setUp(self):
+        self.customer_id = os.getenv('CUSTOMER_ID', 'FFFFFFFF-EEEE-DDDD-1234-AB1234567890')
+        self.api_key = os.getenv('API_KEY', 'EXAMPLE----TE8sTgg45yusumoN6BYsBVkh+yRJ5czgsnCehZaOYldPJdmFh6NeX8kunZ2zU1YWaUw/0wV6xfw==')
+        self.phone_number_test = "11234567890"
+
+    def test_phoneid_constructor(self):
+
+        client = PhoneIdClient(self.customer_id,
+                            self.api_key)
+
+        self.assertEqual(client.customer_id, self.customer_id)
+        self.assertEqual(client.api_key, self.api_key)
+        
+
+    def test_phoneid_pid_contact(self):
+
+        client = PhoneIdClient(self.customer_id, self.api_key)
+        content_type_expected = 'application/json'
+        status_code_expected = 200
+        
+        payload = {  
+            "addons": {
+                "contact": {}
+            },
+            "phone_number": self.phone_number_test
+        }
+
+        response = client.phoneid(**payload)
+
+        self.assertEqual(response.headers.get('Content-Type'), content_type_expected, "Content-Type args do not match expected")
+        self.assertEqual(response.status_code, status_code_expected, "Status code args do not match expected")
+
+    def test_phoneid_pid(self):
+
+        client = PhoneIdClient(self.customer_id, self.api_key)
+        content_type_expected = 'application/json'
+        status_code_expected = 200
+
+        response = client.phoneid(self.phone_number_test)
+
+        self.assertEqual(response.headers.get('Content-Type'), content_type_expected, "Content-Type args do not match expected")
+        self.assertEqual(response.status_code, status_code_expected, "Status code args do not match expected")

{telesign-2.2.2 → telesign-2.2.4}/tests/test_rest.py

@@ -6,6 +6,7 @@ from unittest import TestCase
 from uuid import UUID
 
 from telesign.rest import RestClient
+from telesign.util import AuthMethod
 
 if sys.version_info < (3, 3):
     from mock import Mock, patch
@@ -104,6 +105,29 @@ class TestRest(TestCase):
 
         self.assertEqual(expected_authorization_header, actual_headers['Authorization'])
 
+    def test_generate_telesign_headers_with_post_basic_authentication(self):
+        method_name = 'POST'
+        date_rfc2616 = 'Wed, 14 Dec 2016 18:20:12 GMT'
+        nonce = 'A1592C6F-E384-4CDB-BC42-C3AB970369E9'
+        resource = '/v1/resource'
+
+        expected_authorization_header =  ('Basic RkZGRkZGRkYtRUVFRS1ERERELTEyMzQtQUIxMjM'
+                                          '0NTY3ODkwOkVYQU1QTEUtLS0tVEU4c1RnZzQ1eXVzdW1vTjZCWXNCVmto'
+                                          'K3lSSjVjemdzbkNlaFphT1lsZFBKZG1GaDZOZVg4a3VuWjJ6VTFZV2FV'
+                                          'dy8wd1Y2eGZ3PT0=')
+
+        actual_headers = RestClient.generate_telesign_headers(self.customer_id,
+                                                              self.api_key,
+                                                              method_name,
+                                                              resource,
+                                                              '',
+                                                              date_rfc2616=date_rfc2616,
+                                                              nonce=nonce,
+                                                              user_agent='unit_test',
+                                                              auth_method=AuthMethod.BASIC.value)
+
+        self.assertEqual(expected_authorization_header, actual_headers['Authorization'])
+
     def test_generate_telesign_headers_default_date_and_nonce(self):
         method_name = 'GET'
         resource = '/v1/resource'
@@ -144,6 +168,28 @@ class TestRest(TestCase):
         self.assertEqual(post_kwargs, expected_post_kwargs,
                          "client.session.post.call_args kwargs do not match expected")
 
+    @patch('telesign.rest.RestClient.generate_telesign_headers', return_value={})
+    def test_post_body(self, mock_generate_telesign_headers):
+        test_host = 'https://test.com'
+        test_resource = '/test/resource'
+        test_params = {'test': '123_\u03ff_test'}
+
+        client = RestClient(self.customer_id, self.api_key, rest_endpoint=test_host)
+        client.session.post = Mock()
+
+        expected_post_args = (u'https://test.com/test/resource',)
+        expected_post_kwargs = {'headers': {}, 'json': test_params, 'timeout': client.timeout}
+
+        client.post(test_resource, body=test_params)
+
+        self.assertEqual(client.session.post.call_count, 1, "client.session.post not called")
+
+        post_args, post_kwargs = client.session.post.call_args
+        self.assertEqual(post_args, expected_post_args,
+                         "client.session.post.call_args args do not match expected")
+        self.assertEqual(post_kwargs, expected_post_kwargs,
+                         "client.session.post.call_args kwargs do not match expected")
+
     @patch('telesign.rest.RestClient.generate_telesign_headers', return_value={})
     def test_get(self, mock_generate_telesign_headers):
         test_host = 'https://test.com'
@@ -209,3 +255,25 @@ class TestRest(TestCase):
                          "client.session.delete.call_args args do not match expected")
         self.assertEqual(delete_kwargs, expected_delete_kwargs,
                          "client.session.delete.call_args kwargs do not match expected")
+
+    @patch('telesign.rest.RestClient.generate_telesign_headers', return_value={})
+    def test_post_basic_auth(self, mock_generate_telesign_headers):
+        test_host = 'https://test.com'
+        test_resource = '/test/resource'
+        test_params = {'test': '123_\u03ff_test'}
+
+        client = RestClient(self.customer_id, self.api_key, rest_endpoint=test_host, auth_method=AuthMethod.BASIC.value)
+        client.session.post = Mock()
+
+        expected_post_args = (u'https://test.com/test/resource',)
+        expected_post_kwargs = {'headers': {}, 'data': 'test=123_%CF%BF_test', 'timeout': client.timeout}
+
+        client.post(test_resource, **test_params)
+
+        self.assertEqual(client.session.post.call_count, 1, "client.session.post not called")
+
+        post_args, post_kwargs = client.session.post.call_args
+        self.assertEqual(post_args, expected_post_args,
+                         "client.session.post.call_args args do not match expected")
+        self.assertEqual(post_kwargs, expected_post_kwargs,
+                         "client.session.post.call_args kwargs do not match expected")

telesign-2.2.2/telesign/phoneid.py

@@ -1,54 +0,0 @@
-from __future__ import unicode_literals
-
-import json
-
-from telesign.rest import RestClient
-
-PHONEID_RESOURCE = "/v1/phoneid/{phone_number}"
-
-
-class PhoneIdClient(RestClient):
-    """
-    A set of APIs that deliver deep phone number data attributes that help optimize the end user
-    verification process and evaluate risk.
-    """
-
-    def __init__(self, customer_id, api_key, **kwargs):
-        super(PhoneIdClient, self).__init__(customer_id, api_key, **kwargs)
-
-    def phoneid(self, phone_number, **params):
-        """
-        The PhoneID API provides a cleansed phone number, phone type, and telecom carrier information to determine the
-        best communication method - SMS or voice.
-
-        See https://developer.telesign.com/docs/phoneid-api for detailed API documentation.
-        """
-        return self.post(PHONEID_RESOURCE.format(phone_number=phone_number),
-                         **params)
-
-    def _execute(self, method_function, method_name, resource, **params):
-        resource_uri = "{api_host}{resource}".format(api_host=self.api_host, resource=resource)
-
-        json_fields = json.dumps(params)
-
-        content_type = "application/json" if method_name in ("POST", "PUT") else ""
-
-        headers = self.generate_telesign_headers(self.customer_id,
-                                                 self.api_key,
-                                                 method_name,
-                                                 resource,
-                                                 json_fields,
-                                                 user_agent=self.user_agent,
-                                                 content_type=content_type)
-
-        if method_name in ['POST', 'PUT']:
-            payload = {'data': json_fields}
-        else:
-            payload = {'params': json_fields}
-
-        response = self.Response(method_function(resource_uri,
-                                                 headers=headers,
-                                                 timeout=self.timeout,
-                                                 **payload))
-
-        return response