def test_iterable(pvector):
"""
PVectors can be created from iterables even though they can't be len()
hinted.
"""
assert pvector(iter("a")) == pvector(iter("a"))
def _create_diffs_for(current_path, subobj_a, subobj_b):
"""
Computes a series of ``_IDiffChange`` s to turn ``subobj_a`` into
``subobj_b`` assuming that these subobjs are at ``current_path`` inside a
nested pyrsistent object.
:param current_path: An iterable of pyrsistent object describing the path
inside the root pyrsistent object where the other arguments are
located. See ``PMap.transform`` for the format of this sort of path.
:param subobj_a: The desired input sub object.
:param subobj_b: The desired output sub object.
:returns: An iterable of ``_IDiffChange`` s that will turn ``subobj_a``
into ``subobj_b``.
"""
if subobj_a == subobj_b:
return pvector([])
elif type(subobj_a) != type(subobj_b):
return pvector([_Set(path=current_path, value=subobj_b)])
elif isinstance(subobj_a, PClass) and isinstance(subobj_b, PClass):
a_dict = subobj_a._to_dict()
b_dict = subobj_b._to_dict()
return _create_diffs_for_mappings(current_path, a_dict, b_dict)
elif isinstance(subobj_a, PMap) and isinstance(subobj_b, PMap):
return _create_diffs_for_mappings(
current_path, subobj_a, subobj_b)
elif isinstance(subobj_a, PSet) and isinstance(subobj_b, PSet):
return _create_diffs_for_sets(
current_path, subobj_a, subobj_b)
# If the objects are not equal, and there is no intelligent way to recurse
# inside the objects to make a smaller diff, simply set the current path
# to the object in b.
return pvector([_Set(path=current_path, value=subobj_b)])
def run_vector_random_access_performance():
def random_access(o):
result = 0
for x in range(10000):
for y in testdata:
result = o[y]
return result
testdata = [0, 4, 55, 10000, 98763, -2, 30000, 42004, 37289, 100, 2, 999999]
l = range(1000000)
before = time.time()
random_access(l)
print("Random access large list: " + str(time.time() - before))
v = pvector(l)
before = time.time()
random_access(v)
print("Random access large vector: " + str(time.time() - before))
testdata = [0, 4, 17, -2, 3, 7, 8, 11, 1, 13, 18, 10]
l = range(20)
before = time.time()
random_access(l)
print("Random access small list: " + str(time.time() - before))
v = pvector(l)
before = time.time()
random_access(v)
print("Random access small vector: " + str(time.time() - before))
def multiplier(l, cnt):
if not isinstance(l, pvectorc.PVector):
results = list(map(lambda x: wrapper_fn(map_fn)(x[1], x[0], cnt),
enumerate([l] * cnt)))
return pvector(results)
else:
return pvector(list(map(lambda x: multiplier(x, cnt), l)))
def test_is_hashable(pvector):
from collections import Hashable
v = pvector([1, 2, 3])
v2 = pvector([1, 2, 3])
assert hash(v) == hash(v2)
assert isinstance(pvector(), Hashable)
def start_cluster(self, reactor):
# Destroy the box to begin, so that we are guaranteed
# a clean build.
yield run(reactor, ["vagrant", "destroy", "-f"], path=self.vagrant_path.path)
if self.package_source.version:
env = extend_environ(FLOCKER_BOX_VERSION=vagrant_version(self.package_source.version))
else:
env = os.environ
# Boot the VMs
yield run(reactor, ["vagrant", "up"], path=self.vagrant_path.path, env=env)
for node in self.NODE_ADDRESSES:
yield remove_known_host(reactor, node)
nodes = pvector(ManagedNode(address=address, distribution=self.distribution) for address in self.NODE_ADDRESSES)
certificates = Certificates(self.certificates_path)
cluster = Cluster(
all_nodes=pvector(nodes),
control_node=nodes[0],
agent_nodes=nodes,
dataset_backend=self.dataset_backend,
certificates=certificates,
)
returnValue(cluster)
def test_is_hashable(pvector):
from pyrsistent._compat import Hashable
v = pvector([1, 2, 3])
v2 = pvector([1, 2, 3])
assert hash(v) == hash(v2)
assert isinstance(pvector(), Hashable)
def __init__(self, node_addresses, package_source, distribution,
dataset_backend, dataset_backend_configuration):
"""
:param list: A ``list`` of public IP addresses or
``[private_address, public_address]`` lists.
See ``ManagedRunner`` and ``ManagedNode`` for other parameter
documentation.
"""
# Blow up if the list contains mixed types.
[address_type] = set(type(address) for address in node_addresses)
if address_type is list:
# A list of 2 item lists
self._nodes = pvector(
ManagedNode(
address=address,
private_address=private_address,
distribution=distribution
)
for (private_address, address) in node_addresses
)
else:
# A list of strings.
self._nodes = pvector(
ManagedNode(address=address, distribution=distribution)
for address in node_addresses
)
self.package_source = package_source
self.dataset_backend = dataset_backend
self.dataset_backend_configuration = dataset_backend_configuration
def test_delete_slice(pvector):
seq = pvector(range(5))
assert seq.delete(1, 4) == pvector([0, 4])
assert seq.delete(4, 1) == seq
assert seq.delete(0, 1) == pvector([1, 2, 3, 4])
assert seq.delete(6, 8) == seq
assert seq.delete(-1, 1) == seq
assert seq.delete(1, -1) == pvector([0, 4])
def test_evolver_set_followed_by_delete(pvector):
evolver = pvector([1, 2]).evolver()
evolver[1] = 3
assert [evolver[i] for i in range(len(evolver))] == [1, 3]
del evolver[0]
assert evolver.persistent() == pvector([3])
def __init__(self, mat, rows, cols):
target_type = {numpy.dtype('int8'): numpy.dtype('int64'),
numpy.dtype('int16'): numpy.dtype('int64'),
numpy.dtype('int32'): numpy.dtype('int64'),
numpy.dtype('int64'): numpy.dtype('int64'),
numpy.dtype('float16'): numpy.dtype('float32'),
numpy.dtype('float32'): numpy.dtype('float32'),
numpy.dtype('float64'): numpy.dtype('float64')}
self._matrix = mat.astype(target_type[mat.dtype])
self._rows = pvector(rows)
self._columns = pvector(cols)
def finalize_cluster(cluster):
# Make node lists immutable.
return Cluster(
all_nodes=pvector(cluster.all_nodes),
control_node=cluster.node,
agent_nodes=pvector(cluster.agent_nodes),
dataset_backend=cluster.dataset_backend,
default_volume_size=cluster.default_volume_size,
certificates=cluster.certificates,
dataset_backend_config_file=cluster.dataset_backend_config_file,
)
def test_delete_of_non_existing_element(pvector):
e = pvector([1, 2]).evolver()
with pytest.raises(IndexError):
del e[2]
del e[0]
del e[0]
with pytest.raises(IndexError):
del e[0]
assert e.persistent() == pvector()
def test_repeat(pvector):
v = pvector([1, 2])
assert 5 * pvector() is pvector()
assert v is 1 * v
assert 0 * v is pvector()
assert 2 * pvector([1, 2]) == pvector([1, 2, 1, 2])
assert -3 * pvector([1, 2]) is pvector()
def finalize_cluster(cluster):
"""
:param Cluster cluster: Description of the cluster.
:return: Cluster
"""
# Make node lists immutable.
return Cluster(
all_nodes=pvector(cluster.all_nodes),
control_node=cluster.node,
agent_nodes=pvector(cluster.agent_nodes),
dataset_backend=cluster.dataset_backend,
default_volume_size=cluster.default_volume_size,
certificates=cluster.certificates,
dataset_backend_config_file=cluster.dataset_backend_config_file
)
def configured_cluster_for_nodes(
reactor, certificates, nodes, dataset_backend,
dataset_backend_configuration
):
"""
Get a ``Cluster`` with Flocker services running on the right nodes.
:param reactor: The reactor.
:param Certificates certificates: The certificates to install on the cluster.
:param nodes: The ``ManagedNode``s on which to operate.
:param NamedConstant dataset_backend: The ``DatasetBackend`` constant
representing the dataset backend that the nodes will be configured to
use when they are "started".
:param dict dataset_backend_configuration: The backend-specific
configuration the nodes will be given for their dataset backend.
:returns: A ``Deferred`` which fires with ``Cluster`` when it is
configured.
"""
cluster = Cluster(
all_nodes=pvector(nodes),
control_node=nodes[0],
agent_nodes=nodes,
dataset_backend=dataset_backend,
certificates=certificates
)
configuring = perform(
make_dispatcher(reactor),
configure_cluster(cluster, dataset_backend_configuration)
)
configuring.addCallback(lambda ignored: cluster)
return configuring
def _create_diffs_for_sets(current_path, set_a, set_b):
"""
Computes a series of ``_IDiffChange`` s to turn ``set_a`` into ``set_b``
assuming that these sets are at ``current_path`` inside a nested pyrsistent
object.
:param current_path: An iterable of pyrsistent object describing the path
inside the root pyrsistent object where the other arguments are
located. See ``PMap.transform`` for the format of this sort of path.
:param set_a: The desired input set.
:param set_b: The desired output set.
:returns: An iterable of ``_IDiffChange`` s that will turn ``set_a`` into
``set_b``.
"""
resulting_diffs = pvector([]).evolver()
for item in set_a.difference(set_b):
resulting_diffs.append(
_Remove(path=current_path, item=item)
)
for item in set_b.difference(set_a):
resulting_diffs.append(
_Add(path=current_path, item=item)
)
return resulting_diffs.persistent()
def decode(obj):
if isinstance(obj, ExtType):
if obj.code == TYPE_PSET:
unpacked_data = unpackb(obj.data,
use_list=False,
encoding='utf-8')
return pset(decode(item) for item in unpacked_data)
if obj.code == TYPE_PLIST:
unpacked_data = unpackb(obj.data,
use_list=False,
encoding='utf-8')
return plist(decode(item) for item in unpacked_data)
if obj.code == TYPE_PBAG:
unpacked_data = unpackb(obj.data,
use_list=False,
encoding='utf-8')
return pbag(decode(item) for item in unpacked_data)
module_name, class_name, *data = unpackb(obj.data,
use_list=False,
encoding='utf-8')
cls = getattr(sys.modules[module_name],
class_name)
return cls(*(decode(item) for item in data))
if isinstance(obj, tuple):
return pvector(decode(item) for item in obj)
if isinstance(obj, dict):
new_dict = dict()
for key in obj.keys():
new_dict[decode(key)] = decode(obj[key])
return pmap(new_dict)
return obj
def test_random_insert_within_tail(pvector):
seq = pvector([1, 2, 3])
seq2 = seq.set(1, 4)
assert seq2[1] == 4
assert seq[1] == 2
def traverse(structure, leave=Move, flat=pyrsistent.pvector()):
for item in structure:
if isinstance(item, leave):
flat = flat.append(item)
else:
flat = traverse(item, leave, flat)
return flat
def test_pvectors_produced_from_the_same_evolver_do_not_interfere(pvector):
original_list = list(range(40))
v = pvector(original_list)
e = v.evolver()
e.extend([1, 2, 3])
e[2] = 20
e[35] = 350
v1 = e.persistent()
v1_expected = original_list + [1, 2, 3]
v1_expected[2] = 20
v1_expected[35] = 350
e.extend([-1, -2, -3])
e[3] = -30
e[36] = -360
v2 = e.persistent()
v2_expected = v1_expected + [-1, -2, -3]
v2_expected[3] = -30
v2_expected[36] = -360
assert list(v1) == v1_expected
assert list(v2) == v2_expected
def test_multi_level_sequence_from_iterator(pvector):
seq = pvector(iter(range(8000)))
seq2 = seq.append(11)
assert seq[5] == 5
assert seq2[7373] == 7373
assert seq2[8000] == 11
def test_command_line(self):
"""
A container with custom command line is run with those arguments.
"""
external_port = find_free_port()[1]
name = random_name(self)
d = self.start_container(
name, image_name=u"busybox",
# Pass in pvector since this likely to be what caller actually
# passes in:
command_line=pvector([u"sh", u"-c", u"""\
echo -n '#!/bin/sh
echo -n "HTTP/1.1 200 OK\r\n\r\nhi"
' > /tmp/script.sh;
chmod +x /tmp/script.sh;
nc -ll -p 8080 -e /tmp/script.sh
"""]),
ports=[PortMap(internal_port=8080,
external_port=external_port)])
d.addCallback(
lambda ignored: self.request_until_response(external_port))
def started(response):
d = content(response)
d.addCallback(lambda body: self.assertEqual(b"hi", body))
return d
d.addCallback(started)
return d
def test_evolver_simple_update_in_tree(pvector):
v = pvector(range(35))
e = v.evolver()
e[10] = -10
assert e[10] == -10
assert e.persistent()[10] == -10
def test_non_empty_repr(pvector):
v = pvector([1, 2, 3])
assert str(v) == "pvector([1, 2, 3])"
# There's some state that needs to be reset between calls in the native version,
# test that multiple invocations work.
assert str(v) == "pvector([1, 2, 3])"
def test_evolver_delete_by_index(pvector):
e = pvector([1, 2, 3]).evolver()
del e[0]
assert e.persistent() == python_pvector([2, 3])
assert e.append(4).persistent() == python_pvector([2, 3, 4])
def test_empty_initialization(pvector):
seq = pvector()
assert len(seq) == 0
with pytest.raises(IndexError) as error:
x = seq[0]
assert str(error.value) == 'Index out of range: 0'
def test_insert_beyond_end(pvector):
seq = pvector(range(2))
seq2 = seq.assoc(2, 50)
assert seq2[2] == 50
with pytest.raises(IndexError):
seq2.assoc(19, 4)
def read_schedule_json(obj):
# reconstruct schedule information from json
agents = pvector(obj['agents'])
costs = pmap(obj['costs'])
times = pset(map(as_timerange,obj['times']))
forward = pmap({a: pmap({as_timerange(t): int(t['mid'])
for t in obj['meetings'][a] if t['mid'] != -1})
for a in agents})
mids = pset([mid for ts in forward.values() for mid in ts.values()])
# remove the mid 0, which marks an empty meeting (for unavailable times)
if 0 in mids:
mids = mids.remove(0)
# update meetings and their requirements
requirements = pmap({int(mid): pmap({r['type']: read_jsonable_requirement(r)
for r in rs.values()})
for mid,rs in obj['requirements'].iteritems()})
schedule = Schedule(agents=agents,times=times,forward=forward,
requirements=requirements,costs=costs)
new_unsatisfied = schedule.unsatisfied
for mid,rs in schedule.unsatisfied.iteritems():
for rtype in rs:
r = schedule.requirements[mid][rtype]
if r.satisfied(schedule):
new_unsatisfied = _mark_satisfied(new_unsatisfied,r)
elif not r.satisfiable(schedule):
raise RequirementException(r)
schedule.unsatisfied = new_unsatisfied
return schedule
def test_random_insert_outside_tail(pvector):
seq = pvector(range(20000))
seq2 = seq.set(19000, 4)
assert seq2[19000] == 4
assert seq[19000] == 19000
def test_addition(pvector):
v = pvector([1, 2]) + pvector([3, 4])
assert list(v) == [1, 2, 3, 4]
def test_delete_index_out_of_bounds(pvector):
with pytest.raises(IndexError):
pvector([]).delete(0)
with pytest.raises(IndexError):
pvector([]).delete(-1)
def test_access_with_negative_index(pvector):
seq = pvector([1, 2, 3, 4])
assert seq[-1] == 4
assert seq[-4] == 1
def test_compare_lt_gt(pvector):
v1 = pvector([1, 2])
v2 = pvector([1, 2, 3])
assert v1 < v2
assert v2 > v1
def test_slice_identity(pvector):
# Pvector is immutable, no need to make a copy!
seq = pvector(range(10))
assert seq is seq[::]
def test_initialization_with_one_element(pvector):
seq = pvector([3])
assert len(seq) == 1
assert seq[0] == 3
def test_slicing_no_range_but_step(pvector):
seq = pvector(range(10))
seq2 = seq[::2]
assert list(seq2) == [0, 2, 4, 6, 8]
def test_sorted(pvector):
seq = pvector([5, 2, 3, 1])
assert [1, 2, 3, 5] == sorted(seq)
def test_zero_extend(pvector):
the_list = []
seq = pvector()
seq2 = seq.extend(the_list)
assert seq == seq2
def test_transform_nested_vectors(pvector):
x = pvector([1, 2, pvector([3, 4]), 5])
assert x.transform([2, 0], 999) == pvector([1, 2, pvector([999, 4]), 5])
def test_transform_base_case(pvector):
x = pvector([1, 2])
assert x.transform([1], 3) == pvector([1, 3])
def test_transform_zero_key_length(pvector):
x = pvector([1, 2])
assert x.transform([], 3) == 3
def test_slicing_range_with_step(pvector):
seq = pvector(range(100))
seq2 = seq[2:12:3]
assert list(seq2) == [2, 5, 8, 11]
def test_remove_index_out_of_bounds(pvector):
seq = pvector(range(5))
with pytest.raises(ValueError) as err:
seq.remove(5)
assert 'not in' in str(err.value)
def test_slicing_range(pvector):
seq = pvector(range(10))
seq2 = seq[2:4]
assert list(seq2) == [2, 3]
def test_compare_equal_vectors(pvector):
v1 = pvector([1, 2])
v2 = pvector([1, 2])
assert v1 == v2
assert v1 >= v2
assert v1 <= v2
def test_compare_same_vectors(pvector):
v = pvector([1, 2])
assert v == v
assert pvector() == pvector()
def test_compare_different_vectors_different_sizes(pvector):
v1 = pvector([1, 2])
v2 = pvector([1, 2, 3])
assert v1 != v2
def test_slicing_zero_length_range(pvector):
seq = pvector(range(10))
seq2 = seq[2:2]
assert len(seq2) == 0
def test_compare_with_other_type_of_object(pvector):
assert pvector([1, 2]) != 'foo'
def test_empty_repr(pvector):
assert str(pvector()) == "pvector([])"
def test_refuses_to_hash_when_members_are_unhashable(pvector):
v = pvector([1, 2, [1, 2]])
with pytest.raises(TypeError):
hash(v)
def test_index_error_negative(pvector):
with pytest.raises(IndexError):
pvector([1, 2, 3])[-4]
def test_is_sequence(pvector):
from collections import Sequence
assert isinstance(pvector(), Sequence)
def test_remove_first_only(pvector):
seq = pvector([1, 2, 3, 2, 1])
assert seq.remove(2) == pvector([1, 3, 2, 1])
def test_index_error_positive(pvector):
with pytest.raises(IndexError):
pvector([1, 2, 3])[3]
def test_remove(pvector):
seq = pvector(range(5))
assert seq.remove(3) == pvector([0, 1, 2, 4])
def test_delete_index_malformed(pvector):
with pytest.raises(TypeError):
pvector([]).delete('a')
def test_literalish_works():
from pyrsistent import pvector, v
assert v() is pvector()
assert v(1, 2) == pvector([1, 2])
def test_boolean_conversion(pvector):
assert not bool(pvector())
assert bool(pvector([1]))