[178390751]: address comments 2part

Author: ernestoarbitrio

src/cr/cube/cube.py

@@ -233,48 +233,6 @@ def __repr__(self):
         except Exception:
             return super(Cube, self).__repr__()
 
-    @lazyproperty
-    def alpha_values(self):
-        """Pair (tuple) of confidence-interval thresholds to be used for t-tests.
-
-        The second value is optional and is None when no secondary alpha value was
-        defined for the cube-set.
-        """
-        value = self._transforms_dict.get("pairwise_indices", {}).get("alpha")
-
-        # --- handle omitted, None, [], (), {}, "", 0, and 0.0 cases ---
-        if not value:
-            return (0.05, None)
-
-        # --- reject invalid types ---
-        if not isinstance(value, (float, list, tuple)):
-            raise TypeError(
-                "transforms.pairwise_indices.alpha, when defined, must be a list of 1 "
-                "or 2 float values between 0.0 and 1.0 exclusive. Got %r" % value
-            )
-
-        # --- legacy float "by-itself" case ---
-        if isinstance(value, float):
-            if not 0.0 < value < 1.0:
-                raise ValueError(
-                    "alpha value, when provided, must be between 0.0 and 1.0 "
-                    "exclusive. Got %r" % value
-                )
-            return (value, None)
-
-        # --- sequence case ---
-        for x in value[:2]:
-            if not isinstance(x, float) or not 0.0 < x < 1.0:
-                raise ValueError(
-                    "transforms.pairwise_indices.alpha must be a list of 1 or 2 float "
-                    "values between 0.0 and 1.0 exclusive. Got %r" % value
-                )
-
-        if len(value) == 1:
-            return (value[0], None)
-
-        return tuple(sorted(value[:2]))
-
     @lazyproperty
     def available_measures(self):
         """frozenset of available CUBE_MEASURE members in the cube response."""
@@ -431,21 +389,6 @@ def n_responses(self):
         """Total (int) number of responses considered."""
         return self._cube_response["result"].get("n", 0)
 
-    @lazyproperty
-    def only_larger(self):
-        """True if only the larger of reciprocal pairwise-t values should appear.
-
-        In general, pairwise-t tests are reciprocal. That is, if A is significant with
-        respect to B, then B is significant with respect to A. Having a letter in both
-        columns can produce a cluttered appearance. When this flag is set by the user,
-        only the cell in the reciprocal pair having the largest value gets a letter.
-        Defaults to True unless explicitly set False.
-        """
-        only_larger_value = self._transforms_dict.get("pairwise_indices", {}).get(
-            "only_larger"
-        )
-        return only_larger_value is not False
-
     @lazyproperty
     def overlaps(self):
         """Optional float64 ndarray of cube_overlaps if the measure exists.

src/cr/cube/cubepart.py

@@ -143,26 +143,6 @@ def variable_name(self):
         """str representing the name of the superheading variable."""
         return self._dimensions[0 if self.ndim < 2 else 1].name
 
-    @lazyproperty
-    def _alpha(self):
-        """float confidence-interval threshold for pairwise-t (sig) tests."""
-        # TODO: remove me when summary_pairwise_indices, summary_p_vals and
-        # summary_t_stats will be moved from measures/pairwise_significance.py to
-        # matrix/measures.py
-        return self._cube.alpha_values[0]
-
-    @lazyproperty
-    def _alpha_alt(self):
-        """Alternate float confidence-interval threshold or None.
-
-        This is an optional secondary confidence interval allowing two-level
-        significance testing. Value is None if no alternate alpha was specified by user.
-        """
-        # TODO: remove me when summary_pairwise_indices, summary_p_vals and
-        # summary_t_stats will be moved from measures/pairwise_significance.py to
-        # matrix/measures.py
-        return self._cube.alpha_values[1]
-
     @lazyproperty
     def _available_measures(self):
         """sorted list of available CUBE_MEASURE members in the cube response."""
@@ -183,21 +163,6 @@ def _dimensions(self):
             "must be implemented by each subclass"
         )  # pragma: no cover
 
-    @lazyproperty
-    def _only_larger(self):
-        """True if only the larger of reciprocal pairwise-t values should appear.
-
-        In general, pairwise-t tests are reciprocal. That is, if A is significant with
-        respect to B, then B is significant with respect to A. Having a letter in both
-        columns can produce a cluttered appearance. When this flag is set by the user,
-        only the cell in the reciprocal pair having the largest value gets a letter.
-        Defaults to True unless explicitly set False.
-        """
-        # TODO: remove me when summary_pairwise_indices, summary_p_vals and
-        # summary_t_stats will be moved from measures/pairwise_significance.py to
-        # matrix/measures.py
-        return self._cube.only_larger
-
     @lazyproperty
     def _transforms_dict(self):
         """dict holding transforms for this partition, provided as `transforms` arg.
