unit-python-sdk 0.23.1__tar.gz → 0.25.0__tar.gz

{unit-python-sdk-0.23.1/unit_python_sdk.egg-info → unit-python-sdk-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unit-python-sdk
-Version: 0.23.1
+Version: 0.25.0
 Summary: This library provides a python wrapper to http://unit.co API. See https://docs.unit.co/
 Home-page: https://github.com/unit-finance/unit-python-sdk
 Download-URL: https://github.com/unit-finance/unit-python-sdk.git

{unit-python-sdk-0.23.1 → unit-python-sdk-0.25.0}/setup.py

@@ -3,7 +3,7 @@ from distutils.core import setup
 setup(
     name='unit-python-sdk',
     packages=['unit', 'unit.api', 'unit.models', 'unit.utils'],
-    version="0.23.1",
+    version="0.25.0",
     license='Mozilla Public License 2.0',
     description='This library provides a python wrapper to http://unit.co API. See https://docs.unit.co/',
     author='unit.co',

{unit-python-sdk-0.23.1 → unit-python-sdk-0.25.0}/unit/__init__.py

@@ -23,6 +23,7 @@ from unit.api.account_end_of_day_resource import AccountEndOfDayResource
 from unit.api.checkDeposit_resource import CheckDepositResource
 from unit.api.dispute_resource import DisputeResource
 from unit.api.reward_resource import RewardResource
+from unit.api.recurring_payment_resource import RecurringPaymentResource
 from unit.api.repayment_resource import RepaymentResource
 from unit.utils.configuration import Configuration
 
@@ -35,6 +36,7 @@ class Unit(object):
             raise Exception("use only configuration")
 
         c = configuration if configuration else Configuration(api_url, token, retries, timeout)
+
         self.applications = ApplicationResource(c)
         self.customers = CustomerResource(c)
         self.accounts = AccountResource(c)
@@ -61,3 +63,5 @@ class Unit(object):
         self.rewards = RewardResource(c)
         self.received_payments = ReceivedPaymentResource(c)
         self.repayments = RepaymentResource(c)
+        self.recurring_payments = RecurringPaymentResource(c)
+

{unit-python-sdk-0.23.1 → unit-python-sdk-0.25.0}/unit/api/application_resource.py

@@ -8,33 +8,29 @@ class ApplicationResource(BaseResource):
     def __init__(self, configuration: Configuration):
         super().__init__("applications", configuration)
 
-    def create(self, request: Union[CreateIndividualApplicationRequest, CreateBusinessApplicationRequest]) -> Union[UnitResponse[ApplicationDTO], UnitError]:
+    def create(self, request: CreateApplicationRequest) -> Union[UnitResponse[ApplicationDTO], UnitError]:
         payload = request.to_json_api()
         response = super().post_create(self.resource, payload)
 
-        if response.ok:
+        if super().is_20x(response.status_code):
             data = response.json().get("data")
             included = response.json().get("included")
-            if data["type"] == "individualApplication":
-                return UnitResponse[IndividualApplicationDTO](DtoDecoder.decode(data), DtoDecoder.decode(included))
-            else:
-                return UnitResponse[BusinessApplicationDTO](DtoDecoder.decode(data), DtoDecoder.decode(included))
+            return UnitResponse[ApplicationDTO](DtoDecoder.decode(data), DtoDecoder.decode(included))
         else:
             return UnitError.from_json_api(response.json())
 
     def list(self, params: ListApplicationParams = None) -> Union[UnitResponse[List[ApplicationDTO]], UnitError]:
         params = params or ListApplicationParams()
         response = super().get(self.resource, params.to_dict())
-        if response.status_code == 200:
+        if super().is_20x(response.status_code):
             data = response.json().get("data")
-            included = response.json().get("included")
             return UnitResponse[ApplicationDTO](DtoDecoder.decode(data), None)
         else:
             return UnitError.from_json_api(response.json())
 
     def get(self, application_id: str) -> Union[UnitResponse[ApplicationDTO], UnitError]:
         response = super().get(f"{self.resource}/{application_id}")
-        if response.status_code == 200:
+        if super().is_20x(response.status_code):
             data = response.json().get("data")
             included = response.json().get("included")
             return UnitResponse[ApplicationDTO](DtoDecoder.decode(data), DtoDecoder.decode(included))
@@ -56,13 +52,13 @@ class ApplicationResource(BaseResource):
                 headers = {"Content-Type": "application/pdf"}
 
         response = super().put(url, request.file, headers)
-        if response.status_code == 200:
+        if super().is_20x(response.status_code):
             data = response.json().get("data")
             return UnitResponse[ApplicationDocumentDTO](DtoDecoder.decode(data), None)
         else:
             return UnitError.from_json_api(response.json())
 
-    def update(self, request: PatchApplicationRequest) -> Union[UnitResponse[ApplicationDTO], UnitError]:
+    def update(self, request: UnionPatchApplicationRequest) -> Union[UnitResponse[ApplicationDTO], UnitError]:
         payload = request.to_json_api()
         response = super().patch(f"{self.resource}/{request.application_id}", payload)
         if super().is_20x(response.status_code):
@@ -71,6 +67,15 @@ class ApplicationResource(BaseResource):
         else:
             return UnitError.from_json_api(response.json())
 
+    def update_business_beneficial_owner(self, request: PatchBusinessBeneficialOwnerRequest) -> Union[UnitResponse[BeneficialOwnerDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().patch(f"beneficial-owner/{request.beneficial_owner_id}", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[BeneficialOwnerDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())
+
     def cancel(self, request: CancelApplicationRequest) -> Union[UnitResponse[ApplicationDTO], UnitError]:
         payload = request.to_json_api()
         response = super().post(f"{self.resource}/{request.application_id}/cancel", payload)

{unit-python-sdk-0.23.1 → unit-python-sdk-0.25.0}/unit/api/counterparty_resource.py

@@ -1,5 +1,8 @@
+from typing import Union, List
+
 from unit.utils.configuration import Configuration
 from unit.api.base_resource import BaseResource
+from unit.models import UnitResponse, UnitError
 from unit.models.counterparty import *
 from unit.models.codecs import DtoDecoder
 

unit-python-sdk-0.25.0/unit/api/recurring_payment_resource.py

@@ -0,0 +1,53 @@
+from unit.utils.configuration import Configuration
+from unit.api.base_resource import BaseResource
+from unit.models.payment import *
+from unit.models.codecs import DtoDecoder
+
+
+class RecurringPaymentResource(BaseResource):
+    def __init__(self, configuration: Configuration):
+        super().__init__("recurring-payments", configuration)
+
+    def create(self, request: CreateRecurringPaymentRequest) -> Union[UnitResponse[RecurringPaymentDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().post(f"{self.resource}", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[RecurringPaymentDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())
+
+    def get(self, payment_id: str, include: Optional[str] = "") -> Union[UnitResponse[RecurringPaymentDTO], UnitError]:
+        response = super().get(f"{self.resource}/{payment_id}", {"include": include})
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            included = response.json().get("included")
+            return UnitResponse[RecurringPaymentDTO](DtoDecoder.decode(data), DtoDecoder.decode(included))
+        else:
+            return UnitError.from_json_api(response.json())
+
+    def list(self, params: ListRecurringPaymentParams = None) -> Union[UnitResponse[List[RecurringPaymentDTO]], UnitError]:
+        params = params or ListRecurringPaymentParams()
+        response = super().get(self.resource, params.to_dict())
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            included = response.json().get("included")
+            return UnitResponse[RecurringPaymentDTO](DtoDecoder.decode(data), DtoDecoder.decode(included))
+        else:
+            return UnitError.from_json_api(response.json())
+
+    def disable(self, payment_id: str) -> Union[UnitResponse[RecurringPaymentDTO], UnitError]:
+        response = super().post(f"{self.resource}/{payment_id}/disable")
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[RecurringPaymentDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())
+
+    def enable(self, payment_id: str) -> Union[UnitResponse[RecurringPaymentDTO], UnitError]:
+        response = super().post(f"{self.resource}/{payment_id}/enable")
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[RecurringPaymentDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())

{unit-python-sdk-0.23.1 → unit-python-sdk-0.25.0}/unit/models/__init__.py

@@ -1,4 +1,5 @@
 import json
+
 try:
     from typing import TypeVar, Generic, Union, Optional, Literal, List, Dict
 except ImportError:
@@ -7,6 +8,23 @@ except ImportError:
 
 from datetime import datetime, date
 
+Occupation = Literal["ArchitectOrEngineer", "BusinessAnalystAccountantOrFinancialAdvisor",
+                     "CommunityAndSocialServicesWorker", "ConstructionMechanicOrMaintenanceWorker", "Doctor",
+                     "Educator", "EntertainmentSportsArtsOrMedia", "ExecutiveOrManager", "FarmerFishermanForester",
+                     "FoodServiceWorker", "GigWorker", "HospitalityOfficeOrAdministrativeSupportWorker",
+                     "HouseholdManager", "JanitorHousekeeperLandscaper", "Lawyer", "ManufacturingOrProductionWorker",
+                     "MilitaryOrPublicSafety", "NurseHealthcareTechnicianOrHealthcareSupport",
+                     "PersonalCareOrServiceWorker", "PilotDriverOperator", "SalesRepresentativeBrokerAgent",
+                     "ScientistOrTechnologist", "Student"]
+AnnualIncome = Literal["UpTo10k", "Between10kAnd25k", "Between25kAnd50k", "Between50kAnd100k", "Between100kAnd250k",
+                       "Over250k"]
+SourceOfIncome = Literal["EmploymentOrPayrollIncome", "PartTimeOrContractorIncome", "InheritancesAndGifts",
+                         "PersonalInvestments", "BusinessOwnershipInterests", "GovernmentBenefits"]
+Status = Literal["Approved", "Denied", "PendingReview"]
+Title = Literal["CEO", "COO", "CFO", "President"]
+EntityType = Literal["Corporation", "LLC", "Partnership"]
+UseSelfieVerification = Literal["Never", "ReplaceIdentification"]
+
 
 def to_camel_case(snake_str):
     components = snake_str.lstrip('_').split('_')
@@ -104,6 +122,9 @@ class UnitRequest(object):
 
         return payload
 
+    def __repr__(self):
+        return json.dumps(self.to_json_api())
+
 
 class UnitParams(object):
     def to_dict(self) -> Dict:
@@ -155,12 +176,8 @@ class UnitError(object):
 
     def __str__(self):
         return json.dumps({"errors": [{"title": err.title, "status": err.status, "detail": err.detail,
-                                "details": err.details, "source": err.source, "code": err.code} for err in self.errors]})
-
-
-Status = Literal["Approved", "Denied", "PendingReview"]
-Title = Literal["CEO", "COO", "CFO", "President"]
-EntityType = Literal["Corporation", "LLC", "Partnership"]
+                                       "details": err.details, "source": err.source, "code": err.code} for err in
+                                      self.errors]})
 
 
 class FullName(UnitDTO):
@@ -192,6 +209,7 @@ class Address(UnitDTO):
 
         return None
 
+
 class Phone(UnitDTO):
     def __init__(self, country_code: str, number: str):
         self.country_code = country_code
@@ -202,6 +220,26 @@ class Phone(UnitDTO):
         return Phone(data.get("countryCode"), data.get("number"))
 
 
+class EvaluationParams(object):
+    def __init__(self, use_selfie_verification: Optional[UseSelfieVerification] = None,
+                 require_id_verification: Optional[bool] = False):
+        self.use_selfie_verification = use_selfie_verification
+        self.require_id_verification = require_id_verification
+
+    def to_json_api(self):
+        return {
+            "useSelfieVerification": self.use_selfie_verification,
+            "requireIdVerification": self.require_id_verification,
+        }
+
+    @staticmethod
+    def from_json_api(data: Dict):
+        if data:
+            return EvaluationParams(data.get("useSelfieVerification"), data.get("requireIdVerification"))
+
+        return None
+
+
 class BusinessContact(UnitDTO):
     def __init__(self, full_name: FullName, email: str, phone: Phone):
         self.full_name = full_name
@@ -210,13 +248,17 @@ class BusinessContact(UnitDTO):
 
     @staticmethod
     def from_json_api(data: Dict):
-        return BusinessContact(FullName.from_json_api(data.get("fullName")), data.get("email"), Phone.from_json_api(data.get("phone")))
+        return BusinessContact(FullName.from_json_api(data.get("fullName")), data.get("email"),
+                               Phone.from_json_api(data.get("phone")))
 
 
 class Officer(UnitDTO):
     def __init__(self, full_name: FullName, date_of_birth: date, address: Address, phone: Phone, email: str,
                  status: Optional[Status] = None, title: Optional[Title] = None, ssn: Optional[str] = None,
-                 passport: Optional[str] = None, nationality: Optional[str] = None):
+                 passport: Optional[str] = None, nationality: Optional[str] = None,
+                 evaluation_params: Optional[EvaluationParams] = None, id_theft_score: Optional[str] = None,
+                 occupation: Optional[Occupation] = None, annual_income: Optional[AnnualIncome] = None,
+                 source_of_income: Optional[SourceOfIncome] = None):
         self.full_name = full_name
         self.date_of_birth = date_of_birth
         self.address = address
@@ -227,18 +269,28 @@ class Officer(UnitDTO):
         self.ssn = ssn
         self.passport = passport
         self.nationality = nationality
+        self.evaluation_params = evaluation_params
+        self.id_theft_score = id_theft_score
+        self.occupation = occupation
+        self.annual_income = annual_income
+        self.source_of_income = source_of_income
 
     @staticmethod
     def from_json_api(data: Dict):
         return Officer(data.get("fullName"), data.get("dateOfBirth"), data.get("address"), data.get("phone"),
-                data.get("email"), data.get("status"), data.get("title"), data.get("ssn"), data.get("passport"),
-                data.get("nationality"))
+                       data.get("email"), data.get("status"), data.get("title"), data.get("ssn"), data.get("passport"),
+                       data.get("nationality"), EvaluationParams.from_json_api(data.get("evaluationParams")),
+                       data.get("idTheftScore"), data.get("occupation"), data.get("annualIncome"),
+                       data.get("sourceOfIncome"))
 
 
 class BeneficialOwner(UnitDTO):
     def __init__(self, full_name: FullName, date_of_birth: date, address: Address, phone: Phone, email: str,
                  status: Optional[Status] = None, ssn: Optional[str] = None, passport: Optional[str] = None,
-                 nationality: Optional[str] = None, percentage: Optional[int] = None):
+                 nationality: Optional[str] = None, percentage: Optional[int] = None,
+                 evaluation_params: Optional[EvaluationParams] = None, id_theft_score: Optional[str] = None,
+                 occupation: Optional[Occupation] = None, annual_income: Optional[AnnualIncome] = None,
+                 source_of_income: Optional[SourceOfIncome] = None):
         self.full_name = full_name
         self.date_of_birth = date_of_birth
         self.address = address
@@ -249,15 +301,41 @@ class BeneficialOwner(UnitDTO):
         self.passport = passport
         self.nationality = nationality
         self.percentage = percentage
+        self.evaluation_params = evaluation_params
+        self.id_theft_score = id_theft_score
+        self.occupation = occupation
+        self.annual_income = annual_income
+        self.source_of_income = source_of_income
 
     @staticmethod
-    def from_json_api(l: List):
-        beneficial_owners = []
-        for data in l:
-            beneficial_owners.append(BeneficialOwner(data.get("fullName"), data.get("dateOfBirth"), data.get("address"),
-                data.get("phone"), data.get("email"), data.get("status"), data.get("ssn"),
-                data.get("passport"), data.get("nationality"), data.get("percentage")))
-        return beneficial_owners
+    def create(data: Dict):
+        return BeneficialOwner(data.get("fullName"), data.get("dateOfBirth"), data.get("address"),
+                               data.get("phone"), data.get("email"), data.get("status"), data.get("ssn"),
+                               data.get("passport"), data.get("nationality"), data.get("percentage"),
+                               EvaluationParams.from_json_api(data.get("evaluationParams")), data.get("idTheftScore"),
+                               data.get("occupation"), data.get("annualIncome"), data.get("sourceOfIncome"))
+
+    @staticmethod
+    def from_json_api(l: Union[List, Dict]):
+        if isinstance(l, list):
+            beneficial_owners = []
+            for data in l:
+                beneficial_owners.append(BeneficialOwner.create(data))
+            return beneficial_owners
+        else:
+            return BeneficialOwner.create(l)
+
+
+class BeneficialOwnerDTO(UnitDTO):
+    def __init__(self, _id: str, _type: str, attributes: BeneficialOwner, relationships: Dict[str, Relationship]):
+        self.id = _id
+        self.type = _type
+        self.attributes = attributes
+        self.relationships = relationships
+
+    @staticmethod
+    def from_json_api(_id, _type, attributes, relationships):
+        return BeneficialOwnerDTO(_id, _type, BeneficialOwner.from_json_api(attributes), relationships)
 
 
 class AuthorizedUser(UnitDTO):
@@ -277,10 +355,11 @@ class AuthorizedUser(UnitDTO):
 
         if type(data) is dict:
             return AuthorizedUser(FullName.from_json_api(data.get("fullName")), data.get("email"),
-                              Phone.from_json_api(data.get("phone")), data.get("jwtSubject"))
+                                  Phone.from_json_api(data.get("phone")), data.get("jwtSubject"))
 
         return [AuthorizedUser(FullName.from_json_api(d.get("fullName")), d.get("email"),
-                              Phone.from_json_api(d.get("phone")), d.get("jwtSubject")) for d in data]
+                               Phone.from_json_api(d.get("phone")), d.get("jwtSubject")) for d in data]
+
 
 class WireCounterparty(UnitDTO):
     def __init__(self, routing_number: str, account_number: str, name: str, address: Address):
