telesign 2.2.3__py2.py3-none-any.whl

telesign/__init__.py

@@ -0,0 +1,12 @@
+from pkg_resources import get_distribution
+
+__import__('pkg_resources').declare_namespace(__name__)
+
+__version__ = get_distribution("telesign").version
+__author__ = "TeleSign"
+__copyright__ = "Copyright 2017, TeleSign Corp."
+__credits__ = ["TeleSign"]
+__license__ = "MIT"
+__maintainer__ = "TeleSign Corp."
+__email__ = "support@telesign.com"
+__status__ = "Production"

telesign/appverify.py

@@ -0,0 +1,28 @@
+from __future__ import unicode_literals
+
+from telesign.rest import RestClient
+
+APPVERIFY_STATUS_RESOURCE = "/v1/mobile/verification/status/{external_id}"
+
+
+class AppVerifyClient(RestClient):
+    """
+    App Verify is a secure, lightweight SDK that integrates a frictionless user verification process into existing
+    native mobile applications.
+    """
+
+    def __init__(self, customer_id, api_key, **kwargs):
+        super(AppVerifyClient, self).__init__(customer_id, api_key, **kwargs)
+
+    def status(self, external_id, **params):
+        """
+        Retrieves the verification result for an App Verify transaction by external_id. To ensure a secure verification
+        flow you must check the status using TeleSign's servers on your backend. Do not rely on the SDK alone to
+        indicate a successful verification.
+
+        See https://developer.telesign.com/docs/app-verify-android-sdk-self#section-get-status-service or
+        https://developer.telesign.com/docs/app-verify-ios-sdk-self#section-get-status-service for detailed
+        API documentation.
+        """
+        return self.get(APPVERIFY_STATUS_RESOURCE.format(external_id=external_id),
+                        **params)

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/messaging.py

@@ -0,0 +1,37 @@
+from __future__ import unicode_literals
+
+from telesign.rest import RestClient
+
+MESSAGING_RESOURCE = "/v1/messaging"
+MESSAGING_STATUS_RESOURCE = "/v1/messaging/{reference_id}"
+
+
+class MessagingClient(RestClient):
+    """
+    TeleSign's Messaging API allows you to easily send SMS messages. You can send alerts, reminders, and notifications,
+    or you can send verification messages containing one-time passcodes (OTP).
+    """
+
+    def __init__(self, customer_id, api_key, **kwargs):
+        super(MessagingClient, self).__init__(customer_id, api_key, **kwargs)
+
+    def message(self, phone_number, message, message_type, **params):
+        """
+        Send a message to the target phone_number.
+
+        See https://developer.telesign.com/docs/messaging-api for detailed API documentation.
+        """
+        return self.post(MESSAGING_RESOURCE,
+                         phone_number=phone_number,
+                         message=message,
+                         message_type=message_type,
+                         **params)
+
+    def status(self, reference_id, **params):
+        """
+        Retrieves the current status of the message.
+
+        See https://developer.telesign.com/docs/messaging-api for detailed API documentation.
+        """
+        return self.get(MESSAGING_STATUS_RESOURCE.format(reference_id=reference_id),
+                        **params)

telesign/phoneid.py

@@ -0,0 +1,54 @@
+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

telesign/rest.py

