connect-sdk-python2 3.47.0__zip → 4.0.1__zip

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product_field_validators.py

@@ -0,0 +1,255 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.boleto_bancario_requiredness_validator import BoletoBancarioRequirednessValidator
+from worldline.connect.sdk.v1.domain.empty_validator import EmptyValidator
+from worldline.connect.sdk.v1.domain.fixed_list_validator import FixedListValidator
+from worldline.connect.sdk.v1.domain.length_validator import LengthValidator
+from worldline.connect.sdk.v1.domain.range_validator import RangeValidator
+from worldline.connect.sdk.v1.domain.regular_expression_validator import RegularExpressionValidator
+
+
+class PaymentProductFieldValidators(DataObject):
+
+    __boleto_bancario_requiredness = None
+    __email_address = None
+    __expiration_date = None
+    __fixed_list = None
+    __iban = None
+    __length = None
+    __luhn = None
+    __range = None
+    __regular_expression = None
+    __resident_id_number = None
+    __terms_and_conditions = None
+
+    @property
+    def boleto_bancario_requiredness(self):
+        """
+        | Indicates the requiredness of the field based on the fiscalnumber for Boleto Bancario
+
+        Type: :class:`worldline.connect.sdk.v1.domain.boleto_bancario_requiredness_validator.BoletoBancarioRequirednessValidator`
+        """
+        return self.__boleto_bancario_requiredness
+
+    @boleto_bancario_requiredness.setter
+    def boleto_bancario_requiredness(self, value):
+        self.__boleto_bancario_requiredness = value
+
+    @property
+    def email_address(self):
+        """
+        | Indicates that the content should be validated against the rules for an email address
+
+        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
+        """
+        return self.__email_address
+
+    @email_address.setter
+    def email_address(self, value):
+        self.__email_address = value
+
+    @property
+    def expiration_date(self):
+        """
+        | Indicates that the content should be validated against the rules for an expiration date (it should be in the future)
+
+        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
+        """
+        return self.__expiration_date
+
+    @expiration_date.setter
+    def expiration_date(self, value):
+        self.__expiration_date = value
+
+    @property
+    def fixed_list(self):
+        """
+        | Indicates that content should be one of the, in this object, listed items
+
+        Type: :class:`worldline.connect.sdk.v1.domain.fixed_list_validator.FixedListValidator`
+        """
+        return self.__fixed_list
+
+    @fixed_list.setter
+    def fixed_list(self, value):
+        self.__fixed_list = value
+
+    @property
+    def iban(self):
+        """
+        | Indicates that the content of this (iban) field needs to validated against format checks and modulo check (as described in ISO 7064)
+
+        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
+        """
+        return self.__iban
+
+    @iban.setter
+    def iban(self, value):
+        self.__iban = value
+
+    @property
+    def length(self):
+        """
+        | Indicates that the content needs to be validated against length criteria defined in this object
+
+        Type: :class:`worldline.connect.sdk.v1.domain.length_validator.LengthValidator`
+        """
+        return self.__length
+
+    @length.setter
+    def length(self, value):
+        self.__length = value
+
+    @property
+    def luhn(self):
+        """
+        | Indicates that the content needs to be validated using a LUHN check
+
+        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
+        """
+        return self.__luhn
+
+    @luhn.setter
+    def luhn(self, value):
+        self.__luhn = value
+
+    @property
+    def range(self):
+        """
+        | Indicates that the content needs to be validated against a, in this object, defined range
+
+        Type: :class:`worldline.connect.sdk.v1.domain.range_validator.RangeValidator`
+        """
+        return self.__range
+
+    @range.setter
+    def range(self, value):
+        self.__range = value
+
+    @property
+    def regular_expression(self):
+        """
+        | A string representing the regular expression to check
+
+        Type: :class:`worldline.connect.sdk.v1.domain.regular_expression_validator.RegularExpressionValidator`
+        """
+        return self.__regular_expression
+
+    @regular_expression.setter
+    def regular_expression(self, value):
+        self.__regular_expression = value
+
+    @property
+    def resident_id_number(self):
+        """
+        | Indicates that the content needs to be validated as per the Chinese resident identity number format
+
+        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
+        """
+        return self.__resident_id_number
+
+    @resident_id_number.setter
+    def resident_id_number(self, value):
+        self.__resident_id_number = value
+
+    @property
+    def terms_and_conditions(self):
+        """
+        | Indicates that the content should be validated as such that the customer has accepted the field as if they were terms and conditions of a service
+
+        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
+        """
+        return self.__terms_and_conditions
+
+    @terms_and_conditions.setter
+    def terms_and_conditions(self, value):
+        self.__terms_and_conditions = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProductFieldValidators, self).to_dictionary()
+        if self.boleto_bancario_requiredness is not None:
+            dictionary['boletoBancarioRequiredness'] = self.boleto_bancario_requiredness.to_dictionary()
+        if self.email_address is not None:
+            dictionary['emailAddress'] = self.email_address.to_dictionary()
+        if self.expiration_date is not None:
+            dictionary['expirationDate'] = self.expiration_date.to_dictionary()
+        if self.fixed_list is not None:
+            dictionary['fixedList'] = self.fixed_list.to_dictionary()
+        if self.iban is not None:
+            dictionary['iban'] = self.iban.to_dictionary()
+        if self.length is not None:
+            dictionary['length'] = self.length.to_dictionary()
+        if self.luhn is not None:
+            dictionary['luhn'] = self.luhn.to_dictionary()
+        if self.range is not None:
+            dictionary['range'] = self.range.to_dictionary()
+        if self.regular_expression is not None:
+            dictionary['regularExpression'] = self.regular_expression.to_dictionary()
+        if self.resident_id_number is not None:
+            dictionary['residentIdNumber'] = self.resident_id_number.to_dictionary()
+        if self.terms_and_conditions is not None:
+            dictionary['termsAndConditions'] = self.terms_and_conditions.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProductFieldValidators, self).from_dictionary(dictionary)
+        if 'boletoBancarioRequiredness' in dictionary:
+            if not isinstance(dictionary['boletoBancarioRequiredness'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['boletoBancarioRequiredness']))
+            value = BoletoBancarioRequirednessValidator()
+            self.boleto_bancario_requiredness = value.from_dictionary(dictionary['boletoBancarioRequiredness'])
+        if 'emailAddress' in dictionary:
+            if not isinstance(dictionary['emailAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['emailAddress']))
+            value = EmptyValidator()
+            self.email_address = value.from_dictionary(dictionary['emailAddress'])
+        if 'expirationDate' in dictionary:
+            if not isinstance(dictionary['expirationDate'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['expirationDate']))
+            value = EmptyValidator()
+            self.expiration_date = value.from_dictionary(dictionary['expirationDate'])
+        if 'fixedList' in dictionary:
+            if not isinstance(dictionary['fixedList'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fixedList']))
+            value = FixedListValidator()
+            self.fixed_list = value.from_dictionary(dictionary['fixedList'])
+        if 'iban' in dictionary:
+            if not isinstance(dictionary['iban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['iban']))
+            value = EmptyValidator()
+            self.iban = value.from_dictionary(dictionary['iban'])
+        if 'length' in dictionary:
+            if not isinstance(dictionary['length'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['length']))
+            value = LengthValidator()
+            self.length = value.from_dictionary(dictionary['length'])
+        if 'luhn' in dictionary:
+            if not isinstance(dictionary['luhn'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['luhn']))
+            value = EmptyValidator()
+            self.luhn = value.from_dictionary(dictionary['luhn'])
+        if 'range' in dictionary:
+            if not isinstance(dictionary['range'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['range']))
+            value = RangeValidator()
+            self.range = value.from_dictionary(dictionary['range'])
+        if 'regularExpression' in dictionary:
+            if not isinstance(dictionary['regularExpression'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['regularExpression']))
+            value = RegularExpressionValidator()
+            self.regular_expression = value.from_dictionary(dictionary['regularExpression'])
+        if 'residentIdNumber' in dictionary:
+            if not isinstance(dictionary['residentIdNumber'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['residentIdNumber']))
+            value = EmptyValidator()
+            self.resident_id_number = value.from_dictionary(dictionary['residentIdNumber'])
+        if 'termsAndConditions' in dictionary:
+            if not isinstance(dictionary['termsAndConditions'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['termsAndConditions']))
+            value = EmptyValidator()
+            self.terms_and_conditions = value.from_dictionary(dictionary['termsAndConditions'])
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product_filter.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class PaymentProductFilter(DataObject):
+
+    __groups = None
+    __products = None
+
+    @property
+    def groups(self):
+        """
+        | List containing all payment product groups that should either be restricted to in or excluded from the payment context. Currently, there is only one group, called 'cards'.
+
+        Type: list[str]
+        """
+        return self.__groups
+
+    @groups.setter
+    def groups(self, value):
+        self.__groups = value
+
+    @property
+    def products(self):
+        """
+        | List containing all payment product ids that should either be restricted to in or excluded from the payment context.
+
+        Type: list[int]
+        """
+        return self.__products
+
+    @products.setter
+    def products(self, value):
+        self.__products = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProductFilter, self).to_dictionary()
+        if self.groups is not None:
+            dictionary['groups'] = []
+            for element in self.groups:
+                if element is not None:
+                    dictionary['groups'].append(element)
+        if self.products is not None:
+            dictionary['products'] = []
+            for element in self.products:
+                if element is not None:
+                    dictionary['products'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProductFilter, self).from_dictionary(dictionary)
+        if 'groups' in dictionary:
+            if not isinstance(dictionary['groups'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['groups']))
+            self.groups = []
+            for element in dictionary['groups']:
+                self.groups.append(element)
+        if 'products' in dictionary:
+            if not isinstance(dictionary['products'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['products']))
+            self.products = []
+            for element in dictionary['products']:
+                self.products.append(element)
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product_filters_client_session.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.payment_product_filter import PaymentProductFilter
+
+
+class PaymentProductFiltersClientSession(DataObject):
+
+    __exclude = None
+    __restrict_to = None
+
+    @property
+    def exclude(self):
+        """
+        | Contains the payment product ids and payment product groups that should be excluded from the payment products available for the payment. Note that excluding a payment product will ensure exclusion, even if the payment product is also present in the restrictTo filter, and that excluding a payment product group will exclude all payment products that are a part of that group, even if one or more of them are present in the restrictTo filters.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_filter.PaymentProductFilter`
+        """
+        return self.__exclude
+
+    @exclude.setter
+    def exclude(self, value):
+        self.__exclude = value
+
+    @property
+    def restrict_to(self):
+        """
+        | Contains the payment product ids and payment product groups that should be at most contained in the payment products available for completing the payment. Note that the list of payment products available for completing the payment will only contain payment products present in these filters, but not all payment products in these filters might be present in the list. Some of them might not be allowed in context or they might be present in the exclude filters.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_filter.PaymentProductFilter`
+        """
+        return self.__restrict_to
+
+    @restrict_to.setter
+    def restrict_to(self, value):
+        self.__restrict_to = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProductFiltersClientSession, self).to_dictionary()
+        if self.exclude is not None:
+            dictionary['exclude'] = self.exclude.to_dictionary()
+        if self.restrict_to is not None:
+            dictionary['restrictTo'] = self.restrict_to.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProductFiltersClientSession, self).from_dictionary(dictionary)
+        if 'exclude' in dictionary:
+            if not isinstance(dictionary['exclude'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['exclude']))
+            value = PaymentProductFilter()
+            self.exclude = value.from_dictionary(dictionary['exclude'])
+        if 'restrictTo' in dictionary:
+            if not isinstance(dictionary['restrictTo'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['restrictTo']))
+            value = PaymentProductFilter()
+            self.restrict_to = value.from_dictionary(dictionary['restrictTo'])
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product_filters_hosted_checkout.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.payment_product_filter import PaymentProductFilter
+
+
+class PaymentProductFiltersHostedCheckout(DataObject):
+
+    __exclude = None
+    __restrict_to = None
+    __tokens_only = None
+
+    @property
+    def exclude(self):
+        """
+        | Contains the payment product ids and payment product groups that should be excluded from the payment products available for the payment. Note that excluding a payment product will ensure exclusion, even if the payment product is also present in the restrictTo filter, and that excluding a payment product group will exclude all payment products that are a part of that group, even if one or more of them are present in the restrictTo filters.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_filter.PaymentProductFilter`
+        """
+        return self.__exclude
+
+    @exclude.setter
+    def exclude(self, value):
+        self.__exclude = value
+
+    @property
+    def restrict_to(self):
+        """
+        | Contains the payment product ids and payment product groups that should be at most contained in the payment products available for completing the payment. Note that the list of payment products available for completing the payment will only contain payment products present in these filters, but not all payment products in these filters might be present in the list. Some of them might not be allowed in context or they might be present in the exclude filters.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_filter.PaymentProductFilter`
+        """
+        return self.__restrict_to
+
+    @restrict_to.setter
+    def restrict_to(self, value):
+        self.__restrict_to = value
+
+    @property
+    def tokens_only(self):
+        """
+        * true - The customer may only complete the payment using one of the provided accounts on file.
+        * false -The customer can complete the payment using any way they like, as long as it is allowed in the payment context. Default.
+        
+        | Note that the request must contain at least one valid account on file with an allowed payment product (not excluded and allowed in context) if this property is set to true, else the request will fail.
+
+        Type: bool
+        """
+        return self.__tokens_only
+
+    @tokens_only.setter
+    def tokens_only(self, value):
+        self.__tokens_only = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProductFiltersHostedCheckout, self).to_dictionary()
+        if self.exclude is not None:
+            dictionary['exclude'] = self.exclude.to_dictionary()
+        if self.restrict_to is not None:
+            dictionary['restrictTo'] = self.restrict_to.to_dictionary()
+        if self.tokens_only is not None:
+            dictionary['tokensOnly'] = self.tokens_only
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProductFiltersHostedCheckout, self).from_dictionary(dictionary)
+        if 'exclude' in dictionary:
+            if not isinstance(dictionary['exclude'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['exclude']))
+            value = PaymentProductFilter()
+            self.exclude = value.from_dictionary(dictionary['exclude'])
+        if 'restrictTo' in dictionary:
+            if not isinstance(dictionary['restrictTo'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['restrictTo']))
+            value = PaymentProductFilter()
+            self.restrict_to = value.from_dictionary(dictionary['restrictTo'])
+        if 'tokensOnly' in dictionary:
+            self.tokens_only = dictionary['tokensOnly']
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product_group.py

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.account_on_file import AccountOnFile
+from worldline.connect.sdk.v1.domain.payment_product_display_hints import PaymentProductDisplayHints
+from worldline.connect.sdk.v1.domain.payment_product_field import PaymentProductField
+
+
+class PaymentProductGroup(DataObject):
+    """
+    | Definition of the details of a single payment product group
+    """
+
+    __accounts_on_file = None
+    __allows_installments = None
+    __device_fingerprint_enabled = None
+    __display_hints = None
+    __fields = None
+    __id = None
+
+    @property
+    def accounts_on_file(self):
+        """
+        | Only populated in the Client API
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.account_on_file.AccountOnFile`]
+        """
+        return self.__accounts_on_file
+
+    @accounts_on_file.setter
+    def accounts_on_file(self, value):
+        self.__accounts_on_file = value
+
+    @property
+    def allows_installments(self):
+        """
+        | Indicates if the product supports installments
+        
+        * true - This payment supports installments
+        * false - This payment does not support installments
+
+        Type: bool
+        """
+        return self.__allows_installments
+
+    @allows_installments.setter
+    def allows_installments(self, value):
+        self.__allows_installments = value
+
+    @property
+    def device_fingerprint_enabled(self):
+        """
+        | Indicates if device fingerprint is enabled for the product group
+        
+        * true
+        * false
+
+        Type: bool
+        """
+        return self.__device_fingerprint_enabled
+
+    @device_fingerprint_enabled.setter
+    def device_fingerprint_enabled(self, value):
+        self.__device_fingerprint_enabled = value
+
+    @property
+    def display_hints(self):
+        """
+        | Object containing display hints like the order of the group when shown in a list, the name of the group and the logo. Note that the order of the group is the lowest order among the payment products that belong to the group.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_display_hints.PaymentProductDisplayHints`
+        """
+        return self.__display_hints
+
+    @display_hints.setter
+    def display_hints(self, value):
+        self.__display_hints = value
+
+    @property
+    def fields(self):
+        """
+        | Object containing all the fields and their details that are associated with this payment product group. If you are not interested in the these fields you can have us filter them out (using hide=fields in the query-string)
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.payment_product_field.PaymentProductField`]
+        """
+        return self.__fields
+
+    @fields.setter
+    def fields(self, value):
+        self.__fields = value
+
+    @property
+    def id(self):
+        """
+        | The ID of the payment product group in our system
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value):
+        self.__id = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProductGroup, self).to_dictionary()
+        if self.accounts_on_file is not None:
+            dictionary['accountsOnFile'] = []
+            for element in self.accounts_on_file:
+                if element is not None:
+                    dictionary['accountsOnFile'].append(element.to_dictionary())
+        if self.allows_installments is not None:
+            dictionary['allowsInstallments'] = self.allows_installments
+        if self.device_fingerprint_enabled is not None:
+            dictionary['deviceFingerprintEnabled'] = self.device_fingerprint_enabled
+        if self.display_hints is not None:
+            dictionary['displayHints'] = self.display_hints.to_dictionary()
+        if self.fields is not None:
+            dictionary['fields'] = []
+            for element in self.fields:
+                if element is not None:
+                    dictionary['fields'].append(element.to_dictionary())
+        if self.id is not None:
+            dictionary['id'] = self.id
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProductGroup, self).from_dictionary(dictionary)
+        if 'accountsOnFile' in dictionary:
+            if not isinstance(dictionary['accountsOnFile'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['accountsOnFile']))
+            self.accounts_on_file = []
+            for element in dictionary['accountsOnFile']:
+                value = AccountOnFile()
+                self.accounts_on_file.append(value.from_dictionary(element))
+        if 'allowsInstallments' in dictionary:
+            self.allows_installments = dictionary['allowsInstallments']
+        if 'deviceFingerprintEnabled' in dictionary:
+            self.device_fingerprint_enabled = dictionary['deviceFingerprintEnabled']
+        if 'displayHints' in dictionary:
+            if not isinstance(dictionary['displayHints'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['displayHints']))
+            value = PaymentProductDisplayHints()
+            self.display_hints = value.from_dictionary(dictionary['displayHints'])
+        if 'fields' in dictionary:
+            if not isinstance(dictionary['fields'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['fields']))
+            self.fields = []
+            for element in dictionary['fields']:
+                value = PaymentProductField()
+                self.fields.append(value.from_dictionary(element))
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product_group_response.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.payment_product_group import PaymentProductGroup
+
+
+class PaymentProductGroupResponse(PaymentProductGroup):
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProductGroupResponse, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProductGroupResponse, self).from_dictionary(dictionary)
+        return self