@@ -294,6 +373,7 @@ class WireCounterparty(UnitDTO):
         return WireCounterparty(data["routingNumber"], data["accountNumber"], data["name"],
                                 Address.from_json_api(data["address"]))
 
+
 class Counterparty(UnitDTO):
     def __init__(self, routing_number: str, account_number: str, account_type: str, name: str):
         self.routing_number = routing_number
@@ -305,6 +385,7 @@ class Counterparty(UnitDTO):
     def from_json_api(data: Dict):
         return Counterparty(data["routingNumber"], data["accountNumber"], data["accountType"], data["name"])
 
+
 class Coordinates(UnitDTO):
     def __init__(self, longitude: float, latitude: float):
         self.longitude = longitude
@@ -344,7 +425,8 @@ class CardLevelLimits(UnitDTO):
     @staticmethod
     def from_json_api(data: Dict):
         return CardLevelLimits(data["dailyWithdrawal"], data["dailyPurchase"], data["monthlyWithdrawal"],
-                      data["monthlyPurchase"])
+                               data["monthlyPurchase"])
+
 
 class CardTotals(UnitDTO):
     def __init__(self, withdrawals: int, deposits: int, purchases: int):
@@ -372,6 +454,7 @@ class DeviceFingerprint(UnitDTO):
     def from_json_api(cls, data: Dict):
         return cls(value=data["value"], provider=data["provider"])
 
