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(FindTransactionsRequestFilter, self).__init__(
{
'addresses':
(f.Array
| f.FilterRepeater(
f.Required
| AddressNoChecksum()
| f.Unicode(encoding='ascii', normalize=False))),
'approvees':
(f.Array
| f.FilterRepeater(
f.Required
| Trytes(result_type=TransactionHash)
| f.Unicode(encoding='ascii', normalize=False))),
'bundles':
(f.Array
| f.FilterRepeater(
f.Required
| Trytes(result_type=TransactionHash)
| f.Unicode(encoding='ascii', normalize=False))),
'tags': (f.Array
| f.FilterRepeater(
f.Required
| Trytes(result_type=Tag)
| f.Unicode(encoding='ascii', normalize=False))),
},
# Technically, all of the parameters for this command are
# optional, so long as at least one of them is present and not
# empty.
allow_missing_keys=True,
)
def __init__(self):
super(FindTransactionsRequestFilter, self).__init__(
{
'addresses':
(f.Array
| f.FilterRepeater(f.Required | Trytes(result_type=Address))
| f.Optional(default=[])),
'approvees':
(f.Array
| f.FilterRepeater(f.Required
| Trytes(result_type=TransactionHash))
| f.Optional(default=[])),
'bundles':
(f.Array
| f.FilterRepeater(f.Required
| Trytes(result_type=TransactionHash))
| f.Optional(default=[])),
'tags':
(f.Array
| f.FilterRepeater(f.Required | Trytes(result_type=Tag))
| f.Optional(default=[])),
},
# Technically, all of the parameters for this command are
# optional, so long as at least one of them is present and not
# empty.
allow_missing_keys=True,
)
def __init__(self):
super(GetInclusionStatesRequestFilter, self).__init__(
{
# Required parameters.
'transactions': (
f.Required
| f.Array
| f.FilterRepeater(
f.Required
| Trytes(result_type=TransactionHash)
| f.Unicode(encoding='ascii', normalize=False)
)
),
# Optional parameters.
'tips': (
f.Array
| f.FilterRepeater(
f.Required
| Trytes(result_type=TransactionHash)
| f.Unicode(encoding='ascii', normalize=False)
)
| f.Optional(default=[])
),
},
allow_missing_keys = {
'tips',
},
)
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) -> None:
super(GetBalancesResponseFilter, self).__init__({
'balances':
f.Array | f.FilterRepeater(f.Int),
'references':
f.Array | f.FilterRepeater(
f.ByteString(encoding='ascii') | Trytes(TransactionHash)),
})
def test_repeater_chained_with_repeater(self):
"""
Chaining two FilterRepeaters together has basically the same
effect as combining their Filters, except for one very
important difference: The two sets of Filters are applied
in sequence.
That is, the second set of Filters only get applied if ALL
of the Filters in the first set pass!
Generally, combining two FilterRepeaters into a single instance
is much easier to read/maintain than chaining them, but
should you ever come across a situation where you need to
apply two FilterRepeaters in sequence, you can do so.
"""
self.filter_type = \
lambda: f.FilterRepeater(f.NotEmpty) | f.FilterRepeater(
f.Int)
# The values in this list pass through both FilterRepeaters
# successfully.
self.assertFilterPasses(
['1', 2, 0, None, '-12'],
[1, 2, 0, None, -12],
)
# The values in this list fail one or more Filters in each
# FilterRepeater.
self.assertFilterErrors(
['', 'NaN', 0, None, 'FOO'],
{
# Fails the NotEmpty filter in the first FilterRepeater.
'0': [f.NotEmpty.CODE_EMPTY],
# IMPORTANT: Because the first FilterRepeater had one
# or more errors, the outer FilterChain stopped.
# # Fails the Int filter in the second FilterRepeater.
# '1': [f.Decimal.CODE_NON_FINITE],
# '4': [f.Int.CODE_INVALID],
},
# The result is the same as if we only ran the value
# through the first FilterRepeater.
expected_value=[None, 'NaN', 0, None, 'FOO'])
# The values in this list pass the first FilterRepeater but
# fail the second one.
self.assertFilterErrors(
['1', 'NaN', 0, None, 'FOO'],
{
'1': [f.Decimal.CODE_NON_FINITE],
'4': [f.Decimal.CODE_INVALID],
},
expected_value=[1, None, 0, None, None],
)
def __init__(self):
super(AttachToTangleResponseFilter, self).__init__({
'trytes':
f.FilterRepeater(
f.ByteString(encoding='ascii')
| Trytes(result_type=TransactionTrytes)),
})
def __init__(self) -> None:
super(FindTransactionsResponseFilter, self).__init__({
'hashes':
f.FilterRepeater(
f.ByteString(encoding='ascii') | Trytes(TransactionHash))
| f.Optional(default=[]),
})
def __init__(self):
super(GetTipsResponseFilter, self).__init__({
'hashes': (f.Array
| f.FilterRepeater(
f.ByteString(encoding='ascii')
| Trytes(result_type=TransactionHash))),
})
def __init__(self) -> None:
super(CheckConsistencyRequestFilter, self).__init__({
'tails':
f.Required |
f.Array |
f.FilterRepeater(f.Required | Trytes(TransactionHash)),
})
def __init__(self):
super(IsPromotableRequestFilter, self).__init__({
'tails':
f.Required |
f.Array |
f.FilterRepeater(f.Required | Trytes(TransactionHash)),
})
def __init__(self):
super(StoreTransactionsRequestFilter, self).__init__({
'trytes':
f.Required
| f.Array
| f.FilterRepeater(f.Required | Trytes(result_type=TransactionTrytes)),
})
def __init__(self):
super(WereAddressesSpentFromRequestFilter, self).__init__({
'addresses':
f.Required | f.Array | f.FilterRepeater(
f.Required | AddressNoChecksum()
| f.Unicode(encoding='ascii', normalize=False), ),
})
def __init__(self):
super(GetLatestInclusionRequestFilter, self).__init__({
'hashes':
f.Required | f.Array | f.FilterRepeater(
f.Required | Trytes(TransactionHash),
),
})
def __init__(self) -> None:
super(GetBundlesRequestFilter, self).__init__({
'transactions':
f.Required | f.Array | f.FilterRepeater(
f.Required | Trytes(TransactionHash)
)
})
def __init__(self):
super(StoreTransactionsRequestFilter, self).__init__({
'trytes':
f.Required | f.Array | f.FilterRepeater(
f.Required | Trytes(TransactionTrytes)
| f.Unicode(encoding='ascii', normalize=False), ),
})
def test_restrict_keys(self):
"""
A FilterRepeated is configured to restrict allowed keys in a
mapping.
"""
self.filter_type = lambda: f.FilterRepeater(
filter_chain =f.Int,
restrict_keys = {'ducks', 'sea otters'},
)
# As long as you stick to the expected keys, everything's
# hunky-dory.
self.assertFilterPasses(
{'ducks': '3', 'sea otters': '4'},
{'ducks': 3, 'sea otters': 4},
)
# However, should you deviate from the marked path, we cannot
# be held responsible for the consequences.
self.assertFilterErrors(
# Charlie shot first!
{'ducks': '3', 'hawks': '4'},
{
'hawks': [f.FilterRepeater.CODE_EXTRA_KEY],
},
# Invalid keys are not included in the filtered value.
# This is very similar to how FilterMapper works.
expected_value = {
'ducks': 3,
}
)
def __init__(self):
super(BroadcastTransactionsRequestFilter, self).__init__({
'trytes':
f.Required | f.Array |
f.FilterRepeater(f.Required | Trytes(result_type=TransactionTrytes)
| f.Unicode(encoding='ascii', normalize=False)),
})
def __init__(self):
super(CreateMultisigAddressRequestFilter, self).__init__({
'digests':
f.Required
| f.Array
| f.FilterRepeater(f.Required | Trytes(result_type=Digest)),
})
def test_fail_mapping(self):
"""
A FilterRepeater is applied to a dict that contains invalid
values.
"""
self.filter_type = lambda: f.FilterRepeater(f.NotEmpty | f.Int)
self.assertFilterErrors(
{
# First element is valid (control group).
# The rest fail miserably.
'foo': 4,
'bar': 'NaN',
'baz': 3.14,
'luhrmann': 'FOO',
},
{
'bar': [f.Decimal.CODE_NON_FINITE],
'baz': [f.Int.CODE_DECIMAL],
'luhrmann': [f.Decimal.CODE_INVALID],
},
# Just as with collections, the invalid values in the
# filtered value are replaced with `None`.
expected_value = {
'foo': 4,
'bar': None,
'baz': None,
'luhrmann': None,
},
)
def __init__(self):
super(GetBalancesResponseFilter, self).__init__({
'balances':
f.Array | f.FilterRepeater(f.Int),
'milestone':
f.ByteString(encoding='ascii') | Trytes(result_type=Address),
})
def StringifiedTrytesArray(trytes_type=TryteString):
# type: (Type[TryteString]) -> f.FilterChain
"""
Validates that the incoming value is an array containing tryte
strings corresponding to the specified type (e.g.,
``TransactionHash``).
When a value doesn't pass the filter, a ``ValueError`` is raised with lots
of contextual info attached to it.
:param TryteString result_type:
Any subclass of :py:class:`~iota.TryteString` that you want the filter
to validate.
:return:
:py:class:`filters.FilterChain` object.
.. important::
This filter will return string values, suitable for inclusion in
an API request. If you are expecting objects (e.g.,
:py:class:`Address`), then this is not the filter to use!
.. note::
This filter will allow empty arrays and `None`. If this is not
desirable, chain this filter with ``f.NotEmpty`` or
``f.Required``, respectively.
"""
return f.Array | f.FilterRepeater(
f.Required | Trytes(trytes_type)
| f.Unicode(encoding='ascii', normalize=False), )
def __init__(self):
super(IsReattachableResponseFilter, self).__init__({
'reattachable': (
f.Required
| f.Array
| f.FilterRepeater(f.Type(bool)))
})
def test_fail_non_iterable_value(self):
"""
A FilterRepeater will reject any non-iterable value it comes
across (except for `None`).
"""
self.filter_type = lambda: f.FilterRepeater(f.Int)
self.assertFilterErrors(42, [f.Type.CODE_WRONG_TYPE])
def __init__(self):
super(CheckConsistencyRequestFilter, self).__init__({
'tails': (
f.Required
| f.Array
| f.FilterRepeater(f.Required | Trytes(result_type=TransactionHash))
),
})
def __init__(self):
super(IsReattachableRequestFilter, self).__init__(
{
'addresses':
f.Required | f.Array | f.FilterRepeater(
f.Required | Trytes(Address)
| f.Unicode(encoding='ascii', normalize=False), ),
}, )
def __init__(self) -> None:
super(AttachToTangleResponseFilter, self).__init__({
'trytes':
f.FilterRepeater(
f.ByteString(encoding='ascii') |
Trytes(TransactionTrytes),
),
})
def __init__(self):
super(GetTrytesRequestFilter, self).__init__({
'hashes':
(f.Required
| f.Array
| f.FilterRepeater(f.Required
| Trytes(result_type=TransactionHash))),
})
def test_pass_none(self):
"""
For consistency with all the other Filter classes, `None` is
considered a valid value to pass to a FilterRepeater, even
though it is not iterable.
"""
self.filter_type = lambda: f.FilterRepeater(f.Int)
self.assertFilterPasses(None)