@@ -1236,6 +1201,26 @@ def zscores(self):
 
     # ---implementation (helpers)-------------------------------------
 
+    @lazyproperty
+    def _alpha(self):
+        """float confidence-interval threshold for pairwise-t (sig) tests."""
+        # TODO: remove me when summary_pairwise_indices, summary_p_vals and
+        # summary_t_stats will be moved from measures/pairwise_significance.py to
+        # matrix/measures.py
+        return self._columns_dimension.pairwise_significance_spec.alpha_values[0]
+
+    @lazyproperty
+    def _alpha_alt(self):
+        """Alternate float confidence-interval threshold or None.
+
+        This is an optional secondary confidence interval allowing two-level
+        significance testing. Value is None if no alternate alpha was specified by user.
+        """
+        # TODO: remove me when summary_pairwise_indices, summary_p_vals and
+        # summary_t_stats will be moved from measures/pairwise_significance.py to
+        # matrix/measures.py
+        return self._columns_dimension.pairwise_significance_spec.alpha_values[1]
+
     @lazyproperty
     def _assembler(self):
         """The Assembler object for this slice.
@@ -1279,6 +1264,21 @@ def _dimensions(self):
             )
         )
 
+    @lazyproperty
+    def _only_larger(self):
+        """True if only the larger of reciprocal pairwise-t values should appear.
+
+        In general, pairwise-t tests are reciprocal. That is, if A is significant with
+        respect to B, then B is significant with respect to A. Having a letter in both
+        columns can produce a cluttered appearance. When this flag is set by the user,
+        only the cell in the reciprocal pair having the largest value gets a letter.
+        Defaults to True unless explicitly set False.
+        """
+        # TODO: remove me when summary_pairwise_indices, summary_p_vals and
+        # summary_t_stats will be moved from measures/pairwise_significance.py to
+        # matrix/measures.py
+        return self._columns_dimension.pairwise_significance_spec.only_larger
+
     @lazyproperty
     def _row_variance(self):
         """2D np.float64 ndarray of row-percentage variance for each cell."""

src/cr/cube/dimension.py

@@ -967,23 +967,84 @@ def __init__(self, dimension, dimension_transforms_dict):
         self._dimension_transforms_dict = dimension_transforms_dict
 
     @lazyproperty
-    def column_idx(self):
+    def alpha_values(self):
+        """Pair (tuple) of confidence-interval thresholds to be used for t-tests.
+
+        The second value is optional and is None when no secondary alpha value was
+        defined for the cube-set.
+        """
+        value = self._pairwise_sig_dict.get("pairwise_indices", {}).get("alpha")
+
+        # --- handle omitted, None, [], (), {}, "", 0, and 0.0 cases ---
+        if not value:
+            return (0.05, None)
+
+        # --- reject invalid types ---
+        if not isinstance(value, (float, list, tuple)):
+            raise TypeError(
+                "transforms.pairwise_indices.alpha, when defined, must be a list of 1 "
+                "or 2 float values between 0.0 and 1.0 exclusive. Got %r" % value
+            )
+
+        # --- legacy float "by-itself" case ---
+        if isinstance(value, float):
+            if not 0.0 < value < 1.0:
+                raise ValueError(
+                    "alpha value, when provided, must be between 0.0 and 1.0 "
+                    "exclusive. Got %r" % value
+                )
+            return (value, None)
+
+        # --- sequence case ---
+        for x in value[:2]:
+            if not isinstance(x, float) or not 0.0 < x < 1.0:
+                raise ValueError(
+                    "transforms.pairwise_indices.alpha must be a list of 1 or 2 float "
+                    "values between 0.0 and 1.0 exclusive. Got %r" % value
+                )
+
+        if len(value) == 1:
+            return (value[0], None)
+
+        return tuple(sorted(value[:2]))
+
+    @lazyproperty
+    def only_larger(self):
+        """True if only the larger of reciprocal pairwise-t values should appear.
+
+        In general, pairwise-t tests are reciprocal. That is, if A is significant with
+        respect to B, then B is significant with respect to A. Having a letter in both
+        columns can produce a cluttered appearance. When this flag is set by the user,
+        only the cell in the reciprocal pair having the largest value gets a letter.
+        Defaults to True unless explicitly set False.
+        """
+        only_larger_value = self._pairwise_sig_dict.get("pairwise_indices", {}).get(
+            "only_larger"
+        )
+        return only_larger_value is not False
+
+    @lazyproperty
+    def reference_column_idx(self):
         """Optional int index of base column as reference for the pairwise sig tests."""
         column_significance = self._pairwise_sig_dict.get("column_significance", {})
         if column_significance is not None:
             return column_significance.get("column_idx")
         return None
 
     @lazyproperty
-    def insertion_idx(self):
+    def reference_insertion_idx(self):
         """Optional int index of insertion column as reference for the sig tests."""
         if self._insertion_id:
             return self._dimension.insertion_ids.index(self._insertion_id)
         return None
 
     @lazyproperty
     def _insertion_id(self):
-        """int insertion-id in the "insertion_id" field of the transform dict."""
+        """int insertion-id in the "insertion_id" field of the transform dict.
+
+        Identifies the reference column when the reference column is an insertion rather
+        than a `base` column.
+        """
         column_significance = self._pairwise_sig_dict.get("column_significance", {})
         if column_significance is not None:
             return column_significance.get("insertion_id")

src/cr/cube/matrix/assembler.py

@@ -373,8 +373,9 @@ def pairwise_selection_idx(self):
         In case of standard column it returns its idx in the column order, for subotals
         idxs are the negative in the column order.
         """
