def test_cat_x_cat_with_hs():
# Test without H&S
transforms = {
"columns_dimension": {"insertions": {}},
"rows_dimension": {"insertions": {}},
}
slice_ = Cube(CR.ECON_BLAME_X_IDEOLOGY_ROW_HS, transforms=transforms).partitions[0]
np.testing.assert_almost_equal(
slice_.columns_scale_mean,
[2.19444444, 2.19230769, 2.26666667, 1.88990826, 1.76363636, 3.85],
)
np.testing.assert_almost_equal(
slice_.rows_scale_mean,
[3.87368421, 2.51767677, 3.38429752, 3.66666667, 4.13235294],
)
# Test with H&S
slice_ = Cube(CR.ECON_BLAME_X_IDEOLOGY_ROW_HS).partitions[0]
np.testing.assert_almost_equal(
slice_.columns_scale_mean,
[2.19444444, 2.19230769, 2.26666667, 1.88990826, 1.76363636, 3.85],
)
np.testing.assert_almost_equal(
slice_.rows_scale_mean,
[3.87368421, 2.51767677, 3.0851689, 3.38429752, 3.66666667, 4.13235294],
)
def test_ca_x_mr():
slice_ = Cube(SM.CA_X_MR).partitions[0]
np.testing.assert_almost_equal(
slice_.columns_scale_mean, [1.29787234, 1.8, 1.48730964, np.nan]
)
assert slice_.rows_scale_mean is None
assert slice_.rows_scale_mean_margin is None
assert slice_.columns_scale_mean_margin == 1.504548211036992
slice_ = Cube(SM.CA_X_MR).partitions[1]
np.testing.assert_almost_equal(
slice_.columns_scale_mean, [3.31746032, 3.10743802, 3.09976976, np.nan]
)
assert slice_.rows_scale_mean is None
slice_ = Cube(SM.CA_X_MR).partitions[2]
np.testing.assert_almost_equal(
slice_.columns_scale_mean, [3.31205674, 3.23913043, 3.37745455, np.nan]
)
assert slice_.rows_scale_mean is None
slice_ = Cube(SM.CA_X_MR).partitions[3]
np.testing.assert_almost_equal(
slice_.columns_scale_mean, [3.53676471, 3.34814815, 3.3147877, np.nan]
)
assert slice_.rows_scale_mean is None
def test_cat_x_cat_pruning_and_hs_var_scale_means():
transforms = {
"columns_dimension": {"insertions": {}},
"rows_dimension": {"insertions": {}},
}
slice_ = Cube(CR.CAT_HS_MT_X_CAT_HS_MT, transforms=transforms).partitions[0]
assert slice_._columns_scale_mean_variance == pytest.approx(
[1.4459092, 2.14619102, 2.40430987, np.nan, 0.87972883], nan_ok=True
)
assert slice_.columns_scale_mean_stddev == pytest.approx(
[1.2024596, 1.4649884, 1.5505837, np.nan, 0.9379386], nan_ok=True
)
assert slice_.rows_scale_mean_stddev == pytest.approx(
[0.8506362, 0.9995499, 1.3697947, 0.6971257, np.nan, 0.8164966], nan_ok=True
)
# Just H&S
slice_ = Cube(CR.CAT_HS_MT_X_CAT_HS_MT).partitions[0]
assert slice_._columns_scale_mean_variance == pytest.approx(
[1.4459092, 1.8494177, 2.14619102, 2.40430987, np.nan, 0.87972883], nan_ok=True
)
assert slice_.columns_scale_mean_stddev == pytest.approx(
[1.2024596, 1.359933, 1.4649884, 1.5505837, np.nan, 0.9379386], nan_ok=True
)
assert slice_.rows_scale_mean_stddev == pytest.approx(
[0.8506362, 1.0412664, 0.9995499, 1.3697947, 0.6971257, np.nan, 0.8164966],
nan_ok=True,
)
# Just pruning
transforms = {
"rows_dimension": {"prune": True},
"columns_dimension": {"prune": True},
}
slice_ = Cube(CR.CAT_HS_MT_X_CAT_HS_MT, transforms=transforms).partitions[0]
assert slice_._columns_scale_mean_variance == pytest.approx(
[1.4459092, 1.8494177, 2.14619102, 2.40430987, 0.87972883]
)
assert slice_.columns_scale_mean_stddev == pytest.approx(
[1.2024596, 1.359933, 1.4649884, 1.5505837, 0.9379386]
)
assert slice_.rows_scale_mean_stddev == pytest.approx(
[0.8506362, 1.0412664, 0.9995499, 1.3697947, 0.6971257, 0.8164966]
)
# Pruning and H&S
transforms = {
"rows_dimension": {"insertions": {}, "prune": True},
"columns_dimension": {"insertions": {}, "prune": True},
}
slice_ = Cube(CR.CAT_HS_MT_X_CAT_HS_MT, transforms=transforms).partitions[0]
assert slice_._columns_scale_mean_variance == pytest.approx(
[1.4459092, 2.14619102, 2.40430987, 0.87972883]
)
assert slice_.columns_scale_mean_stddev == pytest.approx(
[1.2024596, 1.4649884, 1.5505837, 0.9379386]
)
assert slice_.rows_scale_mean_stddev == pytest.approx(
[0.8506362, 0.9995499, 1.3697947, 0.6971257, 0.8164966]
)
def test_univariate_cat_with_hiding():
strand_ = Cube(SM.BOLSHEVIK_HAIR).partitions[0]
np.testing.assert_almost_equal(strand_.scale_std_dev, [1.6012836])
np.testing.assert_almost_equal(strand_.scale_std_err, [0.0394328])
np.testing.assert_almost_equal(strand_.scale_median, [1.0])
# Appling hiding transforms
transforms = {
"rows_dimension": {
"elements": {
"5": {
"hide": True
},
"4": {
"hide": True
}
}
}
}
strand_with_hiding_ = Cube(SM.BOLSHEVIK_HAIR,
transforms=transforms).partitions[0]
np.testing.assert_almost_equal(strand_.scale_std_dev,
strand_with_hiding_.scale_std_dev)
np.testing.assert_almost_equal(strand_.scale_std_err,
strand_with_hiding_.scale_std_err)
np.testing.assert_almost_equal(strand_.scale_median, [1.0])
def it_provides_the_default_repr_when_enhanced_repr_fails(
self, dimension_types_prop_):
dimension_types_prop_.return_value = [1, 2, 3]
cube = Cube(None)
cube_repr = cube.__repr__()
assert cube_repr.startswith("<cr.cube.cube.Cube object at 0x")
def test_cat_x_cat_with_hs():
# Test without H&S
transforms = {
"columns_dimension": {
"insertions": {}
},
"rows_dimension": {
"insertions": {}
},
}
slice_ = Cube(CR.ECON_BLAME_X_IDEOLOGY_ROW_HS,
transforms=transforms).partitions[0]
np.testing.assert_almost_equal(
slice_.rows_scale_mean_stddev,
[0.943031, 0.9677583, 0.9817768, 1.8856181, 1.5987533],
)
np.testing.assert_almost_equal(
slice_.columns_scale_mean_stddev,
[0.7195463, 0.7196963, 0.9977753, 1.0608932, 1.0948414, 1.5740076],
)
np.testing.assert_almost_equal(
slice_.rows_scale_mean_stderr,
[0.0558603, 0.0486317, 0.063111, 0.7698004, 0.1938773],
)
np.testing.assert_almost_equal(
slice_.columns_scale_mean_stderr,
[0.0847993, 0.0533474, 0.0515249, 0.0718528, 0.104389, 0.2488725],
)
np.testing.assert_almost_equal(slice_.columns_scale_median,
[2, 2, 2, 1, 1, 5])
np.testing.assert_almost_equal(slice_.rows_scale_median, [4, 3, 3, 3.5, 4])
assert slice_.columns_scale_median_margin == 2
assert slice_.rows_scale_median_margin == 3
# Test with H&S
slice_ = Cube(CR.ECON_BLAME_X_IDEOLOGY_ROW_HS).partitions[0]
np.testing.assert_almost_equal(
slice_.rows_scale_mean_stddev,
[0.943031, 0.9677583, 1.1680149, 0.9817768, 1.8856181, 1.5987533],
)
np.testing.assert_almost_equal(
slice_.columns_scale_mean_stddev,
[0.7195463, 0.7196963, 0.9977753, 1.0608932, 1.0948414, 1.5740076],
)
np.testing.assert_almost_equal(
slice_.rows_scale_mean_stderr,
[0.0558603, 0.0486317, 0.0447584, 0.063111, 0.7698004, 0.1938773],
)
np.testing.assert_almost_equal(
slice_.columns_scale_mean_stderr,
[0.0847993, 0.0533474, 0.0515249, 0.0718528, 0.104389, 0.2488725],
)
np.testing.assert_almost_equal(slice_.columns_scale_median,
[2, 2, 2, 1, 1, 5])
np.testing.assert_almost_equal(slice_.rows_scale_median,
[4, 3, 3, 3, 3.5, 4])
assert slice_.columns_scale_median_margin == 2
assert slice_.rows_scale_median_margin == 3
def test_means_cat_x_cat_arr_fruit_first():
slice_ = Cube(CR.FRUIT_X_PETS_ARRAY).partitions[0]
assert slice_.columns_scale_mean is None
np.testing.assert_almost_equal(slice_.rows_scale_mean, [1.48, 1.4285714, 1.5217391])
slice_ = Cube(CR.FRUIT_X_PETS_ARRAY).partitions[1]
assert slice_.columns_scale_mean is None
np.testing.assert_almost_equal(
slice_.rows_scale_mean, [1.40740741, 1.53846154, 1.55319149]
)
def test_univariate_cat_with_hiding():
strand_ = Cube(SM.BOLSHEVIK_HAIR).partitions[0]
np.testing.assert_almost_equal(strand_.scale_mean, [1.504548211])
# Appling hiding transforms
transforms = {
"rows_dimension": {"elements": {"5": {"hide": True}, "4": {"hide": True}}}
}
strand_with_hiding_ = Cube(SM.BOLSHEVIK_HAIR, transforms=transforms).partitions[0]
np.testing.assert_almost_equal(strand_.scale_mean, strand_with_hiding_.scale_mean)
def test_ca_x_mr():
slice_ = Cube(SM.CA_X_MR).partitions[0]
np.testing.assert_almost_equal(
slice_.columns_scale_mean_stddev,
[1.43286986, 1.75336411, 1.59143099, np.nan])
np.testing.assert_almost_equal(slice_.columns_scale_mean_stderr,
[0.1206694, 0.1481863, 0.0428554, np.nan])
np.testing.assert_almost_equal(slice_.columns_scale_median,
[1, 1, 1, np.nan])
assert slice_.columns_scale_median_margin == 1
assert slice_.rows_scale_median_margin is None
assert slice_.rows_scale_mean_stddev is None
assert slice_.rows_scale_mean_stderr is None
assert slice_.rows_scale_median is None
slice_ = Cube(SM.CA_X_MR).partitions[1]
np.testing.assert_almost_equal(slice_.columns_scale_mean_stddev,
[2.23837666, 2.32059287, 2.2735136, np.nan])
np.testing.assert_almost_equal(slice_.columns_scale_mean_stderr,
[0.1994104, 0.210963, 0.0629833, np.nan])
np.testing.assert_almost_equal(slice_.columns_scale_median,
[5.0, 5.0, 4.0, np.nan])
assert slice_.columns_scale_median_margin == 5
assert slice_.rows_scale_median_margin is None
assert slice_.rows_scale_mean_stddev is None
assert slice_.rows_scale_mean_stderr is None
assert slice_.rows_scale_median is None
slice_ = Cube(SM.CA_X_MR).partitions[2]
np.testing.assert_almost_equal(
slice_.columns_scale_mean_stddev,
[2.24756685, 2.18544045, 2.17207083, np.nan])
np.testing.assert_almost_equal(slice_.columns_scale_mean_stderr,
[0.1892793, 0.186037, 0.0585764, np.nan])
np.testing.assert_almost_equal(slice_.columns_scale_median,
[5.0, 5.0, 5.0, np.nan])
assert slice_.columns_scale_median_margin == 5
assert slice_.rows_scale_median_margin is None
assert slice_.rows_scale_mean_stddev is None
assert slice_.rows_scale_mean_stderr is None
assert slice_.rows_scale_median is None
slice_ = Cube(SM.CA_X_MR).partitions[3]
np.testing.assert_almost_equal(slice_.columns_scale_mean_stddev,
[2.1892387, 2.2020816, 2.1932015, np.nan])
np.testing.assert_almost_equal(slice_.columns_scale_mean_stderr,
[0.1877257, 0.189525, 0.0593408, np.nan])
np.testing.assert_almost_equal(slice_.columns_scale_median,
[5.0, 5.0, 5.0, np.nan])
assert slice_.columns_scale_median_margin == 5
assert slice_.rows_scale_median_margin is None
assert slice_.rows_scale_mean_stddev is None
assert slice_.rows_scale_mean_stderr is None
assert slice_.rows_scale_median is None
def test_means_cat_x_cat_arr_subvars_first():
slice_ = Cube(CR.FRUIT_X_PETS_ARRAY_SUBVARS_FIRST).partitions[0]
np.testing.assert_almost_equal(
slice_.columns_scale_mean, [1.71111111, 1.6, 1.65625]
)
assert slice_.rows_scale_mean is None
slice_ = Cube(CR.FRUIT_X_PETS_ARRAY_SUBVARS_FIRST).partitions[1]
np.testing.assert_almost_equal(
slice_.columns_scale_mean, [1.64705882, 1.7, 1.68421053]
)
assert slice_.rows_scale_mean is None
def test_mean_univariate_cat_var_scale_mean():
# Test nonmissing with no null numeric values
strand = Cube(SM.UNIVARIATE_CAT).partitions[0]
assert strand.scale_mean == pytest.approx(2.686585)
# Test nonmissing with null numeric value
strand = Cube(SM.UNIVARIATE_CAT_WITH_NULL_NUMERIC_VALUE).partitions[0]
assert strand.scale_mean == pytest.approx(2.744010)
# Test with all null numeric value
strand = Cube(SM.UNIVARIATE_CAT_WITH_ALL_NULL_NUMERIC_VALUE).partitions[0]
assert strand.scale_mean is None
def test_cat_x_cat_pruning_and_hs():
transforms = {
"columns_dimension": {"insertions": {}},
"rows_dimension": {"insertions": {}},
}
slice_ = Cube(CR.CAT_HS_MT_X_CAT_HS_MT, transforms=transforms).partitions[0]
np.testing.assert_almost_equal(
slice_.columns_scale_mean,
[1.57933884, 2.10618401, 2.30460074, np.nan, 2.34680135],
)
np.testing.assert_almost_equal(
slice_.rows_scale_mean,
[1.74213625, 1.97, 2.45356177, 2.11838791, np.nan, 2.0],
)
# Just H&S
slice_ = Cube(CR.CAT_HS_MT_X_CAT_HS_MT).partitions[0]
np.testing.assert_almost_equal(
slice_.columns_scale_mean,
[1.57933884, 1.8308135, 2.10618401, 2.30460074, np.nan, 2.34680135],
),
np.testing.assert_almost_equal(
slice_.rows_scale_mean,
[1.74213625, 2.2364515, 1.97, 2.45356177, 2.11838791, np.nan, 2.0],
)
# Just pruning
transforms = {
"rows_dimension": {"prune": True},
"columns_dimension": {"prune": True},
}
slice_ = Cube(CR.CAT_HS_MT_X_CAT_HS_MT, transforms=transforms).partitions[0]
np.testing.assert_almost_equal(
slice_.columns_scale_mean,
[1.57933884, 1.83081353, 2.10618401, 2.30460074, 2.34680135],
)
np.testing.assert_almost_equal(
slice_.rows_scale_mean,
[1.74213625, 2.2364515, 1.97, 2.45356177, 2.11838791, 2.0],
)
# Pruning and H&S
transforms = {
"rows_dimension": {"insertions": {}, "prune": True},
"columns_dimension": {"insertions": {}, "prune": True},
}
slice_ = Cube(CR.CAT_HS_MT_X_CAT_HS_MT, transforms=transforms).partitions[0]
np.testing.assert_almost_equal(
slice_.columns_scale_mean, [1.57933884, 2.106184, 2.3046007, 2.34680135]
),
np.testing.assert_almost_equal(
slice_.rows_scale_mean, [1.74213625, 1.97, 2.45356177, 2.11838791, 2.0]
)
def test_univariate_with_hs_scale_means_row():
# Test without H&S
transforms = {
"columns_dimension": {"insertions": {}},
"rows_dimension": {"insertions": {}},
}
strand = Cube(CR.ECON_BLAME_WITH_HS, transforms).partitions[0]
assert strand.scale_mean == pytest.approx(2.1735206)
# Test with H&S
strand = Cube(CR.ECON_BLAME_WITH_HS).partitions[0]
assert strand.scale_mean == pytest.approx(2.1735206)
def test_means_cat_x_cat_arr_pets_first():
slice_ = Cube(CR.FRUIT_X_PETS_ARRAY_PETS_FIRST).partitions[0]
np.testing.assert_almost_equal(slice_.columns_scale_mean, [1.48, 1.40740741])
np.testing.assert_almost_equal(slice_.rows_scale_mean, [1.71111111, 1.64705882])
slice_ = Cube(CR.FRUIT_X_PETS_ARRAY_PETS_FIRST).partitions[1]
np.testing.assert_almost_equal(slice_.columns_scale_mean, [1.42857143, 1.53846154])
np.testing.assert_almost_equal(slice_.rows_scale_mean, [1.6, 1.7])
slice_ = Cube(CR.FRUIT_X_PETS_ARRAY_PETS_FIRST).partitions[2]
np.testing.assert_almost_equal(slice_.columns_scale_mean, [1.52173913, 1.55319149])
np.testing.assert_almost_equal(slice_.rows_scale_mean, [1.65625, 1.68421053])
def test_univariate_with_hs():
# Test without H&S
transforms = {
"columns_dimension": {"insertions": {}},
"rows_dimension": {"insertions": {}},
}
strand = Cube(CR.ECON_BLAME_WITH_HS, transforms).partitions[0]
np.testing.assert_almost_equal(strand.scale_mean, [2.17352056])
# Test with H&S
strand = Cube(CR.ECON_BLAME_WITH_HS).partitions[0]
np.testing.assert_almost_equal(strand.scale_mean, [2.17352056])
def test_rows_and_new_rows_scale_mean_stddev_for_fruit_x_pets_array():
slice_ = Cube(CR.FRUIT_X_PETS_ARRAY).partitions[0]
assert slice_._columns_scale_mean_variance is None
assert slice_.rows_scale_mean_stddev == pytest.approx(
[0.4995998, 0.4948717, 0.4995272]
)
slice_ = Cube(CR.FRUIT_X_PETS_ARRAY).partitions[1]
assert slice_.rows_scale_mean_stddev == pytest.approx(
[0.4913518, 0.4985185, 0.4971626]
)
def test_bivariate_cat():
slice_ = Cube(CR.ECON_BLAME_X_IDEOLOGY_ROW_HS).partitions[0]
np.testing.assert_almost_equal(
slice_.columns_scale_mean_stddev,
[0.7195463, 0.7196963, 0.9977753, 1.0608932, 1.0948414, 1.5740076],
)
np.testing.assert_almost_equal(
slice_.columns_scale_mean_stderr,
[0.0847993, 0.0533474, 0.0515249, 0.0718528, 0.104389, 0.2488725],
)
np.testing.assert_almost_equal(
slice_.rows_scale_mean_stddev,
[
0.94303101, 0.96775835, 1.16801487, 0.98177679, 1.88561808,
1.5987533
],
)
np.testing.assert_almost_equal(
slice_.rows_scale_mean_stderr,
[0.0558603, 0.0486317, 0.0447584, 0.063111, 0.7698004, 0.1938773],
)
np.testing.assert_almost_equal(slice_.columns_scale_median,
[2, 2, 2, 1, 1, 5])
np.testing.assert_almost_equal(slice_.rows_scale_median,
[4, 3, 3, 3, 3.5, 4])
assert slice_.columns_scale_median_margin == 2
assert slice_.rows_scale_median_margin == 3
def it_knows_ca_as_0th(
self,
request,
dim_types,
cube_idx,
_is_single_filter_col_cube,
expected_value,
dimension_types_prop_,
):
property_mock(
request,
Cube,
"_is_single_filter_col_cube",
return_value=_is_single_filter_col_cube,
)
dimension_types_prop_.return_value = dim_types
cube = Cube(
response=None,
cube_idx=cube_idx,
transforms=None,
population=None,
mask_size=0,
)
_ca_as_0th = cube._ca_as_0th
assert _ca_as_0th is expected_value
def it_provides_array_for_single_valid_cat_CAT_X_MR(self):
"""No pruning needs to happen, because pruning is based on unweighted counts:
>>> cube.unweighted_counts
array([[[0, 108],
[14, 94],
[94, 14]]])
so even though the weighted counts are all zeroes:
>>> cube.counts
array([[[0, 0],
[0, 0],
[0, 0]]])
we expect [[0, 0, 0]] as the result; no zero gets pruned because no unweighted
count is zero.
"""
transforms = {
"rows_dimension": {
"prune": True
},
"columns_dimension": {
"prune": True
},
}
slice_ = Cube(CR.CAT_X_MR_SENTRY, transforms=transforms).partitions[0]
np.testing.assert_array_equal(slice_.counts, np.array([[0, 0, 0]]))
def it_provides_access_to_its_dimensions(self, cube_response,
expected_dim_types):
cube = Cube(cube_response)
dimension_types = tuple(d.dimension_type for d in cube.dimensions)
assert dimension_types == expected_dim_types
def it_provides_multiple_measures_for_NUM_ARRAY_GROUPED_BY_CAT(self):
cube = Cube(NA.NUM_ARR_MULTI_NUMERIC_MEASURES_GROUPED_BY_CAT)
assert cube.sums.tolist() == [
[183.0, 105.0, 43.0, 31.0],
[230.0, 71.0, 79.0, 123.0],
[25.0, 58.0, 148.0, 72.0],
]
assert cube.means == pytest.approx(
np.array([
[61.0, 52.5, 14.333333, 10.333333],
[76.6666667, 35.5, 26.333333, 41.0],
[8.333333, 29.0, 49.333333, 24.0],
]))
assert cube.covariance == pytest.approx(
np.array([
[
[1623.0, 1107.5, 155.5],
[312.5, -362.5, 400.0],
[217.333333, 124.333333, 11.333333],
[25.333333, 73.0, 12.0],
],
[
[1107.5, 758.333333, 124.166666],
[-362.5, 420.5, -464.0],
[124.333333, 134.333333, -189.666666],
[73.0, 937.0, -639.5],
],
[
[155.5, 124.166666, 140.333333],
[400.0, -464.0, 512.0],
[11.333333, -189.666666, 609.333333],
[12.0, -639.5, 631.0],
],
]))
def crtabs(dataset,
variables,
weight=None,
filter_=None,
transforms=None,
**measures):
"""Return Cube representation of crosstab.
:param dataset: Dataset instance
:param variables: List of variable urls, aliases or Variable instances
:param weight: Scrunch variable instance, alias or url
:param filter_: Scrunch filter expression
:param transforms: cr.cube transforms dictionary
"""
variables = [variable_to_url(var, dataset) for var in variables]
if weight is not None:
weight = variable_to_url(weight, dataset)
if filter_ is not None:
filter_ = process_expr(parse_expr(filter_), dataset.resource)
return Cube(
fetch_cube(dataset.resource,
variables,
count=count(),
weight=weight,
filter=filter_,
**measures),
transforms=transforms,
)
def test_ca_items_x_cat():
slice_ = Cube(SM.CA_ITEMS_X_CAT).partitions[0]
assert slice_.columns_scale_mean is None
np.testing.assert_almost_equal(
slice_.rows_scale_mean, [1.50454821, 3.11233766, 3.35788192, 3.33271833]
)
assert slice_.columns_scale_mean_margin is None
def it_provides_stddev_for_numeric_array_with_no_grouping(self):
"""Test stddev on no-dimensions measure of numeric array."""
strand = Cube(NA.NUM_ARR_STDDEV_NO_GROUPING).partitions[0]
assert strand.stddev == pytest.approx([2.5819889, 3.51188458, 2.12132034])
assert strand.unweighted_counts.tolist() == [4, 3, 2]
assert strand.unweighted_bases.tolist() == [4, 3, 2]
assert strand.table_base_range.tolist() == [2, 4]
def test_univariate_ca_subvar_with_empty_total_counts():
strand = Cube(SM.UNIVARIATE_CA_SUBVAR).partitions[0]
# --- scale_meanm, scale_std_dev and scale_std_err can be None when
# --- _total_weighted_count is 0.
assert strand.scale_mean is None
assert strand.scale_std_dev is None
assert strand.scale_std_err is None
def it_provides_share_of_sum_for_numeric_array_with_no_grouping(self):
strand = Cube(NA.NUM_ARR_SUM_NO_GROUPING).partitions[0]
assert strand.sums == pytest.approx([25, 44])
assert strand.share_sum == pytest.approx([0.3623188, 0.6376811])
assert strand.unweighted_counts.tolist() == [6, 6]
assert strand.unweighted_bases.tolist() == [6, 6]
assert strand.table_base_range.tolist() == [6, 6]
def it_provides_unweighted_valid_counts_for_num_array_x_mr(self):
slice_ = Cube(NA.NUM_ARR_MEANS_X_MR).partitions[0]
# unweighted valid counts
assert slice_.unweighted_counts.tolist() == [
[38.0, 14.0, 6.0, 18.0, 38.0],
[38.0, 14.0, 6.0, 18.0, 38.0],
]
def but_it_returns_None_when_numeric_subvars_is_empty(
self, _numeric_subvariables_prop_):
_numeric_subvariables_prop_.return_value = []
cube = Cube(None)
_num_array_dimensions = cube._numeric_array_dimension
assert _num_array_dimensions is None
def it_knows_its_numeric_references(self, _cube_response_prop_,
cube_response, expected_value):
_cube_response_prop_.return_value = cube_response
cube = Cube(None)
numeric_references = cube._numeric_measure_references
assert numeric_references == expected_value
def test_ca_itmes_x_cat_var_scale_means():
# These 2 fixtures represent 1 dataset and its transpose version
slice_ = Cube(SM.CA_ITEMS_X_CAT).partitions[0]
slice2_ = Cube(SM.CA_CAT_X_ITEMS).partitions[0]
# Testing that the scale means (row and col) are equal on the 2 diverse
# datasets
assert slice_.rows_scale_mean_stddev == pytest.approx(
slice2_.columns_scale_mean_stddev
)
assert slice2_._columns_scale_mean_variance == pytest.approx(
[2.56410909, 5.17893869, 4.75445248, 4.81611278],
)
assert slice2_.rows_scale_mean_stddev is None
assert slice_.columns_scale_mean_stddev is None