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]
)