-        insertion_idx = self._columns_dimension.pairwise_significance_spec.insertion_idx
-        column_idx = self._columns_dimension.pairwise_significance_spec.column_idx
+        pairwise_spec = self._columns_dimension.pairwise_significance_spec
+        insertion_idx = pairwise_spec.reference_insertion_idx
+        column_idx = pairwise_spec.reference_column_idx
         column_order = self._column_order.tolist()
         if insertion_idx is not None:
             return column_order.index(~insertion_idx)
@@ -721,7 +722,7 @@ def zscores(self):
     @lazyproperty
     def _alpha(self):
         """float confidence-interval threshold for pairwise-t (sig) tests."""
-        return self._cube.alpha_values[0]
+        return self._columns_dimension.pairwise_significance_spec.alpha_values[0]
 
     @lazyproperty
     def _alpha_alt(self):
@@ -730,7 +731,7 @@ def _alpha_alt(self):
         This is an optional secondary confidence interval allowing two-level
         significance testing. Value is None if no alternate alpha was specified by user.
         """
-        return self._cube.alpha_values[1]
+        return self._columns_dimension.pairwise_significance_spec.alpha_values[1]
 
     def _assemble_marginal(self, marginal):
         """Optional 1D ndarray created from a marginal.
@@ -935,7 +936,7 @@ def _measures(self):
     @lazyproperty
     def _only_larger(self):
         """True if only the larger of reciprocal pairwise-t values should appear."""
-        return self._cube.only_larger
+        return self._columns_dimension.pairwise_significance_spec.only_larger
 
     @lazyproperty
     def _row_order(self):