@@ -0,0 +1,253 @@
+from __future__ import unicode_literals
+
+import hmac
+import uuid
+from base64 import b64encode, b64decode
+from email.utils import formatdate
+from hashlib import sha256
+from platform import python_version
+
+import requests
+
+import telesign
+from telesign.util import AuthMethod
+
+
+class RestClient(requests.models.RequestEncodingMixin):
+    """
+    The TeleSign RestClient is a generic HTTP REST client that can be extended to make requests against any of
+    TeleSign's REST API endpoints.
+
+    RequestEncodingMixin offers the function _encode_params for url encoding the body for use in string_to_sign outside
+    of a regular HTTP request.
+
+    See https://developer.telesign.com for detailed API documentation.
+    """
+    user_agent = "TeleSignSDK/python-{sdk_version} Python/{python_version} Requests/{requests_version}".format(
+        sdk_version=telesign.__version__,
+        python_version=python_version(),
+        requests_version=requests.__version__)
+
+    class Response(object):
+        """
+        A simple HTTP Response object to abstract the underlying Requests library response.
+
+        :param requests_response: A Requests response object.
+        """
+
+        def __init__(self, requests_response):
+            self.status_code = requests_response.status_code
+            self.headers = requests_response.headers
+            self.body = requests_response.text
+            self.ok = requests_response.ok
+
+            try:
+                self.json = requests_response.json()
+            except (Exception, ValueError):
+                self.json = None
+
+    def __init__(self,
+                 customer_id,
+                 api_key,
+                 rest_endpoint='https://rest-api.telesign.com',
+                 proxies=None,
+                 timeout=10,
+                 auth_method=None):
+        """
+        TeleSign RestClient useful for making generic RESTful requests against our API.
+
+        :param customer_id: Your customer_id string associated with your account.
+        :param api_key: Your api_key string associated with your account.
+        :param rest_endpoint: (optional) Override the default rest_endpoint to target another endpoint string.
+        :param proxies: (optional) Dictionary mapping protocol or protocol and hostname to the URL of the proxy.
+        :param timeout: (optional) How long to wait for the server to send data before giving up, as a float,
+                        or as a (connect timeout, read timeout) tuple
+        """
+        self.customer_id = customer_id
+        self.api_key = api_key
+
+        self.api_host = rest_endpoint
+
+        self.session = requests.Session()
+
+        self.session.proxies = proxies if proxies else {}
+
+        self.timeout = timeout
+
+        self.auth_method = auth_method
+
+    @staticmethod
+    def generate_telesign_headers(customer_id,
+                                  api_key,
+                                  method_name,
+                                  resource,
+                                  url_encoded_fields,
+                                  date_rfc2616=None,
+                                  nonce=None,
+                                  user_agent=None,
+                                  content_type=None,
+                                  auth_method=None):
+        """
+        Generates the TeleSign REST API headers used to authenticate requests.
+
+        Creates the canonicalized string_to_sign and generates the HMAC signature. This is used to authenticate requests
+        against the TeleSign REST API.
+
+        See https://developer.telesign.com/docs/authentication for detailed API documentation.
+
+        :param customer_id: Your account customer_id.
+        :param api_key: Your account api_key.
+        :param method_name: The HTTP method name of the request as a upper case string, should be one of 'POST', 'GET',
+            'PUT' or 'DELETE'.
+        :param resource: The partial resource URI to perform the request against, as a string.
+        :param url_encoded_fields: HTTP body parameters to perform the HTTP request with, must be a urlencoded string.
+        :param date_rfc2616: The date and time of the request formatted in rfc 2616, as a string.
+        :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:
+            date_rfc2616 = formatdate(usegmt=True)
+
+        if nonce is None:
+            nonce = str(uuid.uuid4())
+        
+        if not content_type:
+            content_type = "application/x-www-form-urlencoded" if method_name in ("POST", "PUT") else ""
+
+        # Default auth_method is Digest if not explicitly specified
+        if auth_method == AuthMethod.BASIC.value:
+            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.value,
+                                                            b64val=b64val.decode())
+        else:
+            auth_method = AuthMethod.HMAC_SHA256.value
+
+            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{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-nonce:{nonce}".format(nonce=nonce))
+
+            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 = "".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")
+
+            authorization = "TSA {customer_id}:{signature}".format(
+                customer_id=customer_id,
+                signature=signature)
+
+        headers = {
+            "Authorization": authorization,
+            "Date": date_rfc2616,
+            "Content-Type": content_type,
+            "x-ts-auth-method": auth_method,
+            "x-ts-nonce": nonce
+        }
+
+        if user_agent:
+            headers['User-Agent'] = user_agent
+
+        return headers
+
+    def post(self, resource, body=None, **query_params):
+        """
+        Generic TeleSign REST API POST handler.
+
+        :param resource: The partial resource URI to perform the request against, as a string.
+        :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, body, **query_params)
+
+    def get(self, resource, body=None, **query_params):
+        """
+        Generic TeleSign REST API GET handler.
+
+        :param resource: The partial resource URI to perform the request against, as a string.
+        :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, body, **query_params)
+
+    def put(self, resource, body=None, **query_params):
+        """
+        Generic TeleSign REST API PUT handler.
+
+        :param resource: The partial resource URI to perform the request against, as a string.
+        :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, body, **query_params)
+
+    def delete(self, resource, body=None, **query_params):
+        """
+        Generic TeleSign REST API DELETE handler.
+
+        :param resource: The partial resource URI to perform the request against, as a string.
+        :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, body, **query_params)
+
+    def _execute(self, method_function, method_name, resource, body=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 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(query_params)
+        if body:
+            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,
+                                                       content_type=content_type,
+                                                       auth_method=self.auth_method)
+
+        if method_name in ['POST', 'PUT']:
+            payload = {}
+            if body:
+                payload['json'] = body
+            if query_params:
+                payload['data'] = url_encoded_fields
+        else:
+            payload = {'params': url_encoded_fields}
+
+        response = self.Response(method_function(resource_uri,
+                                                 headers=headers,
+                                                 timeout=self.timeout,
+                                                 **payload))
+
+        return response

telesign/score.py

@@ -0,0 +1,25 @@
+from __future__ import unicode_literals
+
+from telesign.rest import RestClient
+
+SCORE_RESOURCE = "/v1/score/{phone_number}"
+
+
+class ScoreClient(RestClient):
+    """
+    Score provides risk information about a specified phone number.
+    """
+
+    def __init__(self, customer_id, api_key, **kwargs):
+        super(ScoreClient, self).__init__(customer_id, api_key, **kwargs)
+
+    def score(self, phone_number, account_lifecycle_event, **params):
+        """
+        Score is an API that delivers reputation scoring based on phone number intelligence, traffic patterns, machine
+        learning, and a global data consortium.
+
+        See https://developer.telesign.com/docs/score-api for detailed API documentation.
+        """
+        return self.post(SCORE_RESOURCE.format(phone_number=phone_number),
+                         account_lifecycle_event=account_lifecycle_event,
+                         **params)

telesign/util.py

@@ -0,0 +1,48 @@
+from __future__ import unicode_literals
+
+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):
+    """
+    Helper function to format a timezone unaware/UTC datetime in rfc3339 utc timestamp the easy way.
+    """
+    return "{date_string}Z".format(date_string=a_datetime.replace(microsecond=0).isoformat())
+
+
+def random_with_n_digits(n):
+    """
+    Helper function to generate a random number n digits in length using a system random.
+    """
+    return "".join(SystemRandom().choice('123456789') for _ in range(n))
+
+
+def verify_telesign_callback_signature(api_key, signature, json_str):
+    """
+    Verify that a callback was made by TeleSign and was not sent by a malicious client by verifying the signature.
+
+    :param api_key: the TeleSign API api_key associated with your account.
+    :param signature: the TeleSign Authorization header value supplied in the callback, as a string.
+    :param json_str: the POST body text, that is, the JSON string sent by TeleSign describing the transaction status.
+    """
+    your_signature = b64encode(HMAC(b64decode(api_key), json_str.encode("utf-8"), sha256).digest()).decode("utf-8")
+
+    if len(signature) != len(your_signature):
+        return False
+
+    # avoid timing attack with constant time equality check
+    signatures_equal = True
+    for x, y in zip(signature, your_signature):
+        if not x == y:
+            signatures_equal = False
+
+    return signatures_equal
+
+
+class AuthMethod(Enum):
+    BASIC = "Basic"
+    HMAC_SHA256 = "HMAC-SHA256"

telesign/voice.py

@@ -0,0 +1,37 @@
+from __future__ import unicode_literals
+
+from telesign.rest import RestClient
+
+VOICE_RESOURCE = "/v1/voice"
+VOICE_STATUS_RESOURCE = "/v1/voice/{reference_id}"
+
+
+class VoiceClient(RestClient):
+    """
+    TeleSign's Voice API allows you to easily send voice messages. You can send alerts, reminders, and notifications,
+    or you can send verification messages containing time-based, one-time passcodes (TOTP).
+    """
+
+    def __init__(self, customer_id, api_key, **kwargs):
+        super(VoiceClient, self).__init__(customer_id, api_key, **kwargs)
+
+    def call(self, phone_number, message, message_type, **params):
+        """
+        Send a voice call to the target phone_number.
+
+        See https://developer.telesign.com/docs/voice-api for detailed API documentation.
+        """
+        return self.post(VOICE_RESOURCE,
+                         phone_number=phone_number,
+                         message=message,
+                         message_type=message_type,
+                         **params)
+
+    def status(self, reference_id, **params):
+        """
+        Retrieves the current status of the voice call.
+
+        See https://developer.telesign.com/docs/voice-api for detailed API documentation.
+        """
+        return self.get(VOICE_STATUS_RESOURCE.format(reference_id=reference_id),
+                        **params)

telesign-2.2.3.dist-info/LICENSE.txt

@@ -0,0 +1,19 @@
+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:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

telesign-2.2.3.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.1
+Name: telesign
+Version: 2.2.3
+Summary: TeleSign SDK
+Home-page: https://github.com/telesign/python_telesign
+Author: TeleSign Corp.
+Author-email: support@telesign.com
+License: MIT
+Keywords: telesign,sms,voice,mobile,authentication,identity,messaging
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+License-File: LICENSE.txt
+Requires-Dist: requests
+
+.. image:: https://raw.github.com/TeleSign/python_telesign/master/python_banner.jpg
+       :target: https://standard.telesign.com
+
+.. image:: https://img.shields.io/travis/TeleSign/python_telesign.svg
+       :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
+
+.. image:: https://img.shields.io/pypi/v/telesign.svg
+       :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
+
+===================
+TeleSign Python SDK
+===================
+
+TeleSign is a communications platform as a service (CPaaS) company, founded on security. Since 2005, TeleSign has
+been a trusted partner to the world’s leading websites and mobile applications, helping secure billions of end-user
+accounts. Today, TeleSign’s data-driven, cloud communications platform is changing the way businesses engage with
+customers and prevent fraud.
+
+For more information about TeleSign, visit our `website <http://www.TeleSign.com>`_.
+
+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 Standard Documentation <https://standard.telesign.com/>`_.
+
+Installation
+------------
+
+To install the TeleSign Python SDK:
+
+.. code-block:: bash
+
+    $ pip install telesign
+
+Python **2.7+** is required for the TeleSign Python SDK.
+
+Authentication
+--------------
+
+You will need a Customer ID and API Key in order to use TeleSign’s API. If you already have an account you can retrieve
+them from your account dashboard within the `Portal <https://portal.telesign.com/login>`_. If you have not signed up
+yet, sign up `here <https://portal.telesign.com/signup>`_.
+
+Dependencies
+------------
+
+We make use of popular, feature-rich and well-tested open-source libraries to perform the underlying functionality of
+the SDK. These dependencies are managed by the community accepted package manager. If you are unable to add these
+additional third party dependencies to your project we have ensured that the SDK code is easy to read and can serve as
+sample code. We have also made sure that more complicated functions such as generate_telesign_headers can be easily
+extracted from the SDK and used 'as is' in your project.
+
+Python Code Example: Messaging
+------------------------------
+
+Here is a basic code example with the JSON response.
+
+.. code-block:: python
+
+    from __future__ import print_function
+    from telesign.messaging import MessagingClient
+
+    customer_id = "FFFFFFFF-EEEE-DDDD-1234-AB1234567890"
+    api_key = "EXAMPLE----TE8sTgg45yusumoN6BYsBVkh+yRJ5czgsnCehZaOYldPJdmFh6NeX8kunZ2zU1YWaUw/0wV6xfw=="
+
+    phone_number = "phone_number"
+    message = "You're scheduled for a dentist appointment at 2:30PM."
+    message_type = "ARN"
+
+    messaging_client = MessagingClient(customer_id, api_key)
+    response = messaging_client.message(phone_number, message, message_type)
+
+    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 Standard Documentation <https://standard.telesign.com/>`_.

telesign-2.2.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+telesign/__init__.py,sha256=D8kANX0FKxBD7-a7xQ21xPz3ojM2WAOK8lThGLtDZuE,367
+telesign/appverify.py,sha256=wBeaeUxGmYcZkrbxkkXlG3-0oZr5sVvegzVpdvaoO2A,1195
+telesign/intelligence.py,sha256=t-xwlgxkXw1OMupF5K4_UKWeTArOr9XPvddmqgZftPI,1452
+telesign/messaging.py,sha256=v7l-eKUPqz7Nrwka0YNPMkC2TaoFUvQm3yp_djuTPu0,1367
+telesign/phoneid.py,sha256=czEVgjDmbbWgDGanqclNhlmAYkD1jLYhEOXQs7M9F88,2111
+telesign/rest.py,sha256=BtiRi0dc5h4OiWapdsfSBvLLwXB5swrwiACT7R-UAkc,11058
+telesign/score.py,sha256=Kceu6IrirN9SsuT1geEWs0QHAn6H9ZNFyIDVHcBJdwg,908
+telesign/util.py,sha256=stDxpL5ZQeGskE_OSGP04UFHs3ZP2ACaRpW1WyQGMHg,1624
+telesign/voice.py,sha256=DJaWyQpun-T7LfNjpxpsUjupiv2ShW1jqoFQA-CE2-Y,1341
+telesign-2.2.3.dist-info/LICENSE.txt,sha256=a--xZ4PCKUL5rpct8RrUC6ODU_8ZKIU51kJPfsA4HUs,1058
+telesign-2.2.3.dist-info/METADATA,sha256=0XcO1v2ZEwFJt2yzWdUH_L6tc7zAXLJeRxZQ3WieMF0,4545
+telesign-2.2.3.dist-info/WHEEL,sha256=AHX6tWk3qWuce7vKLrj7lnulVHEdWoltgauo8bgCXgU,109
+telesign-2.2.3.dist-info/top_level.txt,sha256=6LG7Jcr1jnpVhOWaIShoTdwYJn0QCfPhfudyVJNz1qg,9
+telesign-2.2.3.dist-info/RECORD,,

telesign-2.2.3.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

telesign-2.2.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+telesign