def test_containment_negative_j_out_of_range(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
i = data.draw(integers())
j = data.draw(integers())
assume(j not in j_range)
catalog = FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
assert (i, j) not in catalog
def test_power_measurement(instrument, data):
channel_id = data.draw(sampled_from(instrument.channel_ids))
channel = instrument.channel(channel_id)
voltage = data.draw(floats(channel.voltage.protection.min, channel.voltage.protection.max).map(lambda v: round(v, 3)))
current = data.draw(floats(channel.current.protection.min, channel.current.protection.max).map(lambda v: round(v, 3)))
instrument._inst._channel_voltage_measurements[channel_id] = voltage
instrument._inst._channel_current_measurements[channel_id] = current
assert channel.power.measurement == round(voltage*current, 3)
def test_key_missing_raises_value_error(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
catalog = FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
value = data.draw(integers())
assume(value not in v_range)
with raises(ValueError):
catalog.key(value)
def test_set_voltage_setpoint_level(instrument, data):
channel_id = data.draw(sampled_from(instrument.channel_ids))
channel = instrument.channel(channel_id)
voltage = data.draw(
floats(channel.voltage.protection.min, channel.voltage.protection.max).map(
lambda v: round(v, 3)))
channel.voltage.setpoint.level = voltage
assert channel.voltage.setpoint.level == voltage
def test_set_voltage_setpoint_step_increment(instrument, data):
channel_id = data.draw(sampled_from(instrument.channel_ids))
channel = instrument.channel(channel_id)
increment = data.draw(
floats(channel.voltage.protection.min, channel.voltage.protection.max).map( # TODO: Experimentally determine maximum
lambda v: round(v, 3)))
channel.voltage.setpoint.step.increment = increment
assert channel.voltage.setpoint.step.increment == increment
def test_out_of_range_key_raises_value_error(self, key_range, data):
value_range = data.draw(ranges(min_size=len(key_range), max_size=len(key_range)))
key = data.draw(integers())
assume(not (key_range.start <= key <= key_range[-1]))
catalog = LinearRegularCatalog(key_range.start, key_range[-1], key_range.step,
value_range.start, value_range[-1], value_range.step)
with raises(KeyError):
catalog[key]
def test_fuzz_fractions_bounds(data):
denom = data.draw(none() | integers(1, 100), label="denominator")
fracs = none() | fractions(max_denominator=denom)
low, high = data.draw(tuples(fracs, fracs), label="low, high")
if low is not None and high is not None and low > high:
low, high = high, low
try:
val = data.draw(fractions(low, high, denom), label="value")
except InvalidArgument:
reject() # fractions too close for given max_denominator
if low is not None:
assert low <= val
if high is not None:
assert val <= high
if denom is not None:
assert 1 <= val.denominator <= denom
def allocate_loadbalancer_ingress(self, data):
"""
Complete the S4 Customer Grid service setup by updating its status to
reflect the existence of a platform-supplied LoadBalancer. This would
happen due to actions taken by Kubernetes for any ``LoadBalancer``
service.
"""
services = [
service
for service
in self.kubernetes._state.services.items
if service.spec.type == u"LoadBalancer"
and service.status is not None
and not service.status.loadBalancer.ingress
]
assume([] != services)
for service in services:
self.kubernetes._state_changed(self.kubernetes._state.replace(
u"services",
service,
service.transform(
[u"status", u"loadBalancer", u"ingress"],
[self.kube_model.v1.LoadBalancerIngress(
hostname=data.draw(domains()),
)],
),
))
def test_struct(data):
_elements = one_of(characters(), integers(), text())
_sets = sets(elements=_elements, min_size=1, average_size=5)
allowed_keys = data.draw(_sets)
keys = list(allowed_keys)
values = data.draw(lists(elements=_elements, min_size=len(keys), max_size=len(keys)))
s = py_tools.Struct(allowed_keys)
for key, value in zip(keys, values):
s[key] = value
assert s[key] == value
assert s == {k: v for k, v in zip(keys, values)}
prohibited_keys = {k for k in data.draw(_sets) if k not in allowed_keys}
for key in prohibited_keys:
with pytest.raises(KeyError):
s[key] = data.draw(_elements)
def test_repr(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
catalog = FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
r = repr(catalog)
assert r.startswith('FirstIndexVariesQuickestCatalog2D')
assert 'i_range={!r}'.format(i_range) in r
assert 'j_range={!r}'.format(j_range) in r
assert 'v_range={!r}'.format(v_range) in r
assert check_balanced(r)
def test_fuzz_decimals_bounds(data):
places = data.draw(none() | integers(0, 20), label='places')
finite_decs = decimals(allow_nan=False, allow_infinity=False,
places=places) | none()
low, high = data.draw(tuples(finite_decs, finite_decs), label='low, high')
if low is not None and high is not None and low > high:
low, high = high, low
ctx = decimal.Context(prec=data.draw(integers(1, 100), label='precision'))
try:
with decimal.localcontext(ctx):
strat = decimals(low, high, allow_nan=False,
allow_infinity=False, places=places)
val = data.draw(strat, label='value')
except InvalidArgument:
reject() # decimals too close for given places
if low is not None:
assert low <= val
if high is not None:
assert val <= high
if places is not None:
assert val.as_tuple().exponent == -places
def test_repr(self, key_range, data):
value_range = data.draw(ranges(min_size=len(key_range), max_size=len(key_range)))
catalog = LinearRegularCatalog(key_range.start, key_range[-1], key_range.step,
value_range.start, value_range[-1], value_range.step)
r = repr(catalog)
assert r.startswith('LinearRegularCatalog')
assert 'key_min={}'.format(catalog._key_min) in r
assert 'key_max={}'.format(catalog._key_max) in r
assert 'key_stride={}'.format(catalog._key_stride) in r
assert 'value_first={}'.format(catalog._value_start) in r
assert 'value_last={}'.format(catalog._value_stop) in r
assert 'value_stride={}'.format(catalog._value_stride) in r
assert check_balanced(r)
def remove_pod(self, data):
"""
An existing customer grid pod goes away, as would happen if a user
cancelled their subscription.
"""
assume(0 < len(self.pods))
pod, values = data.draw(sampled_from(sorted(self.pods.items())))
_, storage_pem, _, intro_pem, _ = values
del self.pods[pod]
self.used_tubs.difference_update({
Tub(storage_pem).getTubID(),
Tub(intro_pem).getTubID(),
})
self.case.successResultOf(self.client.delete(pod))
def test_fuzz_decimals_bounds(data):
places = data.draw(none() | integers(0, 20), label="places")
finite_decs = (decimals(
allow_nan=False, allow_infinity=False, places=places) | none())
low, high = data.draw(tuples(finite_decs, finite_decs), label="low, high")
if low is not None and high is not None and low > high:
low, high = high, low
ctx = decimal.Context(prec=data.draw(integers(1, 100), label="precision"))
try:
with decimal.localcontext(ctx):
strat = decimals(low,
high,
allow_nan=False,
allow_infinity=False,
places=places)
val = data.draw(strat, label="value")
except InvalidArgument:
reject() # decimals too close for given places
if low is not None:
assert low <= val
if high is not None:
assert val <= high
if places is not None:
assert val.as_tuple().exponent == -places
def test_broadcast_elements_gufunc_args(parsed_sig, min_side, max_side, max_dims_extra, dtype, data):
signature = unparse(parsed_sig)
parsed_sig, _ = parsed_sig
excluded = data.draw(sets(integers(0, len(parsed_sig) - 1)).map(tuple))
min_side, max_side = sorted([min_side, max_side])
choices = data.draw(real_from_dtype(dtype))
elements = sampled_from(choices)
S = gu.gufunc_args(
signature,
excluded=excluded,
min_side=min_side,
max_side=max_side,
max_dims_extra=max_dims_extra,
dtype=dtype,
elements=elements,
)
X = data.draw(S)
validate_elements(X, choices=choices, dtype=dtype)
def test_simple(data, seed):
model = data.draw(sampled_from([LinearChainCRF]))
struct = model.struct
torch.manual_seed(seed)
vals, (batch, N) = struct._rand()
lengths = torch.tensor(
[data.draw(integers(min_value=2, max_value=N)) for b in range(batch - 1)] + [N]
)
dist = model(vals, lengths)
edges, enum_lengths = dist.enumerate_support()
print(edges.shape)
log_probs = dist.log_prob(edges)
for b in range(lengths.shape[0]):
log_probs[enum_lengths[b] :, b] = -1e9
assert torch.isclose(log_probs.exp().sum(0), torch.tensor(1.0)).all()
entropy = dist.entropy
assert torch.isclose(entropy, -log_probs.exp().mul(log_probs).sum(0)).all()
argmax = dist.argmax
_, max_indices = log_probs.max(0)
amax = edges[max_indices, torch.arange(batch)]
print(argmax.nonzero())
print((amax - argmax).nonzero(), lengths)
assert (amax == argmax).all()
samples = dist.sample((100,))
marginals = dist.marginals
assert ((samples.mean(0) - marginals).abs() < 0.2).all()
dist.kmax(5)
dist.count
def deactivate(self, data):
identifiers = self.database.list_active_subscription_identifiers()
assume(0 < len(identifiers))
subscription_id = data.draw(sampled_from(sorted(identifiers)))
Message.log(deactivating=subscription_id)
self.database.deactivate_subscription(subscription_id)
# We no longer require that the pods and replicasets belonging to this
# subscription exist since the system is supposed to destroy them if
# there is no corresponding active subscription. We use ``discard``
# because we may be deactivating the subscription before we ever got
# around to creating a Deployment for it (or before the ReplicaSet or
# Pod for the Deployment got created by the system).
self.has_replicaset.discard(subscription_id)
self.has_pod.discard(subscription_id)
def test_numeric_target_to_feature_dicts(
data, n_targets, n_features, min_features_per_target, max_features_per_target
):
assume(min_features_per_target <= n_features)
assume(max_features_per_target <= n_features)
target_to_feature_dict = data.draw(
numeric_target_to_feature_dicts(
n_targets, n_features, min_features_per_target, max_features_per_target
)
)
assert len(target_to_feature_dict) == n_targets
for target, features in target_to_feature_dict.items():
assert max(features) < n_features
assert min(features) >= 0
assert len(set(features)) == len(features)
assert min_features_per_target <= len(features) <= max_features_per_target
def test_fit_target_to_feature_dict_consistent(self, data, X_y, estimator):
X, y = X_y
target_to_feature_dict = data.draw(
numeric_target_to_feature_dicts(n_targets=y.shape[1], n_features=X.shape[1])
)
multi_feature_multi_output_regressor = MultiFeatureMultiOutputRegressor(
estimator
)
multi_feature_multi_output_regressor.fit(
X, y, target_to_features_dict=target_to_feature_dict
)
for i, estimator_ in enumerate(
multi_feature_multi_output_regressor.estimators_
):
expected_n_features = len(target_to_feature_dict[i])
assert len(estimator_.coef_) == expected_n_features
def test_str_target_to_feature_dicts(
data, targets, features, min_features_per_target, max_features_per_target
):
assume(min_features_per_target <= len(targets))
assume(max_features_per_target <= len(features))
target_to_feature_dict = data.draw(
str_target_to_feature_dicts(
targets, features, min_features_per_target, max_features_per_target
)
)
assert len(target_to_feature_dict) == len(targets)
for target, target_features in target_to_feature_dict.items():
assert all([feature in features for feature in target_features])
assert len(set(target_features)) == len(target_features)
assert (
min_features_per_target <= len(target_features) <= max_features_per_target
)
def test_shapes_gufunc_args(parsed_sig_and_size, dtype, unique, data):
parsed_sig, min_side, max_side = parsed_sig_and_size
signature = unparse(parsed_sig)
# We could also test using elements strategy that then requires casting,
# but that would be kind of complicated to come up with compatible combos
elements = from_dtype(np.dtype(dtype))
# Assumes zero broadcast dims by default
S = gu.gufunc_args(signature, min_side=min_side, max_side=max_side, dtype=dtype, elements=elements, unique=unique)
X = data.draw(S)
shapes = [np.shape(xx) for xx in X]
validate_shapes(shapes, parsed_sig[0], min_side, max_side)
validate_elements(X, dtype=dtype, unique=unique)
def test_simple_dataarrays(dims, dtype, sizes, data):
elements = None
min_side, max_side = sizes
S = hxr.simple_dataarrays(dims, dtype, elements, min_side, max_side)
da = data.draw(S)
assert da.dims == tuple(dims)
assert all(ss >= min_side for ss in da.sizes.values())
assert (max_side is None) or all(ss <= max_side
for ss in da.sizes.values())
assert da.dtype == np.dtype(dtype)
for dd in dims:
L = da.coords[dd].values.tolist()
assert all(isinstance(ss, int) for ss in L)
assert L == list(range(len(L)))
def test_parts_from_marginals(data, seed):
# todo: add CKY, DepTree too?
model = data.draw(sampled_from([LinearChain, SemiMarkov]))
struct = model()
torch.manual_seed(seed)
vals, (batch, N) = struct._rand()
edge = model(MaxSemiring).marginals(vals).long()
sequence, extra = model.from_parts(edge)
edge_ = model.to_parts(sequence, extra)
assert (torch.isclose(edge, edge_)).all(), edge - edge_
sequence_, extra_ = model.from_parts(edge_)
assert extra == extra_, (extra, extra_)
assert (torch.isclose(sequence, sequence_)).all(), sequence - sequence_
def test_batching_lengths(model_test, semiring, data):
"Test batching"
gen = Gen(model_test, data, LogSemiring)
model, vals, N, batch = gen.model, gen.vals, gen.N, gen.batch
lengths = torch.tensor(
[data.draw(integers(min_value=2, max_value=N)) for b in range(batch - 1)] + [N]
)
# first way: batched implementation
partition = model(semiring).logpartition(vals, lengths=lengths)[0][0]
# second way: unbatched implementation
for b in range(batch):
vals_b = vals[b:(b + 1), :(lengths[b] - 1)]
lengths_b = lengths[b:(b + 1)]
partition_b = model(semiring).logpartition(vals_b, lengths=lengths_b)[0][0]
assert torch.isclose(partition[b], partition_b).all()
# test _dp_standard
partition_dp_standard = model(semiring)._dp_standard(vals, lengths=lengths)[0][0]
assert torch.isclose(partition, partition_dp_standard).all()
def _test_token_group_operation(
self,
operation,
matches_tokens,
voucher,
num_passes,
now,
random,
data,
):
configless = self.useFixture(
ConfiglessMemoryVoucherStore(
DummyRedeemer(),
lambda: now,
), )
# Make sure there are enough tokens for us to use!
self.assertThat(
configless.redeem(voucher, num_passes),
succeeded(Always()),
)
# Figure out some subset, maybe empty, of passes from the group that
# we will try to operate on.
group_size = data.draw(integers(min_value=0, max_value=num_passes))
indices = range(num_passes)
random.shuffle(indices)
spent_indices = indices[:group_size]
# Get some passes and perform the operation.
pass_factory = SpendingController.for_store(
tokens_to_passes=configless.redeemer.tokens_to_passes,
store=configless.store,
)
group = pass_factory.get(u"message", num_passes)
spent, rest = group.split(spent_indices)
operation(spent)
# Verify the expected outcome of the operation using the supplied
# matcher factory.
self.assertThat(
configless.store,
matches_tokens(num_passes, spent),
)
def random_slice(taken_from, random, data):
"""
Divide ``taken_from`` into two pieces with elements randomly assigned to
one piece or the other.
:param list taken_from: A list of elements to divide. This will be
mutated.
:param random: A ``random`` module-alike.
:param data: A Hypothesis data object for drawing values.
:return: A two-tuple of the two resulting lists.
"""
count = data.draw(integers(min_value=1, max_value=len(taken_from)))
random.shuffle(taken_from)
remaining = taken_from[:-count]
sliced = taken_from[-count:]
return remaining, sliced
def test_partition(resolution, start_date, entry_count, partition_start, data):
log_entries = []
if resolution == "weekly":
partition_start %= 7
if start_date is not None:
for d in range(entry_count):
dl, ul = data.draw(
lists(integers(min_value=0, max_value=2**64 - 1),
min_size=2,
max_size=2))
log_entries.append(
parser.RawEntry(start_date + timedelta(days=d), dl, ul))
if start_date is None:
with pytest.raises(TypeError):
parser._partition(log_entries, resolution)
else:
if resolution == "weekly":
res = parser._partition(log_entries,
resolution,
week_start=partition_start)
assert sum(len(part) for part in res) == entry_count
assert all([len(part) <= 7 for part in res])
for part in res:
if any([
entry.date.weekday() == partition_start
for entry in part
]):
assert (sorted(part, key=lambda e: e.date)
[0].date.weekday() == partition_start)
else:
res = parser._partition(log_entries,
resolution,
month_start=partition_start)
assert sum(len(part) for part in res) == entry_count
for part in res:
if any([entry.date.day == partition_start for entry in part]):
assert (sorted(
part,
key=lambda e: e.date)[0].date.day == partition_start)
def test_complex_always_column_major_general(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
d = {k: v for k, v in zip(((i, j) for j, i in product(j_range, i_range)), v_range)}
# The catalog builder needs to be smart enough to recover the i and j ranges, the base
# value, and the stride from this data.
catalog_builder = CatalogBuilder(d)
catalog = catalog_builder.create()
assert isinstance(catalog, FirstIndexVariesQuickestCatalog2D)
assert catalog.key_min() == (i_range.start, j_range.start)
assert catalog.key_max() == (last(i_range), last(j_range))
assert catalog.value_first() == v_range.start
assert catalog.value_last() == last(v_range)
assert catalog.i_min == i_range.start
assert catalog.i_max == last(i_range)
assert catalog.j_min == j_range.start
assert catalog.j_max == last(j_range)
assert len(catalog) == num_indices
assert all(d[key] == catalog[key] for key in d)
def test_parses(self, data):
"""
Configurations built by the strategy can be parsed.
"""
tempdir = self.useFixture(TempDir())
config_text = data.draw(
tahoe_config_texts(
storage_client_plugins={},
shares=one_of(
just((None, None, None)),
share_parameters(),
),
),
)
note(config_text)
config_from_string(
tempdir.join(b"tahoe.ini"),
b"tub.port",
config_text.encode("utf-8"),
)
def test_unix_times(
data: DataObject,
start_datetime: dt.datetime | None,
end_datetime: dt.datetime | None,
) -> None:
try:
unix = data.draw(
unix_times(start_datetime=start_datetime,
end_datetime=end_datetime))
except InvalidArgument:
assume(False)
else:
assert isinstance(unix, int)
datetime = dt.datetime.fromtimestamp(unix, tz=UTC).replace(tzinfo=None)
buffer = dt.timedelta(seconds=1) # 1 second buffer needed
assert (
((dt.datetime(1970, 1, 1) if start_datetime is None else
start_datetime) - buffer) <= datetime <=
((dt.datetime.now() if end_datetime is None else end_datetime) +
buffer))
def test_structure_simple_from_dict_default(converter, cl_and_vals, data):
"""Test structuring non-nested attrs classes with default value."""
cl, vals = cl_and_vals
obj = cl(*vals)
attrs_with_defaults = [a for a in fields(cl) if a.default is not NOTHING]
to_remove = data.draw(
lists(elements=sampled_from(attrs_with_defaults), unique=True))
for a in to_remove:
if isinstance(a.default, Factory):
setattr(obj, a.name, a.default.factory())
else:
setattr(obj, a.name, a.default)
dumped = asdict(obj)
for a in to_remove:
del dumped[a.name]
assert obj == converter.structure(dumped, cl)
def test_parts_from_marginals(data, seed):
# todo: add CKY, DepTree too?
model = data.draw(sampled_from([CKY_CRF, DepTree]))
struct = model()
torch.manual_seed(seed)
vals, (batch, N) = test_lookup[model]._rand()
vals_jax = struct.resize(np.array(vals.numpy()))
Ns = np.array([N] * vals_jax.shape[0])
edge = model(MaxSemiring).marginals(vals_jax, Ns)
sequence, extra = struct.from_parts(edge)
edge_ = struct.to_parts(sequence, extra, Ns)
print(edge)
print(sequence)
print(edge_)
assert (np.isclose(edge, edge_)).all(), edge - edge_
sequence_, extra_ = struct.from_parts(edge_)
assert (extra == extra_).all(), (extra, extra_)
assert (np.isclose(sequence, sequence_)).all(), sequence - sequence_
def test_bmm(backend, data):
small_ints = integers(min_value=2, max_value=4)
A, B, C, D = (
data.draw(small_ints),
data.draw(small_ints),
data.draw(small_ints),
data.draw(small_ints),
)
a = data.draw(tensors(backend=shared[backend], shape=(D, A, B)))
b = data.draw(tensors(backend=shared[backend], shape=(1, B, C)))
c = a @ b
c2 = ((a.contiguous().view(D, A, B, 1) *
b.contiguous().view(1, 1, B, C)).sum(2).view(D, A, C))
assert_close_tensor(c, c2)
def create_pods(self, data):
"""
Fabricate Pods which warrant existence and which Kubernetes would have
made for us had we actually been using it. This happens automatically
as a consequence of creating an appropriate Deployments (by way of
ReplicaSets).
"""
deployments = list(
deployment
for deployment in self.kubernetes._state.deployments.items
if 0 == len(get_pods(self.kubernetes._state, deployment)))
assume([] != deployments)
addresses = ipv4_addresses()
for deployment in deployments:
self.kubernetes._state_changed(
self.kubernetes._state.create(
u"pods",
derive_pod(self.kube_model, deployment,
data.draw(addresses)),
), )
self.has_pod.add(deployment.metadata.annotations[u"subscription"])
def test_upgrades_run(self, values, data):
"""
``Schema.run_upgrades`` executes all of the statements from the given
``SchemaUpgrade`` instances.
"""
# Pick a version at which to start the database.
current_version = data.draw(
integers(min_value=0, max_value=len(values)),
)
upgrades = list(
# Interpolating into SQL here ... bad form but I don't want to
# hand-code a bunch of unique SQL statements for this test. A
# schema upgrade would normally not have a variable in it like
# this.
SchemaUpgrade(["INSERT INTO [a] ([b]) VALUES ({})".format(value)])
for value
in values
)
schema = Schema(upgrades=upgrades)
db = connect(":memory:")
cursor = db.cursor()
# Create the table we're going to mess with.
cursor.execute("CREATE TABLE [a] ([b] INTEGER)")
# Fast-forward to the state we're going to pretend the database is at.
change_user_version(cursor, lambda old_version: current_version)
# Run whatever upgrades remain appropriate.
schema.run_upgrades(cursor)
cursor.execute("SELECT [b] FROM [a]")
selected_values = list(b for (b,) in cursor.fetchall())
self.assertThat(
selected_values,
Equals(values[current_version:]),
)
def test_mm(backend, data):
small_ints = integers(min_value=2, max_value=4)
A, B, C, D = (
data.draw(small_ints),
data.draw(small_ints),
data.draw(small_ints),
data.draw(small_ints),
)
a = data.draw(tensors(backend=backend, shape=(D, A, B)))
b = data.draw(tensors(backend=backend, shape=(1, B, C)))
c = a @ b
c2 = ((a.contiguous().view(D, A, B, 1) *
b.contiguous().view(1, 1, B, C)).sum(2).view(D, A, C))
for ind in c._tensor.indices():
assert_close(c[ind], c2[ind])
def test_params(data, seed):
model = data.draw(
sampled_from([Alignment, DepTree, SemiMarkov, DepTree, CKY, CKY_CRF]))
struct = model()
torch.manual_seed(seed)
vals, (batch, N) = struct._rand()
if isinstance(vals, tuple):
vals = tuple((v.requires_grad_(True) for v in vals))
else:
vals.requires_grad_(True)
# torch.autograd.set_detect_anomaly(True)
semiring = LogSemiring
alpha = model(semiring).sum(vals)
alpha.sum().backward()
if not isinstance(vals, tuple):
b = vals.grad.detach()
vals.grad.zero_()
alpha = model(semiring).sum(vals, _autograd=False)
alpha.sum().backward()
c = vals.grad.detach()
assert torch.isclose(b, c).all()
def test_dataarrays(dtype, size_dims, size_sides, data):
elements = None
coords_elements = None
min_dims, max_dims = size_dims
min_side, max_side = size_sides
S = hxr.dataarrays(dtype, elements, coords_elements, min_side, max_side,
min_dims, max_dims)
da = data.draw(S)
assert len(da.dims) >= min_dims
assert len(da.dims) <= max_dims
assert all(ss >= min_side for ss in da.sizes.values())
assert (max_side is None) or all(ss <= max_side
for ss in da.sizes.values())
assert da.dtype == np.dtype(dtype)
for dd in da.dims:
L = da.coords[dd].values.tolist()
assert all(isinstance(ss, int) for ss in L)
assert len(set(L)) == len(L)
def test_alignment(data):
model = data.draw(sampled_from([Alignment]))
semiring = data.draw(sampled_from([StdSemiring]))
struct = model(semiring)
vals, (batch, N) = model._rand()
struct = model(semiring,
max_gap=max(3,
abs(vals.shape[1] - vals.shape[2]) + 1))
vals.fill_(1)
alpha = struct.sum(vals)
model = data.draw(sampled_from([Alignment]))
semiring = data.draw(sampled_from([StdSemiring]))
struct = model(semiring)
vals, (batch, N) = model._rand()
vals.fill_(1)
alpha = struct.sum(vals)
count = struct.enumerate(vals)[0]
assert torch.isclose(count, alpha).all()
model = data.draw(sampled_from([Alignment]))
semiring = data.draw(sampled_from([LogSemiring]))
struct = model(semiring)
vals, (batch, N) = model._rand()
alpha = struct.sum(vals)
count = struct.enumerate(vals)[0]
assert torch.isclose(count, alpha).all()
semiring = data.draw(sampled_from([MaxSemiring]))
struct = model(semiring, local=True)
vals, (batch, N) = model._rand()
vals[..., 0] = -2 * vals[..., 0].abs()
vals[..., 1] = vals[..., 1].abs()
vals[..., 2] = -2 * vals[..., 2].abs()
alpha = struct.sum(vals)
count = struct.enumerate(vals)[0]
mx = struct.marginals(vals)
print(alpha, count)
print(mx[0].nonzero())
assert torch.isclose(count, alpha).all()
def test_archive_redundant(self, data):
"""
make sure when archive command is called multiple times for a given
interval it will not create duplicate archives
"""
test_time = datetime(2005, 6, 7)
# generate measurements for a day
day_data = data.draw(self.generate_measurements(test_time))
# create archives for day
out = StringIO()
period_end = test_time + relativedelta(days=1)
period_end = period_end.replace(tzinfo=pytz.UTC)
call_command('archive_measurements',
'day',
period_end=period_end,
stdout=out)
# get number of archives
n_archives = ArchiveDay.objects.filter(
starttime__gte=period_end -
relativedelta(days=1)).filter(starttime__lt=period_end).count()
# call archive again
call_command('archive_measurements',
'day',
period_end=period_end,
stdout=out)
# check that the number of archives didn't change
n_archives2 = ArchiveDay.objects.filter(
starttime__gte=period_end -
relativedelta(days=1)).filter(starttime__lt=period_end).count()
if day_data:
self.assertTrue(n_archives > 0)
self.assertEqual(n_archives, n_archives2)
def test_vars_to_dims_dicts(var_sizes, dim_sizes, data):
min_vars, max_vars = var_sizes
min_dims, max_dims = dim_sizes
S = hxr.vars_to_dims_dicts(min_vars, max_vars, min_dims, max_dims)
D = data.draw(S)
n = len(D)
assert n >= min_vars
assert (max_vars is None) or (n <= max_vars)
assert all(len(dd) >= min_dims for _, dd in D.items())
assert (max_dims is None) or all(
len(dd) <= max_dims for _, dd in D.items())
assert all(all(isinstance(ss, str) for ss in dd) for _, dd in D.items())
if all(len(dd) <= MAX_DIM_LEN for _, dd in D.items()):
ds = xr.Dataset({
vv: xr.DataArray(np.zeros((1, ) * len(dd)), dims=dd)
for vv, dd in D.items()
})
assert set(ds) == set(D.keys())
assert all(ds[vv].dims == tuple(dd) for vv, dd in D.items())
def create_pods(self, data):
"""
Fabricate Pods which warrant existence and which Kubernetes would have
made for us had we actually been using it. This happens automatically
as a consequence of creating an appropriate Deployments (by way of
ReplicaSets).
"""
deployments = list(
deployment
for deployment
in self.kubernetes._state.deployments.items
if 0 == len(get_pods(self.kubernetes._state, deployment))
)
assume([] != deployments)
addresses = ipv4_addresses()
for deployment in deployments:
self.kubernetes._state_changed(
self.kubernetes._state.create(
u"pods",
derive_pod(self.kube_model, deployment, data.draw(addresses)),
),
)
self.has_pod.add(deployment.metadata.annotations[u"subscription"])
def test_kmax(data):
model = data.draw(sampled_from([LinearChain, SemiMarkov, DepTree]))
K = 2
semiring = KMaxSemiring(K)
struct = model(semiring)
vals, (batch, N) = model._rand()
max1 = model(MaxSemiring).sum(vals)
alpha = struct.sum(vals, _raw=True)
assert (alpha[0] == max1).all()
assert (alpha[1] <= max1).all()
topk = struct.marginals(vals, _raw=True)
argmax = model(MaxSemiring).marginals(vals)
assert (topk[0] == argmax).all()
print(topk[0].nonzero(), topk[1].nonzero())
assert (topk[1] != topk[0]).any()
if model != DepTree:
log_probs = model(MaxSemiring).enumerate(vals)[1]
tops = torch.topk(torch.cat(log_probs, dim=0), 5, 0)[0]
assert torch.isclose(struct.score(topk[1], vals), alpha[1]).all()
for k in range(K):
assert (torch.isclose(alpha[k], tops[k])).all()
def test_bcast_tuple_of_arrays(args, data):
"""Now testing broadcasting of tuple_of_arrays, kind of crazy since it uses
gufuncs to test itself. Some awkwardness here since there are a lot of
corner cases when dealing with object types in the numpy extension.
For completeness, should probably right a function like this for the other
functions, but there always just pass dtype, elements, unique to
`_tuple_of_arrays` anyway, so this should be pretty good.
"""
shapes, dtype, elements, unique = args
shapes = shapes.ravel()
# Need to squeeze out due to weird behaviour of object
dtype = np.squeeze(dtype, -1)
elements = np.squeeze(elements, -1)
elements_shape = max(dtype.shape, elements.shape)
dtype_ = np.broadcast_to(dtype, elements_shape)
if elements_shape == ():
elements = from_dtype(dtype_.item())
else:
elements = [from_dtype(dd) for dd in dtype_]
shapes_shape = max(shapes.shape, dtype.shape, elements_shape, unique.shape)
shapes = np.broadcast_to(shapes, shapes_shape)
S = gu._tuple_of_arrays(shapes, dtype, elements=elements, unique=unique)
X = data.draw(S)
assert len(shapes) == len(X)
for spec, drawn in zip(shapes, X):
assert tuple(spec) == np.shape(drawn)
for ii, xx in enumerate(X):
dd = dtype[ii] if dtype.size > 1 else dtype.item()
uu = unique[ii] if unique.size > 1 else unique.item()
validate_elements([xx], dtype=dd, unique=uu)
def test_hostname_labels_long_idn_punycode(self, data):
# type: (SearchStrategy) -> None
"""
hostname_labels() handles case where idna_text() generates text
that encoded to punycode ends up as longer than allowed.
"""
@composite
def mock_idna_text(draw, min_size, max_size):
# type: (DrawCallable, int, int) -> Text
# We want a string that does not exceed max_size, but when
# encoded to punycode, does exceed max_size.
# So use a unicode character that is larger when encoded,
# "á" being a great example, and use it max_size times, which
# will be max_size * 3 in size when encoded.
return u"\N{LATIN SMALL LETTER A WITH ACUTE}" * max_size
with patch("hyperlink.hypothesis.idna_text", mock_idna_text):
label = data.draw(hostname_labels())
try:
check_label(label)
idna_encode(label)
except UnicodeError: # pragma: no cover
raise AssertionError(
"Invalid IDN label: {!r}".format(label))
def test_indexing(data, x):
d = data.draw(dim(x))
i = data.draw(integers(min_value=0, max_value=x.shape[d] - 1))
x2 = x[{d: i}]
assert set(x2.dims) == set(x.dims) - set([d])
ds = data.draw(dims(x))
index = {}
for d in ds:
i = data.draw(integers(min_value=0, max_value=x.shape[d] - 1))
index[d] = i
x2 = x[index]
assert set(x2.dims) == set(x.dims) - set(ds)
ds = data.draw(dims(x))
index = {}
for d in ds:
i = data.draw(integers(min_value=0, max_value=x.shape[d] - 1))
j = data.draw(integers(min_value=i + 1, max_value=x.shape[d]))
index[d] = slice(i, j)
x2 = x[index]
assert set(x2.dims) == set(x.dims)
x[index] = 6
def test_j_min(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
catalog = FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
assert catalog.j_min == j_range.start
def test_v_range_preserved(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
catalog = FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
assert catalog.v_range == v_range
def test_iteration(self, key_range, data):
value_range = data.draw(ranges(min_size=len(key_range), max_size=len(key_range)))
catalog = LinearRegularCatalog(key_range.start, key_range[-1], key_range.step,
value_range.start, value_range[-1], value_range.step)
assert all(k == m for k, m in zip(key_range, iter(catalog)))
def test_containment_positive(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
catalog = FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
assert all((i, j) in catalog for (i, j) in product(i_range, j_range))
def test_mismatched_ranges_raises_value_error(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges())
assume(len(v_range) != num_indices)
with raises(ValueError):
FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
def test_iteration(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
catalog = FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
assert all(a == b for a, b in zip(((i, j) for (j, i) in product(j_range, i_range)), iter(catalog)))
def test_length(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
catalog = FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
assert len(catalog) == num_indices
def test_value_stop(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
catalog = FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
assert catalog.value_last() == last(v_range)
def test_key_max(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
catalog = FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
assert catalog.key_max() == (i_range.stop - i_range.step,
j_range.stop - j_range.step)
def test_key(self, i_range, j_range, data):
num_indices = len(i_range) * len(j_range)
v_range = data.draw(ranges(min_size=num_indices, max_size=num_indices))
catalog = FirstIndexVariesQuickestCatalog2D(i_range, j_range, v_range)
assert all(catalog.key(value) == key for key, value in catalog.items())
def test_get_voltage_setpoint_step_default(instrument, data):
channel_id = data.draw(sampled_from(instrument.channel_ids))
channel = instrument.channel(channel_id)
assert channel.voltage.setpoint.step.default == 0.001
def test_set_current_setpoint_level(instrument, data):
channel_id = data.draw(sampled_from(instrument.channel_ids))
channel = instrument.channel(channel_id)
current = data.draw(floats(channel.current.protection.min, channel.current.protection.max).map(lambda v: round(v, 3)))
channel.current.setpoint.level = current
assert channel.current.setpoint.level == current
def get_example(self, strat, data):
data.draw(strat)
def test_floats_are_in_range(x, y, data):
x, y = sorted((x, y))
assume(x < y)
t = data.draw(floats(x, y))
assert x <= t <= y
