def __init__(self): super(GetNewAddressesRequestFilter, self).__init__( { # Everything except ``seed`` is optional. 'checksum': f.Type(bool) | f.Optional(default=False), 'count': f.Type(int) | f.Min(1), 'index': f.Type(int) | f.Min(0) | f.Optional(default=0), 'securityLevel': f.Type(int) | f.Min(1) | f.Max(self.MAX_SECURITY_LEVEL) | f.Optional(default=AddressGenerator.DEFAULT_SECURITY_LEVEL), 'seed': f.Required | Trytes(result_type=Seed), }, allow_missing_keys={ 'checksum', 'count', 'index', 'securityLevel', }, )
def __init__(self): super(SendTransferRequestFilter, self).__init__( { # Required parameters. 'depth': f.Required | f.Type(int) | f.Min(1), 'seed': f.Required | Trytes(result_type=Seed), # Loosely-validated; testnet nodes require a different value # than mainnet. 'minWeightMagnitude': f.Required | f.Type(int) | f.Min(1), 'transfers': (f.Required | f.Array | f.FilterRepeater(f.Required | f.Type(ProposedTransaction))), # Optional parameters. 'changeAddress': Trytes(result_type=Address), # Note that ``inputs`` is allowed to be an empty array. 'inputs': f.Array | f.FilterRepeater(f.Required | Trytes(result_type=Address)), }, allow_missing_keys={ 'changeAddress', 'inputs', }, )
def __init__(self): super(GetPrivateKeysRequestFilter, self).__init__( { # Optional Parameters 'count': f.Type(int) | f.Min(1) | f.Optional(default=1), 'index': f.Type(int) | f.Min(0) | f.Optional(default=0), 'securityLevel': f.Type(int) | f.Min(1) | f.Optional(default=AddressGenerator.DEFAULT_SECURITY_LEVEL), # Required Parameters 'seed': f.Required | Trytes(result_type=Seed), }, allow_missing_keys={ 'count', 'index', 'securityLevel', }, )
def __init__(self): super(PromoteTransactionRequestFilter, self).__init__({ 'depth': f.Required | f.Type(int) | f.Min(1), 'transaction': f.Required | Trytes(TransactionHash), # Loosely-validated; testnet nodes require a different value # than mainnet. 'minWeightMagnitude': f.Required | f.Type(int) | f.Min(1), })
def __init__(self): super(ReplayBundleRequestFilter, self).__init__({ 'depth': f.Required | f.Type(int) | f.Min(1), 'transaction': f.Required | Trytes(result_type=TransactionHash), # Loosely-validated; testnet nodes require a different value than # mainnet. 'minWeightMagnitude': f.Required | f.Type(int) | f.Min(1), })
def __init__(self): super(GetNewAddressesRequestFilter, self).__init__( { # ``count`` and ``index`` are optional. 'count': f.Type(int) | f.Min(1), 'index': f.Type(int) | f.Min(0) | f.Optional(default=0), 'seed': f.Required | Trytes(result_type=Seed), }, allow_missing_keys={ 'count', 'index', }, )
def __init__(self): super(SendTrytesRequestFilter, self).__init__({ 'depth': f.Required | f.Type(int) | f.Min(1), 'trytes': f.Required | f.Array | f.FilterRepeater(f.Required | Trytes(result_type=TransactionTrytes)), # Loosely-validated; testnet nodes require a different value than # mainnet. 'minWeightMagnitude': f.Required | f.Type(int) | f.Min(1), })
def __init__(self): super(PrepareMultisigTransferRequestFilter, self).__init__( { 'changeAddress': Trytes(Address), 'multisigInput': f.Required | f.Type(MultisigAddress), 'transfers': f.Required | f.Array | f.FilterRepeater(f.Required | f.Type(ProposedTransaction), ), }, allow_missing_keys={ 'changeAddress', }, )
def __init__(self): super(IsReattachableResponseFilter, self).__init__({ 'reattachable': ( f.Required | f.Array | f.FilterRepeater(f.Type(bool))) })
def __init__(self) -> None: super(GetAccountDataRequestFilter, self).__init__( { # Required parameters. 'seed': f.Required | Trytes(Seed), # Optional parameters. 'stop': f.Type(int) | f.Min(0), 'start': f.Type(int) | f.Min(0) | f.Optional(0), 'inclusionStates': f.Type(bool) | f.Optional(False), 'security_level': SecurityLevel }, allow_missing_keys={ 'stop', 'start', 'inclusionStates', 'security_level' }, )
def __init__(self): super(PrepareTransferRequestFilter, self).__init__( { # Required parameters. 'seed': f.Required | Trytes(result_type=Seed), 'transfers': (f.Required | f.Array | f.FilterRepeater(f.Required | f.Type(ProposedTransaction))), # Optional parameters. 'changeAddress': Trytes(result_type=Address), 'securityLevel': SecurityLevel, # Note that ``inputs`` is allowed to be an empty array. 'inputs': f.Array | f.FilterRepeater(f.Required | GeneratedAddress), }, allow_missing_keys={ 'changeAddress', 'inputs', 'securityLevel', }, )
def __init__(self): super(GetInputsRequestFilter, self).__init__( { # These arguments are optional. 'stop': f.Type(int) | f.Min(0), 'start': f.Type(int) | f.Min(0) | f.Optional(0), 'threshold': f.Type(int) | f.Min(0), # These arguments are required. 'seed': f.Required | Trytes(result_type=Seed), }, allow_missing_keys={ 'stop', 'start', 'threshold', })
def __init__(self): super(GetNewAddressesRequestFilter, self).__init__( { # Everything except ``seed`` is optional. 'checksum': f.Type(bool) | f.Optional(default=False), 'count': f.Type(int) | f.Min(1), 'index': f.Type(int) | f.Min(0) | f.Optional(default=0), 'securityLevel': SecurityLevel, 'seed': f.Required | Trytes(Seed), }, allow_missing_keys={ 'checksum', 'count', 'index', 'securityLevel', }, )
def __init__(self): super(GetAccountDataRequestFilter, self).__init__( { # Required parameters. 'seed': f.Required | Trytes(result_type=Seed), # Optional parameters. 'stop': f.Type(int) | f.Min(0), 'start': f.Type(int) | f.Min(0) | f.Optional(0), 'inclusionStates': f.Type(bool) | f.Optional(False), }, allow_missing_keys={ 'stop', 'inclusionStates', 'start', }, )
def __init__(self) -> None: super(GetDigestsRequestFilter, self).__init__( { # Optional Parameters 'count': f.Type(int) | f.Min(1) | f.Optional(default=1), 'index': f.Type(int) | f.Min(0) | f.Optional(default=0), 'securityLevel': SecurityLevel, # Required Parameters 'seed': f.Required | Trytes(Seed), }, allow_missing_keys={ 'count', 'index', 'securityLevel', }, )
def __init__(self) -> None: super(GetTransfersRequestFilter, self).__init__( { # Required parameters. 'seed': f.Required | Trytes(Seed), # Optional parameters. 'stop': f.Type(int) | f.Min(0), 'start': f.Type(int) | f.Min(0) | f.Optional(0), 'inclusionStates': f.Type(bool) | f.Optional(False), }, allow_missing_keys={ 'stop', 'inclusionStates', 'start', }, )
def SecurityLevel(): """ Generates a filter chain for validating a security level. :return: :py:class:`filters.FilterChain` object. """ return (f.Type(int) | f.Min(1) | f.Max(3) | f.Optional(default=AddressGenerator.DEFAULT_SECURITY_LEVEL))
def __init__( self, filter_map, allow_missing_keys=False, allow_extra_keys=False, ): super(RequestFilter, self).__init__( f.Type(Mapping) | f.FilterMapper(filter_map, allow_missing_keys, allow_extra_keys))
def __init__( self, filter_map, allow_missing_keys=True, allow_extra_keys=True, ): super(ResponseFilter, self).__init__( f.Type(Mapping) | f.FilterMapper(filter_map, allow_missing_keys, allow_extra_keys))
def __init__(self): super(GetTransactionsToApproveRequestFilter, self).__init__( { 'depth': f.Required | f.Type(int) | f.Min(1), 'reference': Trytes(result_type=TransactionHash), }, allow_missing_keys={ 'reference', })
def _apply(self, value): value = self._filter(value, f.Type(Address)) # type: Address if self._has_errors: return None if value.key_index is None: return self._invalid_value(value, self.CODE_NO_KEY_INDEX) return value
def __init__(self) -> None: super(SendTrytesRequestFilter, self).__init__( { 'depth': f.Required | f.Type(int) | f.Min(1), 'trytes': f.Required | f.Array | f.FilterRepeater(f.Required | Trytes(TransactionTrytes), ), # Loosely-validated; devnet nodes require a different value # than mainnet. 'minWeightMagnitude': f.Required | f.Type(int) | f.Min(1), 'reference': Trytes(TransactionHash), }, allow_missing_keys={ 'reference', })
def _apply(self, value): value = self._filter(value, f.Type(text_type)) # type: Text if self._has_errors: return None parsed = compat.urllib_parse.urlparse(value) if parsed.scheme not in self.SCHEMES: return self._invalid_value(value, self.CODE_NOT_NODE_URI) return value
def _apply(self, value): value = self._filter(value, f.Type(Address)) # type: Address if self._has_errors: return None if value.key_index is None: return self._invalid_value(value, self.CODE_NO_KEY_INDEX) if value.security_level is None: return self._invalid_value(value, self.CODE_NO_SECURITY_LEVEL) return value
def __init__(self): super(GetBalancesRequestFilter, self).__init__( { 'addresses': f.Required | f.Array | f.FilterRepeater( f.Required | AddressNoChecksum() | f.Unicode(encoding='ascii', normalize=False), ), 'threshold': f.Type(int) | f.Min(0) | f.Max(100) | f.Optional(default=100), }, allow_missing_keys={ 'threshold', }, )
def __init__(self): super(AttachToTangleRequestFilter, self).__init__({ 'branchTransaction': f.Required | Trytes(TransactionHash), 'trunkTransaction': f.Required | Trytes(TransactionHash), 'trytes': f.Required | f.Array | f.FilterRepeater( f.Required | Trytes(result_type=TransactionTrytes), ), # Loosely-validated; testnet nodes require a different value # than mainnet. 'minWeightMagnitude': f.Required | f.Type(int) | f.Min(1), })
def __init__(self): super(GetBalancesRequestFilter, self).__init__( { 'addresses': (f.Required | f.Array | f.FilterRepeater(f.Required | Trytes(result_type=Address))), 'threshold': (f.Type(int) | f.Min(0) | f.Max(100) | f.Optional(default=100)), }, allow_missing_keys={ 'threshold', }, )
def _run(self, context): # type: (TaskContext) -> Optional[Mapping] params =\ context.filter_kwargs({ 'retries': { 'max': f.Type(int) | f.Optional(default=self.max_retries) | f.Min(1), }, }) if self.request.retries < params['retries']['max']: raise self.retry() return {'count': self.request.retries}
def _apply(self, value): # noinspection PyTypeChecker value = self._filter( filter_chain=f.Type( (binary_type, bytearray, text_type, TryteString) ), value=value, ) # type: TrytesCompatible if self._has_errors: return None # If the incoming value already has the correct type, then we're # done. if isinstance(value, self.result_type): return value # First convert to a generic TryteString, to make sure that the # sequence doesn't contain any invalid characters. try: value = TryteString(value) except ValueError: return self._invalid_value( value=value, reason=self.CODE_NOT_TRYTES, exc_info=True, ) if self.result_type is TryteString: return value # Now coerce to the expected type and verify that there are no # type-specific errors. try: return self.result_type(value) except ValueError: return self._invalid_value( value=value, reason=self.CODE_WRONG_FORMAT, exc_info=True, template_vars={ 'result_type': self.result_type.__name__, }, )
def test_repeaterception(self): """ FilterRepeaters can contain other FilterRepeaters. """ self.filter_type = lambda: ( # Apply the following filters to each item in the incoming # value: f.FilterRepeater( # 1. It must be a list. f.Type(list) # 2. Apply the Int filter to each of its items. | f.FilterRepeater(f.Int) # 3. It must have a length <= 3. | f.MaxLength(3) ) ) self.assertFilterPasses( # # Note that the INCOMING VALUE ITSELF does not have to be a # list, nor does it have to have a max length <= 3. # # These Filters are applied to the items INSIDE THE # INCOMING VALUE (because of the outer FilterRepeater). # { 'foo': ['1', '2', '3'], 'bar': [-20, 20], 'baz': ['486'], 'luhrmann': [None, None, None], }, { 'foo': [1, 2, 3], 'bar': [-20, 20], 'baz': [486], 'luhrmann': [None, None, None], }, ) # The 1st item in this value is not a list, so it fails. self.assertFilterErrors( [ [42], {'arch': 486}, ], { '1': [f.Type.CODE_WRONG_TYPE], }, expected_value = [[42], None], ) # The 1st item in this value contains invalid ints. self.assertFilterErrors( [ [42], ['NaN', 3.14, 'FOO'], ], { # # The error keys are the dotted paths to the invalid # values (in this case, they are numeric because we # are working with lists). # # This way, we don't have to deal with nested dicts # when processing error codes. # '1.0': [f.Decimal.CODE_NON_FINITE], '1.1': [f.Int.CODE_DECIMAL], '1.2': [f.Decimal.CODE_INVALID], }, expected_value = [[42], [None, None, None]], ) # The 1st item in this value is too long. self.assertFilterErrors( [ [42], [1, 2, 3, 4] ], { '1': [f.MaxLength.CODE_TOO_LONG], }, expected_value = [[42], None] )