+
 class CheckCounterparty(object):
     def __init__(self, routing_number: str, account_number: str, name: str):
         self.routing_number = routing_number
@@ -384,3 +467,83 @@ class CheckCounterparty(object):
             return None
 
         return CheckCounterparty(data["routingNumber"], data["accountNumber"], data["name"])
+
+
+class BaseIndividual(UnitDTO):
+    def __init__(self, full_name: FullName, date_of_birth: date, ssn: str, email: str, phone: Phone, address: Address):
+        self.full_name = full_name
+        self.date_of_birth = date_of_birth
+        self.ssn = ssn
+        self.email = email
+        self.phone = phone
+        self.address = address
+
+
+class Grantor(BaseIndividual):
+    @staticmethod
+    def from_json_api(data: Dict):
+        if not data:
+            return None
+
+        return Grantor(FullName.from_json_api(data["fullName"]), data["dateOfBirth"], data["ssn"], data["email"],
+                       Phone.from_json_api(data["phone"]), Address.from_json_api(data["address"]))
+
+
+class Trustee(BaseIndividual):
+    @staticmethod
+    def from_json_api(data: Dict):
+        if not data:
+            return None
+
+        return Trustee(FullName.from_json_api(data["fullName"]), data["dateOfBirth"], data["ssn"], data["email"],
+                       Phone.from_json_api(data["phone"]), Address.from_json_api(data["address"]))
+
+
+class TrustContact(UnitDTO):
+    def __init__(self, full_name: FullName, email: str, phone: Phone, address: Address, jwt_subject: Optional[str]):
+        self.full_name = full_name
+        self.email = email
+        self.phone = phone
+        self.address = address
+        self.jwt_subject = jwt_subject
+
+    @staticmethod
+    def from_json_api(data: Dict):
+        if not data:
+            return None
+
+        return TrustContact(FullName.from_json_api(data["fullName"]), data["email"], Phone.from_json_api(data["phone"]),
+                            Address.from_json_api(data["address"]), data.get("jwtSubject"))
+
+
+class Agent(BaseIndividual):
+    def __init__(self, status: str, full_name: FullName, ssn: Optional[str], passport: Optional[str],
+                 nationality: Optional[str], date_of_birth: date, email: str, phone: Phone, address: Address,
+                 jwt_subject: Optional[str]):
+        super().__init__(full_name, date_of_birth, ssn, email, phone, address)
+        self.status = status
+        self.passport = passport
+        self.nationality = nationality
+        self.jwt_subject = jwt_subject
+
+    @staticmethod
+    def from_json_api(data: Dict):
+        if not data:
+            return None
+
+        return Agent(data["status"], FullName.from_json_api(data["fullName"]), data.get("ssn"), data.get("passport"),
+                     data.get("nationality"), data["dateOfBirth"], data["email"], Phone.from_json_api(data["phone"]),
+                     Address.from_json_api(data["address"]), data.get("jwtSubject"))
+
+
+class Beneficiary(UnitDTO):
+    def __init__(self, full_name: FullName, date_of_birth: date):
+        self.full_name = full_name
+        self.date_of_birth = date_of_birth
+
+    @staticmethod
+    def from_json_api(data: Dict):
+        if not data:
+            return None
+
+        return Beneficiary(FullName.from_json_api(data["fullName"]), data.get("dateOfBirth"))