incognia-python 2.2.0__tar.gz → 3.0.0__tar.gz

{incognia_python-2.2.0 → incognia_python-3.0.0}/.github/workflows/continuous.yaml

@@ -52,15 +52,15 @@ jobs:
       - name: Publish Python distribution to Test PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
-          repository_url: https://test.pypi.org/legacy/
+          repository-url: https://test.pypi.org/legacy/
           password: ${{ secrets.TEST_PYPI_API_TOKEN }}
-          skip_existing: true
-          print_hash: true
+          skip-existing: true
+          print-hash: true
           verbose: true
       - name: Publish Python distribution to PyPI
         if: startsWith(github.ref, 'refs/tags/v')
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           password: ${{ secrets.PYPI_API_TOKEN }}
-          print_hash: true
+          print-hash: true
           verbose: true

{incognia_python-2.2.0 → incognia_python-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: incognia-python
-Version: 2.2.0
+Version: 3.0.0
 Summary: Python lightweight client library for Incognia APIs
 Home-page: https://github.com/inloco/incognia-python
 Author: Incognia
@@ -49,7 +49,7 @@ Authentication is done transparently, so you don't need to worry about it.
 
 #### Registering New Signup
 
-This method registers a new signup for the given installation and a structured address, an address
+This method registers a new signup for the given request token and a structured address, an address
 line or coordinates, returning a `dict`, containing the risk assessment and supporting evidence:
 
 ```python3
@@ -72,30 +72,30 @@ structured_address: StructuredAddress = {
     'complements': 'Floor 2',
     'postal_code': '10001'
 }
-assessment: dict = api.register_new_signup('installation-id', structured_address=structured_address)
+assessment: dict = api.register_new_signup('request-token', structured_address=structured_address)
 
 # with address line:
 address_line: str = '350 Fifth Avenue, Manhattan, New York 10118'
-assessment: dict = api.register_new_signup('installation-id', address_line=address_line)
+assessment: dict = api.register_new_signup('request-token', address_line=address_line)
 
 # with coordinates, a dict:
 coordinates: Coordinates = {
     'lat': 40.74836007062138,
     'lng': -73.98509720487937
 }
-assessment: dict = api.register_new_signup('installation-id', address_coordinates=coordinates)
+assessment: dict = api.register_new_signup('request-token', address_coordinates=coordinates)
 
 # with external_id:
 external_id: str = 'external-id'
-assessment: dict = api.register_new_signup('installation-id', external_id=external_id)
+assessment: dict = api.register_new_signup('request-token', external_id=external_id)
 
 # with policy_id:
 policy_id: str = 'policy-id'
-assessment: dict = api.register_new_signup('installation-id', policy_id=policy_id)
+assessment: dict = api.register_new_signup('request-token', policy_id=policy_id)
 
 # with account_id:
 account_id: str = 'account-id'
-assessment: dict = api.register_new_signup('installation-id', account_id=account_id)
+assessment: dict = api.register_new_signup('request-token', account_id=account_id)
 
 ```
 
@@ -113,13 +113,13 @@ api = IncogniaAPI('client-id', 'client-secret')
 
 api.register_feedback(FeedbackEvents.ACCOUNT_TAKEOVER,
                       occurred_at=dt.datetime(2024, 7, 22, 15, 20, 0, tzinfo=dt.timezone.utc),
-                      installation_id='installation-id',
+                      request_token='request-token',
                       account_id='account-id')
 ```
 
 #### Registering Payment
 
-This method registers a new payment for the given installation and account, returning a `dict`,
+This method registers a new payment for the given request token and account, returning a `dict`,
 containing the risk assessment and supporting evidence.
 
 ```python3
@@ -180,7 +180,7 @@ payment_methods: List[PaymentMethod] = [
 
 policy_id: str = 'policy-id'
 
-assessment: dict = api.register_payment('installation-id',
+assessment: dict = api.register_payment('request-token',
                                         'account-id',
                                         'external-id',
                                         addresses=addresses,
@@ -191,7 +191,7 @@ assessment: dict = api.register_payment('installation-id',
 
 #### Registering Login
 
-This method registers a new login for the given installation and account, returning a `dict`,
+This method registers a new login for the given request token and account, returning a `dict`,
 containing the risk assessment and supporting evidence.
 
 ```python3
@@ -201,7 +201,7 @@ api = IncogniaAPI('client-id', 'client-secret')
 
 policy_id: str = 'policy-id'
 
-assessment: dict = api.register_login('installation-id', 
+assessment: dict = api.register_login('request-token', 
                                       'account-id', 
                                       'external-id', 
                                       policy_id='policy_id')

{incognia_python-2.2.0 → incognia_python-3.0.0}/README.md

@@ -33,7 +33,7 @@ Authentication is done transparently, so you don't need to worry about it.
 
 #### Registering New Signup
 
-This method registers a new signup for the given installation and a structured address, an address
+This method registers a new signup for the given request token and a structured address, an address
 line or coordinates, returning a `dict`, containing the risk assessment and supporting evidence:
 
 ```python3
@@ -56,30 +56,30 @@ structured_address: StructuredAddress = {
     'complements': 'Floor 2',
     'postal_code': '10001'
 }
-assessment: dict = api.register_new_signup('installation-id', structured_address=structured_address)
+assessment: dict = api.register_new_signup('request-token', structured_address=structured_address)
 
 # with address line:
 address_line: str = '350 Fifth Avenue, Manhattan, New York 10118'
-assessment: dict = api.register_new_signup('installation-id', address_line=address_line)
+assessment: dict = api.register_new_signup('request-token', address_line=address_line)
 
 # with coordinates, a dict:
 coordinates: Coordinates = {
     'lat': 40.74836007062138,
     'lng': -73.98509720487937
 }
-assessment: dict = api.register_new_signup('installation-id', address_coordinates=coordinates)
+assessment: dict = api.register_new_signup('request-token', address_coordinates=coordinates)
 
 # with external_id:
 external_id: str = 'external-id'
-assessment: dict = api.register_new_signup('installation-id', external_id=external_id)
+assessment: dict = api.register_new_signup('request-token', external_id=external_id)
 
 # with policy_id:
 policy_id: str = 'policy-id'
-assessment: dict = api.register_new_signup('installation-id', policy_id=policy_id)
+assessment: dict = api.register_new_signup('request-token', policy_id=policy_id)
 
 # with account_id:
 account_id: str = 'account-id'
-assessment: dict = api.register_new_signup('installation-id', account_id=account_id)
+assessment: dict = api.register_new_signup('request-token', account_id=account_id)
 
 ```
 
@@ -97,13 +97,13 @@ api = IncogniaAPI('client-id', 'client-secret')
 
 api.register_feedback(FeedbackEvents.ACCOUNT_TAKEOVER,
                       occurred_at=dt.datetime(2024, 7, 22, 15, 20, 0, tzinfo=dt.timezone.utc),
-                      installation_id='installation-id',
+                      request_token='request-token',
                       account_id='account-id')
 ```
 
 #### Registering Payment
 
-This method registers a new payment for the given installation and account, returning a `dict`,
+This method registers a new payment for the given request token and account, returning a `dict`,
 containing the risk assessment and supporting evidence.
 
 ```python3
@@ -164,7 +164,7 @@ payment_methods: List[PaymentMethod] = [
 
 policy_id: str = 'policy-id'
 
-assessment: dict = api.register_payment('installation-id',
+assessment: dict = api.register_payment('request-token',
                                         'account-id',
                                         'external-id',
                                         addresses=addresses,
@@ -175,7 +175,7 @@ assessment: dict = api.register_payment('installation-id',
 
 #### Registering Login
 
-This method registers a new login for the given installation and account, returning a `dict`,
+This method registers a new login for the given request token and account, returning a `dict`,
 containing the risk assessment and supporting evidence.
 
 ```python3
@@ -185,7 +185,7 @@ api = IncogniaAPI('client-id', 'client-secret')
 
 policy_id: str = 'policy-id'
 
-assessment: dict = api.register_login('installation-id', 
+assessment: dict = api.register_login('request-token', 
                                       'account-id', 
                                       'external-id', 
                                       policy_id='policy_id')

{incognia_python-2.2.0 → incognia_python-3.0.0}/incognia/api.py

@@ -1,16 +1,17 @@
 import datetime as dt
 from typing import Optional, List
 
-from .datetime_util import total_milliseconds_since_epoch, has_timezone
+from .datetime_util import has_timezone
 from .endpoints import Endpoints
 from .exceptions import IncogniaHTTPError, IncogniaError
 from .json_util import encode
 from .models import Coordinates, StructuredAddress, TransactionAddress, PaymentValue, PaymentMethod
+from .singleton import Singleton
 from .token_manager import TokenManager
 from .base_request import BaseRequest, JSON_CONTENT_HEADER
 
 
-class IncogniaAPI:
+class IncogniaAPI(metaclass=Singleton):
     def __init__(self, client_id: str, client_secret: str):
         self.__token_manager = TokenManager(client_id, client_secret)
         self.__request = BaseRequest()
@@ -20,29 +21,27 @@ class IncogniaAPI:
         return {'Authorization': f'{token_type} {access_token}'}
 
     def register_new_signup(self,
-                            installation_id: str,
+                            request_token: Optional[str],
                             address_line: Optional[str] = None,
                             structured_address: Optional[StructuredAddress] = None,
                             address_coordinates: Optional[Coordinates] = None,
                             external_id: Optional[str] = None,
                             policy_id: Optional[str] = None,
-                            account_id: Optional[str] = None,
-                            request_token: Optional[str] = None) -> dict:
-        if not installation_id:
-            raise IncogniaError('installation_id is required.')
+                            account_id: Optional[str] = None) -> dict:
+        if not request_token:
+            raise IncogniaError('request_token is required.')
 
         try:
             headers = self.__get_authorization_header()
             headers.update(JSON_CONTENT_HEADER)
             body = {
-                'installation_id': installation_id,
+                'request_token': request_token,
                 'address_line': address_line,
                 'structured_address': structured_address,
                 'address_coordinates': address_coordinates,
                 'external_id': external_id,
                 'policy_id': policy_id,
-                'account_id': account_id,
-                'request_token': request_token
+                'account_id': account_id
             }
             data = encode(body)
             return self.__request.post(Endpoints.SIGNUPS, headers=headers, data=data)
@@ -52,21 +51,17 @@ class IncogniaAPI:
 
     def register_feedback(self,
                           event: str,
-                          timestamp: dt.datetime = None,
                           external_id: Optional[str] = None,
                           login_id: Optional[str] = None,
                           payment_id: Optional[str] = None,
                           signup_id: Optional[str] = None,
                           account_id: Optional[str] = None,
                           installation_id: Optional[str] = None,
-                          session_token: Optional[str] = None,
                           request_token: Optional[str] = None,
                           occurred_at: dt.datetime = None,
                           expires_at: dt.datetime = None) -> None:
         if not event:
             raise IncogniaError('event is required.')
-        if timestamp is not None and not has_timezone(timestamp):
-            raise IncogniaError('timestamp must have timezone')
         if occurred_at is not None and not has_timezone(occurred_at):
             raise IncogniaError('occurred_at must have timezone')
         if expires_at is not None and not has_timezone(expires_at):
@@ -83,11 +78,8 @@ class IncogniaAPI:
                 'signup_id': signup_id,
                 'account_id': account_id,
                 'installation_id': installation_id,
-                'session_token': session_token,
                 'request_token': request_token
             }
-            if timestamp is not None:
-                body['timestamp'] = total_milliseconds_since_epoch(timestamp)
             if occurred_at is not None:
                 body['occurred_at'] = occurred_at.isoformat()
             if expires_at is not None:
@@ -99,17 +91,16 @@ class IncogniaAPI:
             raise IncogniaHTTPError(e) from None
 
     def register_payment(self,
-                         installation_id: str,
+                         request_token: str,
                          account_id: str,
                          external_id: Optional[str] = None,
                          addresses: Optional[List[TransactionAddress]] = None,
                          payment_value: Optional[PaymentValue] = None,
                          payment_methods: Optional[List[PaymentMethod]] = None,
                          evaluate: Optional[bool] = None,
-                         policy_id: Optional[str] = None,
-                         request_token: Optional[str] = None) -> dict:
-        if not installation_id:
-            raise IncogniaError('installation_id is required.')
+                         policy_id: Optional[str] = None) -> dict:
+        if not request_token:
+            raise IncogniaError('request_token is required.')
         if not account_id:
             raise IncogniaError('account_id is required.')
 
@@ -119,14 +110,13 @@ class IncogniaAPI:
             params = None if evaluate is None else {'eval': evaluate}
             body = {
                 'type': 'payment',
-                'installation_id': installation_id,
+                'request_token': request_token,
                 'account_id': account_id,
                 'external_id': external_id,
                 'addresses': addresses,
                 'payment_value': payment_value,
                 'payment_methods': payment_methods,
-                'policy_id': policy_id,
-                'request_token': request_token
+                'policy_id': policy_id
             }
             data = encode(body)
             return self.__request.post(Endpoints.TRANSACTIONS, headers=headers, params=params,
@@ -136,14 +126,13 @@ class IncogniaAPI:
             raise IncogniaHTTPError(e) from None
 
     def register_login(self,
-                       installation_id: str,
+                       request_token: str,
                        account_id: str,
                        external_id: Optional[str] = None,
                        evaluate: Optional[bool] = None,
-                       policy_id: Optional[str] = None,
-                       request_token: Optional[str] = None) -> dict:
-        if not installation_id:
-            raise IncogniaError('installation_id is required.')
+                       policy_id: Optional[str] = None) -> dict:
+        if not request_token:
+            raise IncogniaError('request_token is required.')
         if not account_id:
             raise IncogniaError('account_id is required.')
 
@@ -153,11 +142,10 @@ class IncogniaAPI:
             params = None if evaluate is None else {'eval': evaluate}
             body = {
                 'type': 'login',
-                'installation_id': installation_id,
+                'request_token': request_token,
                 'account_id': account_id,
                 'external_id': external_id,
-                'policy_id': policy_id,
-                'request_token': request_token
+                'policy_id': policy_id
             }
             data = encode(body)
             return self.__request.post(Endpoints.TRANSACTIONS, headers=headers, params=params,
@@ -167,14 +155,13 @@ class IncogniaAPI:
             raise IncogniaHTTPError(e) from None
 
     def register_web_login(self,
-                           session_token: str,
+                           request_token: str,
                            account_id: str,
                            external_id: Optional[str] = None,
                            evaluate: Optional[bool] = None,
-                           policy_id: Optional[str] = None,
-                           request_token: Optional[str] = None) -> dict:
-        if not session_token:
-            raise IncogniaError('session_token is required.')
+                           policy_id: Optional[str] = None) -> dict:
+        if not request_token:
+            raise IncogniaError('request_token is required.')
         if not account_id:
             raise IncogniaError('account_id is required.')
 
@@ -184,11 +171,10 @@ class IncogniaAPI:
             params = None if evaluate is None else {'eval': evaluate}
             body = {
                 'type': 'login',
-                'session_token': session_token,
+                'request_token': request_token,
                 'account_id': account_id,
                 'external_id': external_id,
-                'policy_id': policy_id,
-                'request_token': request_token
+                'policy_id': policy_id
             }
             data = encode(body)
             return self.__request.post(Endpoints.TRANSACTIONS, headers=headers, params=params,

incognia_python-3.0.0/incognia/datetime_util.py

@@ -0,0 +1,5 @@
+import datetime as dt
+
+
+def has_timezone(d: dt.datetime) -> bool:
+    return d.tzinfo is not None and d.tzinfo.utcoffset(d) is not None

{incognia_python-2.2.0 → incognia_python-3.0.0}/incognia/feedback_events.py

@@ -15,15 +15,18 @@ class FeedbackEvents:
     PAYMENT_DECLINED_BY_BUSINESS: Final[str] = 'payment_declined_by_business'
     PAYMENT_DECLINED_BY_ACQUIRER: Final[str] = 'payment_declined_by_acquirer'
     LOGIN_ACCEPTED: Final[str] = 'login_accepted'
+    LOGIN_ACCEPTED_BY_DEVICE_VERIFICATION: Final[str] = 'login_accepted_by_device_verification'
+    LOGIN_ACCEPTED_BY_FACIAL_BIOMETRICS: Final[str] = 'login_accepted_by_facial_biometrics'
+    LOGIN_ACCEPTED_BY_MANUAL_REVIEW: Final[str] = 'login_accepted_by_manual_review'
     LOGIN_DECLINED: Final[str] = 'login_declined'
+    ACCOUNT_ALLOWED: Final[str] = 'account_allowed'
+    LOGIN_DECLINED_BY_FACIAL_BIOMETRICS: Final[str] = 'login_declined_by_facial_biometrics'
+    LOGIN_DECLINED_BY_MANUAL_REVIEW: Final[str] = 'login_declined_by_manual_review'
+    DEVICE_ALLOWED: Final[str] = 'device_allowed'
     VERIFIED: Final[str] = 'verified'
     IDENTITY_FRAUD: Final[str] = 'identity_fraud'
     ACCOUNT_TAKEOVER: Final[str] = 'account_takeover'
     CHARGEBACK_NOTIFICATION: Final[str] = 'chargeback_notification'
     CHARGEBACK: Final[str] = 'chargeback'
-    MPOS_FRAUD: Final[str] = 'mpos_fraud'
-    CHALLENGE_PASSED: Final[str] = 'challenge_passed'
-    CHALLENGE_FAILED: Final[str] = 'challenge_failed'
-    PASSWORD_CHANGED_SUCCESSFULLY: Final[str] = 'password_changed_successfully'
-    PASSWORD_CHANGE_FAILED: Final[str] = 'password_change_failed'
     PROMOTION_ABUSE: Final[str] = 'promotion_abuse'
+    RESET: Final[str] = 'reset'

incognia_python-3.0.0/incognia/singleton.py

@@ -0,0 +1,8 @@
+
+class Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]

{incognia_python-2.2.0 → incognia_python-3.0.0}/incognia_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: incognia-python
-Version: 2.2.0
+Version: 3.0.0
 Summary: Python lightweight client library for Incognia APIs
 Home-page: https://github.com/inloco/incognia-python
 Author: Incognia
@@ -49,7 +49,7 @@ Authentication is done transparently, so you don't need to worry about it.
 
 #### Registering New Signup
 
-This method registers a new signup for the given installation and a structured address, an address
+This method registers a new signup for the given request token and a structured address, an address
 line or coordinates, returning a `dict`, containing the risk assessment and supporting evidence:
 
 ```python3
@@ -72,30 +72,30 @@ structured_address: StructuredAddress = {
     'complements': 'Floor 2',
     'postal_code': '10001'
 }
-assessment: dict = api.register_new_signup('installation-id', structured_address=structured_address)
+assessment: dict = api.register_new_signup('request-token', structured_address=structured_address)
 
 # with address line:
 address_line: str = '350 Fifth Avenue, Manhattan, New York 10118'
-assessment: dict = api.register_new_signup('installation-id', address_line=address_line)
+assessment: dict = api.register_new_signup('request-token', address_line=address_line)
 
 # with coordinates, a dict:
 coordinates: Coordinates = {
     'lat': 40.74836007062138,
     'lng': -73.98509720487937
 }
-assessment: dict = api.register_new_signup('installation-id', address_coordinates=coordinates)
+assessment: dict = api.register_new_signup('request-token', address_coordinates=coordinates)
 
 # with external_id:
 external_id: str = 'external-id'
-assessment: dict = api.register_new_signup('installation-id', external_id=external_id)
+assessment: dict = api.register_new_signup('request-token', external_id=external_id)
 
 # with policy_id:
 policy_id: str = 'policy-id'
-assessment: dict = api.register_new_signup('installation-id', policy_id=policy_id)
+assessment: dict = api.register_new_signup('request-token', policy_id=policy_id)
 
 # with account_id:
 account_id: str = 'account-id'
-assessment: dict = api.register_new_signup('installation-id', account_id=account_id)
+assessment: dict = api.register_new_signup('request-token', account_id=account_id)
 
 ```
 
@@ -113,13 +113,13 @@ api = IncogniaAPI('client-id', 'client-secret')
 
 api.register_feedback(FeedbackEvents.ACCOUNT_TAKEOVER,
                       occurred_at=dt.datetime(2024, 7, 22, 15, 20, 0, tzinfo=dt.timezone.utc),
-                      installation_id='installation-id',
+                      request_token='request-token',
                       account_id='account-id')
 ```
 
 #### Registering Payment
 
-This method registers a new payment for the given installation and account, returning a `dict`,
+This method registers a new payment for the given request token and account, returning a `dict`,
 containing the risk assessment and supporting evidence.
 
 ```python3
@@ -180,7 +180,7 @@ payment_methods: List[PaymentMethod] = [
 
 policy_id: str = 'policy-id'
 
-assessment: dict = api.register_payment('installation-id',
+assessment: dict = api.register_payment('request-token',
                                         'account-id',
                                         'external-id',
                                         addresses=addresses,
@@ -191,7 +191,7 @@ assessment: dict = api.register_payment('installation-id',
 
 #### Registering Login
 
-This method registers a new login for the given installation and account, returning a `dict`,
+This method registers a new login for the given request token and account, returning a `dict`,
 containing the risk assessment and supporting evidence.
 
 ```python3
@@ -201,7 +201,7 @@ api = IncogniaAPI('client-id', 'client-secret')
 
 policy_id: str = 'policy-id'
 
-assessment: dict = api.register_login('installation-id', 
+assessment: dict = api.register_login('request-token', 
                                       'account-id', 
                                       'external-id', 
                                       policy_id='policy_id')

{incognia_python-2.2.0 → incognia_python-3.0.0}/incognia_python.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ incognia/exceptions.py
 incognia/feedback_events.py
 incognia/json_util.py
 incognia/models.py
+incognia/singleton.py
 incognia/token_manager.py
 incognia_python.egg-info/PKG-INFO
 incognia_python.egg-info/SOURCES.txt

{incognia_python-2.2.0 → incognia_python-3.0.0}/tests/test_api.py

@@ -15,10 +15,8 @@ class TestIncogniaAPI(TestCase):
     CLIENT_ID: Final[str] = 'ANY_ID'
     CLIENT_SECRET: Final[str] = 'ANY_SECRET'
     INSTALLATION_ID: Final[str] = 'ANY_INSTALLATION_ID'
-    SESSION_TOKEN: Final[str] = 'ANY_SESSION_TOKEN'
     REQUEST_TOKEN: Final[str] = 'ANY_REQUEST_TOKEN'
-    INVALID_INSTALLATION_ID: Final[str] = 'INVALID_INSTALLATION_ID'
-    INVALID_SESSION_TOKEN: Final[str] = 'INVALID_SESSION_TOKEN'
+    INVALID_REQUEST_TOKEN: Final[str] = 'INVALID_REQUEST_TOKEN'
     ACCOUNT_ID: Final[str] = 'ANY_ACCOUNT_ID'
     INVALID_ACCOUNT_ID: Final[str] = 'INVALID_ACCOUNT_ID'
     ADDRESS_LINE: Final[str] = 'ANY_ADDRESS_LINE'
@@ -57,22 +55,23 @@ class TestIncogniaAPI(TestCase):
         'Content-Type': 'application/json'
     }
     REGISTER_SIGNUP_DATA: Final[bytes] = encode({
-        'installation_id': f'{INSTALLATION_ID}'
+        'request_token': f'{REQUEST_TOKEN}'
+    })
+    REGISTER_INVALID_SIGNUP_DATA: Final[bytes] = encode({
+        'request_token': f'{INVALID_REQUEST_TOKEN}'
     })
     FULL_REGISTER_SIGNUP_DATA: Final[bytes] = encode({
-        'installation_id': f'{INSTALLATION_ID}',
+        'request_token': f'{REQUEST_TOKEN}',
         'address_line': f'{ADDRESS_LINE}',
         'structured_address': STRUCTURED_ADDRESS,
         'address_coordinates': ADDRESS_COORDINATES,
         'external_id': f'{EXTERNAL_ID}',
         'policy_id': f'{POLICY_ID}',
-        'account_id': f'{ACCOUNT_ID}',
-        'request_token': f'{REQUEST_TOKEN}'
+        'account_id': f'{ACCOUNT_ID}'
     })
     OK_STATUS_CODE: Final[int] = 200
     CLIENT_ERROR_CODE: Final[int] = 400
     VALID_EVENT_FEEDBACK_TYPE: Final[str] = 'valid_event_feedback_type'
-    INVALID_EVENT_FEEDBACK_TYPE: Final[str] = 'invalid_event_feedback_type'
     TIMESTAMP: Final[dt.datetime] = dt.datetime.now(dt.timezone.utc)
     TIMESTAMP_WITHOUT_TIMEZONE: Final[dt.datetime] = dt.datetime.now()
     LOGIN_ID: Final[str] = 'ANY_LOGIN_ID'
@@ -88,62 +87,59 @@ class TestIncogniaAPI(TestCase):
         'signup_id': f'{SIGNUP_ID}',
         'account_id': f'{ACCOUNT_ID}',
         'installation_id': f'{INSTALLATION_ID}',
-        'session_token': f'{SESSION_TOKEN}',
         'request_token': f'{REQUEST_TOKEN}',
-        'timestamp': int((
-            TIMESTAMP - dt.datetime.fromtimestamp(0, dt.timezone.utc)).total_seconds() * 1000.0),
         'occurred_at': TIMESTAMP.isoformat(),
         'expires_at': TIMESTAMP.isoformat(),
     })
-    REGISTER_INVALID_FEEDBACK_DATA: Final[bytes] = encode({
-        'event': f'{INVALID_EVENT_FEEDBACK_TYPE}'
-    })
     REGISTER_VALID_PAYMENT_DATA: Final[bytes] = encode({
         'type': 'payment',
-        'installation_id': f'{INSTALLATION_ID}',
+        'request_token': f'{REQUEST_TOKEN}',
         'account_id': f'{ACCOUNT_ID}',
         'policy_id': f'{POLICY_ID}',
-        'request_token': f'{REQUEST_TOKEN}',
     })
     REGISTER_INVALID_PAYMENT_DATA: Final[bytes] = encode({
         'type': 'payment',
-        'installation_id': f'{INVALID_INSTALLATION_ID}',
+        'request_token': f'{INVALID_REQUEST_TOKEN}',
         'account_id': f'{INVALID_ACCOUNT_ID}'
     })
     REGISTER_VALID_LOGIN_DATA: Final[bytes] = encode({
         'type': 'login',
-        'installation_id': f'{INSTALLATION_ID}',
+        'request_token': f'{REQUEST_TOKEN}',
         'account_id': f'{ACCOUNT_ID}',
-        'policy_id': f'{POLICY_ID}',
-        'request_token': f'{REQUEST_TOKEN}'
+        'policy_id': f'{POLICY_ID}'
     })
     REGISTER_VALID_WEB_LOGIN_DATA: Final[bytes] = encode({
         'type': 'login',
-        'session_token': f'{SESSION_TOKEN}',
+        'request_token': f'{REQUEST_TOKEN}',
         'account_id': f'{ACCOUNT_ID}',
-        'policy_id': f'{POLICY_ID}',
-        'request_token': f'{REQUEST_TOKEN}'
+        'policy_id': f'{POLICY_ID}'
     })
     REGISTER_INVALID_LOGIN_DATA: Final[bytes] = encode({
         'type': 'login',
-        'installation_id': f'{INVALID_INSTALLATION_ID}',
+        'request_token': f'{INVALID_REQUEST_TOKEN}',
         'account_id': f'{INVALID_ACCOUNT_ID}'
     })
     REGISTER_INVALID_WEB_LOGIN_DATA: Final[bytes] = encode({
         'type': 'login',
-        'session_token': f'{INVALID_SESSION_TOKEN}',
+        'request_token': f'{INVALID_REQUEST_TOKEN}',
         'account_id': f'{INVALID_ACCOUNT_ID}'
     })
     DEFAULT_PARAMS: Final[None] = None
 
+    def test_metaclass_singleton_should_always_return_the_same_instance(self):
+        api1 = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+        api2 = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        self.assertEqual(api1, api2)
+
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
-    def test_register_new_signup_when_installation_id_is_valid_should_return_a_valid_dict(
+    def test_register_new_signup_when_request_token_is_valid_should_return_a_valid_dict(
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
         mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
 
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
-        response = api.register_new_signup(installation_id=self.INSTALLATION_ID)
+        response = api.register_new_signup(request_token=self.REQUEST_TOKEN)
 
         mock_token_manager_get.assert_called()
         mock_base_request_post.assert_called_with(Endpoints.SIGNUPS,
@@ -154,13 +150,12 @@ class TestIncogniaAPI(TestCase):
 
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
-    def test_register_new_signup_when_installation_id_is_valid_should_return_full_valid_dict_(
+    def test_register_new_signup_when_request_token_is_valid_should_return_full_valid_dict_(
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
         mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
 
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
-        response = api.register_new_signup(installation_id=self.INSTALLATION_ID,
-                                           address_line=self.ADDRESS_LINE,
+        response = api.register_new_signup(address_line=self.ADDRESS_LINE,
                                            structured_address=self.STRUCTURED_ADDRESS,
                                            address_coordinates=self.ADDRESS_COORDINATES,
                                            external_id=self.EXTERNAL_ID,
@@ -177,29 +172,29 @@ class TestIncogniaAPI(TestCase):
 
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
-    def test_register_new_signup_when_installation_id_is_invalid_should_raise_an_IncogniaHTTPError(
+    def test_register_new_signup_when_request_token_is_empty_should_raise_an_IncogniaError(
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
-        mock_base_request_post.configure_mock(side_effect=IncogniaHTTPError)
-
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        self.assertRaises(IncogniaHTTPError, api.register_new_signup, self.INSTALLATION_ID)
+        self.assertRaises(IncogniaError, api.register_new_signup, request_token='')
 
-        mock_token_manager_get.assert_called()
-        mock_base_request_post.assert_called_with(Endpoints.SIGNUPS,
-                                                  headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
-                                                  data=self.REGISTER_SIGNUP_DATA)
+        mock_token_manager_get.assert_not_called()
+        mock_base_request_post.assert_not_called()
 
     @patch.object(BaseRequest, 'post')
-    @patch.object(TokenManager, 'get')
-    def test_register_new_signup_when_installation_id_is_empty_should_raise_an_IncogniaError(
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_new_signup_when_request_token_is_invalid_should_raise_an_IncogniaHTTPError(
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+        mock_base_request_post.configure_mock(side_effect=IncogniaHTTPError)
+
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        self.assertRaises(IncogniaError, api.register_new_signup, '')
+        self.assertRaises(IncogniaHTTPError, api.register_new_signup, self.INVALID_REQUEST_TOKEN)
 
-        mock_token_manager_get.assert_not_called()
-        mock_base_request_post.assert_not_called()
+        mock_token_manager_get.assert_called()
+        mock_base_request_post.assert_called_with(Endpoints.SIGNUPS,
+                                                  headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
+                                                  data=self.REGISTER_INVALID_SIGNUP_DATA)
 
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
@@ -221,7 +216,6 @@ class TestIncogniaAPI(TestCase):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
         api.register_feedback(self.VALID_EVENT_FEEDBACK_TYPE,
-                              timestamp=self.TIMESTAMP,
                               occurred_at=self.TIMESTAMP,
                               expires_at=self.TIMESTAMP,
                               external_id=self.EXTERNAL_ID,
@@ -230,7 +224,6 @@ class TestIncogniaAPI(TestCase):
                               signup_id=self.SIGNUP_ID,
                               account_id=self.ACCOUNT_ID,
                               installation_id=self.INSTALLATION_ID,
-                              session_token=self.SESSION_TOKEN,
                               request_token=self.REQUEST_TOKEN)
 
         mock_token_manager_get.assert_called()
@@ -249,20 +242,6 @@ class TestIncogniaAPI(TestCase):
         mock_token_manager_get.assert_not_called()
         mock_base_request_post.assert_not_called()
 
-    @patch.object(BaseRequest, 'post')
-    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
-    def test_register_feedback_when_timestamp_does_not_have_timezone_should_raise_IncogniaError(
-            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
-        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
-
-        self.assertRaises(IncogniaError,
-                          api.register_feedback,
-                          event=self.VALID_EVENT_FEEDBACK_TYPE,
-                          timestamp=self.TIMESTAMP_WITHOUT_TIMEZONE)
-
-        mock_token_manager_get.assert_not_called()
-        mock_base_request_post.assert_not_called()
-
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
     def test_register_feedback_when_occurred_at_does_not_have_timezone_should_raise_IncogniaError(
@@ -291,22 +270,6 @@ class TestIncogniaAPI(TestCase):
         mock_token_manager_get.assert_not_called()
         mock_base_request_post.assert_not_called()
 
-    @patch.object(BaseRequest, 'post')
-    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
-    def test_register_feedback_when_required_fields_are_invalid_should_raise_an_IncogniaHTTPError(
-            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
-        mock_base_request_post.configure_mock(side_effect=IncogniaHTTPError)
-
-        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
-
-        self.assertRaises(IncogniaHTTPError, api.register_feedback,
-                          event=self.INVALID_EVENT_FEEDBACK_TYPE)
-
-        mock_token_manager_get.assert_called()
-        mock_base_request_post.assert_called_with(Endpoints.FEEDBACKS,
-                                                  headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
-                                                  data=self.REGISTER_INVALID_FEEDBACK_DATA)
-
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
     def test_register_payment_when_required_fields_are_valid_should_work(
@@ -315,10 +278,9 @@ class TestIncogniaAPI(TestCase):
 
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        request_response = api.register_payment(self.INSTALLATION_ID,
+        request_response = api.register_payment(self.REQUEST_TOKEN,
                                                 self.ACCOUNT_ID,
-                                                policy_id=self.POLICY_ID,
-                                                request_token=self.REQUEST_TOKEN)
+                                                policy_id=self.POLICY_ID)
 
         mock_token_manager_get.assert_called()
         mock_base_request_post.assert_called_with(Endpoints.TRANSACTIONS,
@@ -330,11 +292,12 @@ class TestIncogniaAPI(TestCase):
 
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
-    def test_register_payment_when_installation_id_is_empty_should_raise_an_IncogniaError(
+    def test_register_payment_when_request_token_is_empty_should_raise_an_IncogniaError(
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        self.assertRaises(IncogniaError, api.register_payment, installation_id='',
+        self.assertRaises(IncogniaError, api.register_payment,
+                          request_token='',
                           account_id=self.ACCOUNT_ID)
 
         mock_token_manager_get.assert_not_called()
@@ -346,7 +309,8 @@ class TestIncogniaAPI(TestCase):
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        self.assertRaises(IncogniaError, api.register_payment, installation_id=self.INSTALLATION_ID,
+        self.assertRaises(IncogniaError, api.register_payment,
+                          request_token=self.REQUEST_TOKEN,
                           account_id='')
 
         mock_token_manager_get.assert_not_called()
@@ -361,7 +325,7 @@ class TestIncogniaAPI(TestCase):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
         self.assertRaises(IncogniaHTTPError, api.register_payment,
-                          installation_id=self.INVALID_INSTALLATION_ID,
+                          request_token=self.INVALID_REQUEST_TOKEN,
                           account_id=self.INVALID_ACCOUNT_ID)
 
         mock_token_manager_get.assert_called()
@@ -378,10 +342,9 @@ class TestIncogniaAPI(TestCase):
 
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        request_response = api.register_login(self.INSTALLATION_ID,
+        request_response = api.register_login(self.REQUEST_TOKEN,
                                               self.ACCOUNT_ID,
-                                              policy_id=self.POLICY_ID,
-                                              request_token=self.REQUEST_TOKEN)
+                                              policy_id=self.POLICY_ID)
 
         mock_token_manager_get.assert_called()
         mock_base_request_post.assert_called_with(Endpoints.TRANSACTIONS,
@@ -393,11 +356,12 @@ class TestIncogniaAPI(TestCase):
 
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
-    def test_register_login_when_installation_id_is_empty_should_raise_an_IncogniaError(
+    def test_register_login_when_request_token_is_empty_should_raise_an_IncogniaError(
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        self.assertRaises(IncogniaError, api.register_login, installation_id='',
+        self.assertRaises(IncogniaError, api.register_login,
+                          request_token='',
                           account_id=self.ACCOUNT_ID)
 
         mock_token_manager_get.assert_not_called()
@@ -409,7 +373,8 @@ class TestIncogniaAPI(TestCase):
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        self.assertRaises(IncogniaError, api.register_login, installation_id=self.INSTALLATION_ID,
+        self.assertRaises(IncogniaError, api.register_login,
+                          request_token=self.REQUEST_TOKEN,
                           account_id='')
 
         mock_token_manager_get.assert_not_called()
@@ -424,7 +389,7 @@ class TestIncogniaAPI(TestCase):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
         self.assertRaises(IncogniaHTTPError, api.register_login,
-                          installation_id=self.INVALID_INSTALLATION_ID,
+                          request_token=self.INVALID_REQUEST_TOKEN,
                           account_id=self.INVALID_ACCOUNT_ID)
 
         mock_token_manager_get.assert_called()
@@ -441,10 +406,9 @@ class TestIncogniaAPI(TestCase):
 
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        request_response = api.register_web_login(self.SESSION_TOKEN,
+        request_response = api.register_web_login(self.REQUEST_TOKEN,
                                                   self.ACCOUNT_ID,
-                                                  policy_id=self.POLICY_ID,
-                                                  request_token=self.REQUEST_TOKEN)
+                                                  policy_id=self.POLICY_ID)
 
         mock_token_manager_get.assert_called()
         mock_base_request_post.assert_called_with(Endpoints.TRANSACTIONS,
@@ -456,11 +420,12 @@ class TestIncogniaAPI(TestCase):
 
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
-    def test_register_web_login_when_session_token_is_empty_should_raise_an_IncogniaError(
+    def test_register_web_login_when_request_token_is_empty_should_raise_an_IncogniaError(
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        self.assertRaises(IncogniaError, api.register_web_login, session_token='',
+        self.assertRaises(IncogniaError, api.register_web_login,
+                          request_token='',
                           account_id=self.ACCOUNT_ID)
 
         mock_token_manager_get.assert_not_called()
@@ -472,7 +437,8 @@ class TestIncogniaAPI(TestCase):
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        self.assertRaises(IncogniaError, api.register_web_login, session_token=self.SESSION_TOKEN,
+        self.assertRaises(IncogniaError, api.register_web_login,
+                          request_token=self.REQUEST_TOKEN,
                           account_id='')
 
         mock_token_manager_get.assert_not_called()
@@ -487,8 +453,8 @@ class TestIncogniaAPI(TestCase):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
         self.assertRaises(IncogniaHTTPError, api.register_web_login,
-                          session_token=self.INVALID_SESSION_TOKEN,
-                          account_id=self.INVALID_ACCOUNT_ID)
+                          account_id=self.INVALID_ACCOUNT_ID,
+                          request_token=self.INVALID_REQUEST_TOKEN)
 
         mock_token_manager_get.assert_called()
         mock_base_request_post.assert_called_with(Endpoints.TRANSACTIONS,

incognia_python-2.2.0/incognia/datetime_util.py

@@ -1,9 +0,0 @@
-import datetime as dt
-
-
-def total_milliseconds_since_epoch(t: dt.datetime) -> int:
-    return int((t - dt.datetime.fromtimestamp(0, dt.timezone.utc)).total_seconds() * 1000.0)
-
-
-def has_timezone(d: dt.datetime) -> bool:
-    return d.tzinfo is not None and d.tzinfo.utcoffset(d) is not None