1862640369

Build Type

github

Committed by GitHub

Commit Message

Merge 1df0f4dbd into 0de070d67

Pull Request Pull Request #166: Autocompute `AmbiguousAssignOrExtract` as extract

Run Details

3338 of 3369 branches covered (99.08%)

Branch coverage included in aggregate %.

467 of 518 new or added lines in 20 files covered. (90.15%)

1 existing line in 1 file now uncovered.

13620 of 13673 relevant lines covered (99.61%)

4.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.09

/grblas/expr.py

import numpy as np

from . import lib, utils
from .dtypes import _INDEX
from .utils import _CArray, output_type


class _AllIndices:
    __slots__ = "_carg", "name", "_expr_name"

    def __init__(self):
        self._carg = lib.GrB_ALL
        self.name = "GrB_ALL"
        self._expr_name = ":"

    def __reduce__(self):
        return "_ALL_INDICES"


_ALL_INDICES = _AllIndices()


class AxisIndex:
    __slots__ = "size", "index", "cscalar", "dimsize"

    def __init__(self, size, index, cscalar, dimsize):
        self.size = size
        self.index = index
        self.cscalar = cscalar
        self.dimsize = dimsize

    @property
    def _carg(self):
        return self.index._carg

    @property
    def name(self):
        return self.index.name

    @property
    def _expr_name(self):
        if self.size is None:
            return f"{self.index.value}"
        idx = self._py_index()
        if type(idx) is slice:
            rv = f"{'' if idx.start is None else idx.start}:{'' if idx.stop is None else idx.stop}"
            if idx.step is not None:
                return f"{rv}:{idx.step}"
            return rv
        if idx.size < 6:
            return f"[{', '.join(map(str, idx))}]"
        else:
            return f"[{', '.join(map(str, idx[:3]))}, ...]"

    def _py_index(self):
        """Convert resolved index back into a valid Python index"""
        if self.size is None:
            return self.index.value
        if self.index is _ALL_INDICES:
            return slice(None)
        from ._slice import gxb_backwards, gxb_range, gxb_stride

        if self.cscalar is gxb_backwards:
            start, stop, step = self.index.array.tolist()
            size = self.dimsize
            stop -= size + 1
            step = -step
        elif self.cscalar is gxb_range:
            start, stop = self.index.array.tolist()
            step = None
            stop += 1
        elif self.cscalar is gxb_stride:
            start, stop, step = self.index.array.tolist()
            stop += 1
        else:
            return self.index.array
        if (
            start == 0
            and (step is None or step > 0)
            or start == self.dimsize - 1
            and step is not None
            and step < 0
        ):
            start = None
        if (
            stop == self.dimsize
            and (step is None or step > 0)
            or stop == -self.dimsize - 1
            and step is not None
            and step < 0
        ):
            stop = None
        return slice(start, stop, step)


class IndexerResolver:
    __slots__ = "obj", "indices", "shape", "__weakref__"

    def __init__(self, obj, indices):
        self.obj = obj
        if indices is Ellipsis:
            from .scalar import _as_scalar
            from .vector import Vector

            if type(obj) is Vector:
                self.indices = [
                    AxisIndex(
                        obj._size,
                        _ALL_INDICES,
                        _as_scalar(obj._size, _INDEX, is_cscalar=True),
                        obj._size,
                    )
                ]
                self.shape = (obj._size,)
            else:
                self.indices = [
                    AxisIndex(
                        obj._nrows,
                        _ALL_INDICES,
                        _as_scalar(obj._nrows, _INDEX, is_cscalar=True),
                        obj._nrows,
                    ),
                    AxisIndex(
                        obj._ncols,
                        _ALL_INDICES,
                        _as_scalar(obj._ncols, _INDEX, is_cscalar=True),
                        obj._ncols,
                    ),
                ]
                self.shape = (obj._nrows, obj._ncols)
        else:
            self.indices = self.parse_indices(indices, obj.shape)
            self.shape = tuple(index.size for index in self.indices if index.size is not None)

    @property
    def is_single_element(self):
        return not self.shape

    @property
    def py_indices(self):
        if self.obj.ndim > 1:
            return tuple(index._py_index() for index in self.indices)
        return self.indices[0]._py_index()

    def parse_indices(self, indices, shape):
        """
        Returns
            [(rows, rowsize), (cols, colsize)] for Matrix
            [(idx, idx_size)] for Vector

        Within each tuple, if the index is of type int, the size will be None
        """
        if len(shape) == 1:
            if type(indices) is tuple:
                raise TypeError(f"Index for {type(self.obj).__name__} cannot be a tuple")
            # Convert to tuple for consistent processing
            indices = (indices,)
        else:  # len(shape) == 2
            if type(indices) is not tuple or len(indices) != 2:
                raise TypeError(f"Index for {type(self.obj).__name__} must be a 2-tuple")

        out = []
        for i, idx in enumerate(indices):
            typ = output_type(idx)
            if typ is tuple:
                raise TypeError(
                    f"Index in position {i} cannot be a tuple; must use slice or list or int"
                )
            out.append(self.parse_index(idx, typ, shape[i]))
        return out

    def parse_index(self, index, typ, size):
        from .scalar import _as_scalar

        if np.issubdtype(typ, np.integer):
            if index >= size:
                raise IndexError(f"Index out of range: index={index}, size={size}")
            if np.issubdtype(typ, np.signedinteger) and index < 0:
                index = index + size
                if index < 0:
                    raise IndexError(f"Index out of range: index={index - size}, size={size}")
            return AxisIndex(None, _as_scalar(int(index), _INDEX, is_cscalar=True), None, size)
        if typ is list:
            pass
        elif typ is slice:
            from ._slice import slice_to_index

            return slice_to_index(index, size)

        elif typ is np.ndarray:
            if len(index.shape) != 1:
                raise TypeError(f"Invalid number of dimensions for index: {len(index.shape)}")
            if not np.issubdtype(index.dtype, np.integer):
                raise TypeError(f"Invalid dtype for index: {index.dtype}")
            if np.issubdtype(index.dtype, np.signedinteger):
                is_negative = index < 0
                if is_negative.any():
                    index = np.where(is_negative, index + size, index)
                    if (index < 0).any():
                        bad_index = index[index < 0][0] - size
                        raise IndexError(f"Index out of range: index={bad_index}, size={size}")
            return AxisIndex(
                len(index), _CArray(index), _as_scalar(len(index), _INDEX, is_cscalar=True), size
            )
        else:
            from .scalar import Scalar

            if typ is Scalar:
                if not np.issubdtype(index.dtype.np_type, np.integer):
                    raise TypeError(f"An integer is required for indexing.  Got: {index.dtype}")
                value = int(index)
                if np.issubdtype(index.dtype.np_type, np.signedinteger) and value < 0:
                    value = value + size
                    if value < 0:
                        raise IndexError(f"Index out of range: index={value - size}, size={size}")
                return AxisIndex(None, _as_scalar(value, _INDEX, is_cscalar=True), None, size)

            from .matrix import Matrix, TransposedMatrix
            from .vector import Vector

            if typ is Vector or typ is Matrix:
                raise TypeError(
                    f"Invalid type for index: {typ.__name__}.\n"
                    f"If you want to apply a mask, perhaps do something like "
                    f"`x.dup(mask={index.name}.S)`.\n"
                    f"If you want to assign with a mask, perhaps do something like "
                    f"`x(mask={index.name}.S) << value`."
                )
            elif typ is TransposedMatrix:
                raise TypeError(f"Invalid type for index: {typ.__name__}.")
            try:
                index = list(index)
            except Exception:
                from .mask import Mask

                if isinstance(index, Mask):
                    raise TypeError(
                        f"Invalid type for index: {typ.__name__}.\n"
                        f"If you want to apply a mask, perhaps do something like "
                        f"`x.dup(mask={index.name})`.\n"
                        f"If you want to assign with a mask, perhaps do something like "
                        f"`x(mask={index.name}) << value`."
                    )
                raise TypeError(f"Invalid type for index: {typ}; unable to convert to list")
        return self.parse_index(np.array(index), np.ndarray, size)

    def get_index(self, dim):
        """Return a new IndexerResolver with index for the selected dimension"""
        rv = object.__new__(IndexerResolver)
        rv.obj = self.obj
        rv.indices = (self.indices[dim],)
        return rv


class Assigner:
    __slots__ = "updater", "resolved_indexes", "is_submask", "__weakref__"

    def __init__(self, updater, resolved_indexes, *, is_submask):
        # We could check here whether mask dimensions match index dimensions.
        # We could also check for valid `updater.kwargs` if `resolved_indexes.is_single_element`.
        self.updater = updater
        self.resolved_indexes = resolved_indexes
        self.is_submask = is_submask
        if updater.kwargs.get("input_mask") is not None:
            raise TypeError("`input_mask` argument may only be used for extract")

    def update(self, obj):
        # Occurs when user calls `C[index](...).update(obj)` or `C(...)[index].update(obj)`
        self.updater._setitem(self.resolved_indexes, obj, is_submask=self.is_submask)

    def __lshift__(self, obj):
        # Occurs when user calls `C[index](...) << obj` or `C(...)[index] << obj`
        self.updater._setitem(self.resolved_indexes, obj, is_submask=self.is_submask)

    def __eq__(self, other):
        raise TypeError(f"__eq__ not defined for objects of type {type(self)}.")

    def __bool__(self):
        raise TypeError(f"__bool__ not defined for objects of type {type(self)}.")


class AmbiguousAssignOrExtract:
    __slots__ = "parent", "resolved_indexes", "_value", "__weakref__"
    _is_scalar = False

    def __init__(self, parent, resolved_indexes):
        self.parent = parent
        self.resolved_indexes = resolved_indexes
        self._value = None

    def __call__(self, *args, **kwargs):
        # Occurs when user calls `C[index](params)`
        # Reverse the call order so we can parse the call args and kwargs
        updater = self.parent(*args, **kwargs)
        is_submask = updater.kwargs.get("mask") is not None
        return Assigner(updater, self.resolved_indexes, is_submask=is_submask)

    def __lshift__(self, obj):
        # Occurs when user calls `C[index] << obj`
        self.update(obj)

    def update(self, obj):
        # Occurs when user calls `C[index].update(obj)`
        if getattr(self.parent, "_is_transposed", False):
            raise TypeError("'TransposedMatrix' object does not support item assignment")
        Updater(self.parent)._setitem(self.resolved_indexes, obj, is_submask=False)

    def new(self, dtype=None, *, mask=None, input_mask=None, name=None):
        """
        Force extraction of the indexes into a new object
        dtype and mask are the only controllable parameters.
        """
        if input_mask is not None:
            if mask is not None:
                raise TypeError("mask and input_mask arguments cannot both be given")
            from .base import _check_mask

            _check_mask(input_mask, output=self.parent)
            mask = self._input_mask_to_mask(input_mask)
        delayed_extractor = self.parent._prep_for_extract(self.resolved_indexes)
        return delayed_extractor.new(dtype, mask=mask, name=name)

    dup = new

    def _extract_delayed(self):
        """Return an Expression object, treating this as an extract call"""
        return self.parent._prep_for_extract(self.resolved_indexes)

    def _input_mask_to_mask(self, input_mask):
        from .vector import Vector

        if type(input_mask.mask) is Vector and type(self.parent) is not Vector:
            rowidx, colidx = self.resolved_indexes.indices
            if rowidx.size is None:
                if self.parent._ncols != input_mask.mask._size:
                    raise ValueError(
                        "Size of `input_mask` Vector does not match ncols of Matrix:\n"
                        f"{self.parent.name}.ncols != {input_mask.mask.name}.size  -->  "
                        f"{self.parent._ncols} != {input_mask.mask._size}"
                    )
                mask_expr = input_mask.mask._prep_for_extract(self.resolved_indexes.get_index(1))
            elif colidx.size is None:
                if self.parent._nrows != input_mask.mask._size:
                    raise ValueError(
                        "Size of `input_mask` Vector does not match nrows of Matrix:\n"
                        f"{self.parent.name}.nrows != {input_mask.mask.name}.size  -->  "
                        f"{self.parent._nrows} != {input_mask.mask._size}"
                    )
                mask_expr = input_mask.mask._prep_for_extract(self.resolved_indexes.get_index(0))
            else:
                raise TypeError(
                    "Got Vector `input_mask` when extracting a submatrix from a Matrix.  "
                    "Vector `input_mask` with a Matrix (or TransposedMatrix) input is "
                    "only valid when extracting from a single row or column."
                )
        elif input_mask.mask.shape != self.parent.shape:
            if type(self.parent) is Vector:
                attr = "size"
                shape1 = self.parent._size
                shape2 = input_mask.mask._size
            else:
                attr = "shape"
                shape1 = self.parent.shape
                shape2 = input_mask.mask.shape
            raise ValueError(
                f"{attr.capitalize()} of `input_mask` does not match {attr} of input:\n"
                f"{self.parent.name}.{attr} != {input_mask.mask.name}.{attr}  -->  "
                f"{shape1} != {shape2}"
            )
        else:
            mask_expr = input_mask.mask._prep_for_extract(self.resolved_indexes)
        mask_value = mask_expr.new(name="mask_temp")
        return type(input_mask)(mask_value)

    def _repr_html_(self):
        from . import formatting

        return formatting.format_index_expression_html(self)

    def __repr__(self):
        from . import formatting

        return formatting.format_index_expression(self)

    @property
    def dtype(self):
        return self.parent.dtype


class Updater:
    __slots__ = "parent", "kwargs", "__weakref__"

    def __init__(self, parent, **kwargs):
        self.parent = parent
        self.kwargs = kwargs

    def __getitem__(self, keys):
        # Occurs when user calls `C(params)[index]`
        # Need something prepared to receive `<<` or `.update()`
        if self.parent._is_scalar:
            raise TypeError("Indexing not supported for Scalars")
        resolved_indexes = IndexerResolver(self.parent, keys)
        return Assigner(self, resolved_indexes, is_submask=False)

    def _setitem(self, resolved_indexes, obj, *, is_submask):
        # Occurs when user calls C(params)[index] = expr
        if resolved_indexes.is_single_element and not self.kwargs:
            # Fast path using assignElement
            self.parent._assign_element(resolved_indexes, obj)
        else:
            mask = self.kwargs.get("mask")
            expr = self.parent._prep_for_assign(
                resolved_indexes, obj, mask=mask, is_submask=is_submask
            )
            self.update(expr)

    def __setitem__(self, keys, obj):
        if self.parent._is_scalar:
            raise TypeError("Indexing not supported for Scalars")
        resolved_indexes = IndexerResolver(self.parent, keys)
        self._setitem(resolved_indexes, obj, is_submask=False)

    def __delitem__(self, keys):
        # Occurs when user calls `del C(params)[index]`
        if self.parent._is_scalar:
            raise TypeError("Indexing not supported for Scalars")
        resolved_indexes = IndexerResolver(self.parent, keys)
        if resolved_indexes.is_single_element:
            self.parent._delete_element(resolved_indexes)
        else:
            # Delete selection by assigning an empty scalar
            from .scalar import Scalar

            scalar = Scalar.new(
                self.parent.dtype, is_cscalar=False, name="s_empty"  # pragma: is_grbscalar
            )
            self._setitem(resolved_indexes, scalar, is_submask=False)

    def __lshift__(self, expr):
        # Occurs when user calls `C(params) << expr`
        self.parent._update(expr, **self.kwargs)

    def update(self, expr):
        # Occurs when user calls `C(params).update(expr)`
        self.parent._update(expr, **self.kwargs)

    def __eq__(self, other):
        raise TypeError(f"__eq__ not defined for objects of type {type(self)}.")

    def __bool__(self):
        raise TypeError(f"__bool__ not defined for objects of type {type(self)}.")


class InfixExprBase:
    __slots__ = "left", "right", "_value", "__weakref__"
    _is_scalar = False

    def __init__(self, left, right):
        self.left = left
        self.right = right
        self._value = None

    def new(self, dtype=None, *, mask=None, name=None):
        if (
            mask is None
            and self._value is not None
            and (dtype is None or self._value.dtype == dtype)
        ):
            rv = self._value
            if name is not None:
                rv.name = name
            self._value = None
            return rv
        expr = self._to_expr()
        return expr.new(dtype, mask=mask, name=name)

    dup = new

    def _to_expr(self):
        if self._value is None:
            # Rely on the default operator for `x @ y`
            self._value = getattr(self.left, self.method_name)(self.right)
        return self._value

    def _get_value(self, attr=None, default=None):
        expr = self._to_expr()
        return expr._get_value(attr=attr, default=default)

    def _format_expr(self):
        return f"{self.left.name} {self._infix} {self.right.name}"

    def _format_expr_html(self):
        return f"{self.left._name_html} {self._infix} {self.right._name_html}"

    def _repr_html_(self):
        from . import formatting

        if self.output_type.__name__ == "VectorExpression":
            return formatting.format_vector_infix_expression_html(self)
        elif self.output_type.__name__ == "MatrixExpression":
            return formatting.format_matrix_infix_expression_html(self)
        return formatting.format_scalar_infix_expression_html(self)

    def __repr__(self):
        from . import formatting

        if self.output_type.__name__ == "VectorExpression":
            return formatting.format_vector_infix_expression(self)
        elif self.output_type.__name__ == "MatrixExpression":
            return formatting.format_matrix_infix_expression(self)
        return formatting.format_scalar_infix_expression(self)

    @property
    def dtype(self):
        if self._value is not None:
            return self._value.dtype
        return self._to_expr().dtype


# Mistakes
utils._output_types[AmbiguousAssignOrExtract] = AmbiguousAssignOrExtract
utils._output_types[Assigner] = Assigner
utils._output_types[Updater] = Updater

1	import numpy as np	6✔
2
3	from . import lib, utils	6✔
4	from .dtypes import _INDEX	6✔
5	from .utils import _CArray, output_type	6✔
6
7
8	class _AllIndices:	6✔
9	__slots__ = "_carg", "name", "_expr_name"	6✔
10
11	def __init__(self):	6✔
12	self._carg = lib.GrB_ALL	6✔
13	self.name = "GrB_ALL"	6✔
14	self._expr_name = ":"	6✔
15
16	def __reduce__(self):	6✔
17	return "_ALL_INDICES"	2✔
18
19
20	_ALL_INDICES = _AllIndices()	6✔
21
22
23	class AxisIndex:	6✔
24	__slots__ = "size", "index", "cscalar", "dimsize"	6✔
25
26	def __init__(self, size, index, cscalar, dimsize):	6✔
27	self.size = size	4✔
28	self.index = index	4✔
29	self.cscalar = cscalar	4✔
30	self.dimsize = dimsize	4✔
31
32	@property	6✔
33	def _carg(self):	6✔
34	return self.index._carg	4✔
35
36	@property	6✔
37	def name(self):	6✔
38	return self.index.name	4✔
39
40	@property	6✔
41	def _expr_name(self):	6✔
NEW 42	if self.size is None:	×
NEW 43	return f"{self.index.value}"	×
NEW 44	idx = self._py_index()	×
NEW 45	if type(idx) is slice:	×
NEW 46	rv = f"{'' if idx.start is None else idx.start}:{'' if idx.stop is None else idx.stop}"	×
NEW 47	if idx.step is not None:	×
NEW 48	return f"{rv}:{idx.step}"	×
NEW 49	return rv	×
NEW 50	if idx.size < 6:	×
NEW 51	return f"[{', '.join(map(str, idx))}]"	×
52	else:
NEW 53	return f"[{', '.join(map(str, idx[:3]))}, ...]"	×
54
55	def _py_index(self):	6✔
56	"""Convert resolved index back into a valid Python index"""
57	if self.size is None:	4✔
58	return self.index.value	4✔
59	if self.index is _ALL_INDICES:	4✔
60	return slice(None)	4✔
61	from ._slice import gxb_backwards, gxb_range, gxb_stride	4✔
62
63	if self.cscalar is gxb_backwards:	4✔
64	start, stop, step = self.index.array.tolist()	4✔
65	size = self.dimsize	4✔
66	stop -= size + 1	4✔
67	step = -step	4✔
68	elif self.cscalar is gxb_range:	4✔
69	start, stop = self.index.array.tolist()	4✔
70	step = None	4✔
71	stop += 1	4✔
72	elif self.cscalar is gxb_stride:	4✔
73	start, stop, step = self.index.array.tolist()	4✔
74	stop += 1	4✔
75	else:
76	return self.index.array	4✔
77	if (	4✔
78	start == 0
79	and (step is None or step > 0)
80	or start == self.dimsize - 1
81	and step is not None
82	and step < 0
83	):
84	start = None	4✔
85	if (	4✔
86	stop == self.dimsize
87	and (step is None or step > 0)
88	or stop == -self.dimsize - 1
89	and step is not None
90	and step < 0
91	):
92	stop = None	4✔
93	return slice(start, stop, step)	4✔
94
95
96	class IndexerResolver:	6✔
97	__slots__ = "obj", "indices", "shape", "__weakref__"	6✔
98
99	def __init__(self, obj, indices):	6✔
100	self.obj = obj	4✔
101	if indices is Ellipsis:	4✔
102	from .scalar import _as_scalar	4✔
103	from .vector import Vector	4✔
104
105	if type(obj) is Vector:	4✔
106	self.indices = [	4✔
107	AxisIndex(
108	obj._size,
109	_ALL_INDICES,
110	_as_scalar(obj._size, _INDEX, is_cscalar=True),
111	obj._size,
112	)
113	]
114	self.shape = (obj._size,)	4✔
115	else:
116	self.indices = [	4✔
117	AxisIndex(
118	obj._nrows,
119	_ALL_INDICES,
120	_as_scalar(obj._nrows, _INDEX, is_cscalar=True),
121	obj._nrows,
122	),
123	AxisIndex(
124	obj._ncols,
125	_ALL_INDICES,
126	_as_scalar(obj._ncols, _INDEX, is_cscalar=True),
127	obj._ncols,
128	),
129	]
130	self.shape = (obj._nrows, obj._ncols)	4✔
131	else:
132	self.indices = self.parse_indices(indices, obj.shape)	4✔
133	self.shape = tuple(index.size for index in self.indices if index.size is not None)	4✔
134
135	@property	6✔
136	def is_single_element(self):	6✔
137	return not self.shape	4✔
138
139	@property	6✔
140	def py_indices(self):	6✔
141	if self.obj.ndim > 1:	4✔
142	return tuple(index._py_index() for index in self.indices)	4✔
143	return self.indices[0]._py_index()	4✔
144
145	def parse_indices(self, indices, shape):	6✔
146	"""
147	Returns
148	[(rows, rowsize), (cols, colsize)] for Matrix
149	[(idx, idx_size)] for Vector
150
151	Within each tuple, if the index is of type int, the size will be None
152	"""
153	if len(shape) == 1:	4✔
154	if type(indices) is tuple:	4✔
155	raise TypeError(f"Index for {type(self.obj).__name__} cannot be a tuple")	4✔
156	# Convert to tuple for consistent processing
157	indices = (indices,)	4✔
158	else: # len(shape) == 2
159	if type(indices) is not tuple or len(indices) != 2:	4✔
160	raise TypeError(f"Index for {type(self.obj).__name__} must be a 2-tuple")	4✔
161
162	out = []	4✔
163	for i, idx in enumerate(indices):	4✔
164	typ = output_type(idx)	4✔
165	if typ is tuple:	4✔
166	raise TypeError(	4✔
167	f"Index in position {i} cannot be a tuple; must use slice or list or int"
168	)
169	out.append(self.parse_index(idx, typ, shape[i]))	4✔
170	return out	4✔
171
172	def parse_index(self, index, typ, size):	6✔
173	from .scalar import _as_scalar	4✔
174
175	if np.issubdtype(typ, np.integer):	4✔
176	if index >= size:	4✔
177	raise IndexError(f"Index out of range: index={index}, size={size}")	4✔
178	if np.issubdtype(typ, np.signedinteger) and index < 0:	4✔
179	index = index + size	4✔
180	if index < 0:	4✔
181	raise IndexError(f"Index out of range: index={index - size}, size={size}")	4✔
182	return AxisIndex(None, _as_scalar(int(index), _INDEX, is_cscalar=True), None, size)	4✔
183	if typ is list:	4✔
184	pass	4✔
185	elif typ is slice:	4✔
186	from ._slice import slice_to_index	4✔
187
188	return slice_to_index(index, size)	4✔
189
190	elif typ is np.ndarray:	4✔
191	if len(index.shape) != 1:	4✔
192	raise TypeError(f"Invalid number of dimensions for index: {len(index.shape)}")	4✔
193	if not np.issubdtype(index.dtype, np.integer):	4✔
194	raise TypeError(f"Invalid dtype for index: {index.dtype}")	4✔
195	if np.issubdtype(index.dtype, np.signedinteger):	4✔
196	is_negative = index < 0	4✔
197	if is_negative.any():	4✔
198	index = np.where(is_negative, index + size, index)	4✔
199	if (index < 0).any():	4✔
200	bad_index = index[index < 0][0] - size	4✔
201	raise IndexError(f"Index out of range: index={bad_index}, size={size}")	4✔
202	return AxisIndex(	4✔
203	len(index), _CArray(index), _as_scalar(len(index), _INDEX, is_cscalar=True), size
204	)
205	else:
206	from .scalar import Scalar	4✔
207
208	if typ is Scalar:	4✔
209	if not np.issubdtype(index.dtype.np_type, np.integer):	4✔
210	raise TypeError(f"An integer is required for indexing. Got: {index.dtype}")	4✔
211	value = int(index)	4✔
212	if np.issubdtype(index.dtype.np_type, np.signedinteger) and value < 0:	4✔
213	value = value + size	4✔
214	if value < 0:	4✔
215	raise IndexError(f"Index out of range: index={value - size}, size={size}")	4✔
216	return AxisIndex(None, _as_scalar(value, _INDEX, is_cscalar=True), None, size)	4✔
217
218	from .matrix import Matrix, TransposedMatrix	4✔
219	from .vector import Vector	4✔
220
221	if typ is Vector or typ is Matrix:	4✔
222	raise TypeError(	4✔
223	f"Invalid type for index: {typ.__name__}.\n"
224	f"If you want to apply a mask, perhaps do something like "
225	f"`x.dup(mask={index.name}.S)`.\n"
226	f"If you want to assign with a mask, perhaps do something like "
227	f"`x(mask={index.name}.S) << value`."
228	)
229	elif typ is TransposedMatrix:	4✔
230	raise TypeError(f"Invalid type for index: {typ.__name__}.")	4✔
231	try:	4✔
232	index = list(index)	4✔
233	except Exception:	4✔
234	from .mask import Mask	4✔
235
236	if isinstance(index, Mask):	4✔
237	raise TypeError(	4✔
238	f"Invalid type for index: {typ.__name__}.\n"
239	f"If you want to apply a mask, perhaps do something like "
240	f"`x.dup(mask={index.name})`.\n"
241	f"If you want to assign with a mask, perhaps do something like "
242	f"`x(mask={index.name}) << value`."
243	)
244	raise TypeError(f"Invalid type for index: {typ}; unable to convert to list")	4✔
245	return self.parse_index(np.array(index), np.ndarray, size)	4✔
246
247	def get_index(self, dim):	6✔
248	"""Return a new IndexerResolver with index for the selected dimension"""
249	rv = object.__new__(IndexerResolver)	4✔
250	rv.obj = self.obj	4✔
251	rv.indices = (self.indices[dim],)	4✔
252	return rv	4✔
253
254
255	class Assigner:	6✔
256	__slots__ = "updater", "resolved_indexes", "is_submask", "__weakref__"	6✔
257
258	def __init__(self, updater, resolved_indexes, *, is_submask):	6✔
259	# We could check here whether mask dimensions match index dimensions.
260	# We could also check for valid `updater.kwargs` if `resolved_indexes.is_single_element`.
261	self.updater = updater	4✔
262	self.resolved_indexes = resolved_indexes	4✔
263	self.is_submask = is_submask	4✔
264	if updater.kwargs.get("input_mask") is not None:	4✔
265	raise TypeError("`input_mask` argument may only be used for extract")	4✔
266
267	def update(self, obj):	6✔
268	# Occurs when user calls `C[index](...).update(obj)` or `C(...)[index].update(obj)`
269	self.updater._setitem(self.resolved_indexes, obj, is_submask=self.is_submask)	4✔
270
271	def __lshift__(self, obj):	6✔
272	# Occurs when user calls `C[index](...) << obj` or `C(...)[index] << obj`
273	self.updater._setitem(self.resolved_indexes, obj, is_submask=self.is_submask)	4✔
274
275	def __eq__(self, other):	6✔
276	raise TypeError(f"__eq__ not defined for objects of type {type(self)}.")	4✔
277
278	def __bool__(self):	6✔
279	raise TypeError(f"__bool__ not defined for objects of type {type(self)}.")	4✔
280
281
282	class AmbiguousAssignOrExtract:	6✔
283	__slots__ = "parent", "resolved_indexes", "_value", "__weakref__"	6✔
284	_is_scalar = False	6✔
285
286	def __init__(self, parent, resolved_indexes):	6✔
287	self.parent = parent	4✔
288	self.resolved_indexes = resolved_indexes	4✔
289	self._value = None	4✔
290
291	def __call__(self, args, *kwargs):	6✔
292	# Occurs when user calls `C[index](params)`
293	# Reverse the call order so we can parse the call args and kwargs
294	updater = self.parent(args, *kwargs)	4✔
295	is_submask = updater.kwargs.get("mask") is not None	4✔
296	return Assigner(updater, self.resolved_indexes, is_submask=is_submask)	4✔
297
298	def __lshift__(self, obj):	6✔
299	# Occurs when user calls `C[index] << obj`
300	self.update(obj)	4✔
301
302	def update(self, obj):	6✔
303	# Occurs when user calls `C[index].update(obj)`
304	if getattr(self.parent, "_is_transposed", False):	4✔
305	raise TypeError("'TransposedMatrix' object does not support item assignment")	4✔
306	Updater(self.parent)._setitem(self.resolved_indexes, obj, is_submask=False)	4✔
307
308	def new(self, dtype=None, *, mask=None, input_mask=None, name=None):	6✔
309	"""
310	Force extraction of the indexes into a new object
311	dtype and mask are the only controllable parameters.
312	"""
313	if input_mask is not None:	4✔
314	if mask is not None:	4✔
315	raise TypeError("mask and input_mask arguments cannot both be given")	4✔
316	from .base import _check_mask	4✔
317
318	_check_mask(input_mask, output=self.parent)	4✔
319	mask = self._input_mask_to_mask(input_mask)	4✔
320	delayed_extractor = self.parent._prep_for_extract(self.resolved_indexes)	4✔
321	return delayed_extractor.new(dtype, mask=mask, name=name)	4✔
322
323	dup = new	6✔
324
325	def _extract_delayed(self):	6✔
326	"""Return an Expression object, treating this as an extract call"""
327	return self.parent._prep_for_extract(self.resolved_indexes)	4✔
328
329	def _input_mask_to_mask(self, input_mask):	6✔
330	from .vector import Vector	4✔
331
332	if type(input_mask.mask) is Vector and type(self.parent) is not Vector:	4✔
333	rowidx, colidx = self.resolved_indexes.indices	4✔
334	if rowidx.size is None:	4✔
335	if self.parent._ncols != input_mask.mask._size:	4✔
336	raise ValueError(	4✔
337	"Size of `input_mask` Vector does not match ncols of Matrix:\n"
338	f"{self.parent.name}.ncols != {input_mask.mask.name}.size --> "
339	f"{self.parent._ncols} != {input_mask.mask._size}"
340	)
341	mask_expr = input_mask.mask._prep_for_extract(self.resolved_indexes.get_index(1))	4✔
342	elif colidx.size is None:	4✔
343	if self.parent._nrows != input_mask.mask._size:	4✔
344	raise ValueError(	4✔
345	"Size of `input_mask` Vector does not match nrows of Matrix:\n"
346	f"{self.parent.name}.nrows != {input_mask.mask.name}.size --> "
347	f"{self.parent._nrows} != {input_mask.mask._size}"
348	)
349	mask_expr = input_mask.mask._prep_for_extract(self.resolved_indexes.get_index(0))	4✔
350	else:
351	raise TypeError(	4✔
352	"Got Vector `input_mask` when extracting a submatrix from a Matrix. "
353	"Vector `input_mask` with a Matrix (or TransposedMatrix) input is "
354	"only valid when extracting from a single row or column."
355	)
356	elif input_mask.mask.shape != self.parent.shape:	4✔
357	if type(self.parent) is Vector:	4✔
358	attr = "size"	4✔
359	shape1 = self.parent._size	4✔
360	shape2 = input_mask.mask._size	4✔
361	else:
362	attr = "shape"	4✔
363	shape1 = self.parent.shape	4✔
364	shape2 = input_mask.mask.shape	4✔
365	raise ValueError(	4✔
366	f"{attr.capitalize()} of `input_mask` does not match {attr} of input:\n"
367	f"{self.parent.name}.{attr} != {input_mask.mask.name}.{attr} --> "
368	f"{shape1} != {shape2}"
369	)
370	else:
371	mask_expr = input_mask.mask._prep_for_extract(self.resolved_indexes)	4✔
372	mask_value = mask_expr.new(name="mask_temp")	4✔
373	return type(input_mask)(mask_value)	4✔
374
375	def _repr_html_(self):	6✔
NEW 376	from . import formatting	×
377
NEW 378	return formatting.format_index_expression_html(self)	×
379
380	def __repr__(self):	6✔
NEW 381	from . import formatting	×
382
NEW 383	return formatting.format_index_expression(self)	×
384
385	@property	6✔
386	def dtype(self):	6✔
387	return self.parent.dtype	4✔
388
389
390	class Updater:	6✔
391	__slots__ = "parent", "kwargs", "__weakref__"	6✔
392
393	def __init__(self, parent, **kwargs):	6✔
394	self.parent = parent	4✔
395	self.kwargs = kwargs	4✔
396
397	def __getitem__(self, keys):	6✔
398	# Occurs when user calls `C(params)[index]`
399	# Need something prepared to receive `<<` or `.update()`
400	if self.parent._is_scalar:	4✔
401	raise TypeError("Indexing not supported for Scalars")	4✔
402	resolved_indexes = IndexerResolver(self.parent, keys)	4✔
403	return Assigner(self, resolved_indexes, is_submask=False)	4✔
404
405	def _setitem(self, resolved_indexes, obj, *, is_submask):	6✔
406	# Occurs when user calls C(params)[index] = expr
407	if resolved_indexes.is_single_element and not self.kwargs:	4✔
408	# Fast path using assignElement
409	self.parent._assign_element(resolved_indexes, obj)	4✔
410	else:
411	mask = self.kwargs.get("mask")	4✔
412	expr = self.parent._prep_for_assign(	4✔
413	resolved_indexes, obj, mask=mask, is_submask=is_submask
414	)
415	self.update(expr)	4✔
416
417	def __setitem__(self, keys, obj):	6✔
418	if self.parent._is_scalar:	4✔
419	raise TypeError("Indexing not supported for Scalars")	4✔
420	resolved_indexes = IndexerResolver(self.parent, keys)	4✔
421	self._setitem(resolved_indexes, obj, is_submask=False)	4✔
422
423	def __delitem__(self, keys):	6✔
424	# Occurs when user calls `del C(params)[index]`
425	if self.parent._is_scalar:	4✔
426	raise TypeError("Indexing not supported for Scalars")	4✔
427	resolved_indexes = IndexerResolver(self.parent, keys)	4✔
428	if resolved_indexes.is_single_element:	4✔
429	self.parent._delete_element(resolved_indexes)	4✔
430	else:
431	# Delete selection by assigning an empty scalar
432	from .scalar import Scalar	4✔
433
434	scalar = Scalar.new(	4✔
435	self.parent.dtype, is_cscalar=False, name="s_empty" # pragma: is_grbscalar
436	)
437	self._setitem(resolved_indexes, scalar, is_submask=False)	4✔
438
439	def __lshift__(self, expr):	6✔
440	# Occurs when user calls `C(params) << expr`
441	self.parent._update(expr, **self.kwargs)	4✔
442
443	def update(self, expr):	6✔
444	# Occurs when user calls `C(params).update(expr)`
445	self.parent._update(expr, **self.kwargs)	4✔
446
447	def __eq__(self, other):	6✔
448	raise TypeError(f"__eq__ not defined for objects of type {type(self)}.")	4✔
449
450	def __bool__(self):	6✔
451	raise TypeError(f"__bool__ not defined for objects of type {type(self)}.")	4✔
452
453
454	class InfixExprBase:	6✔
455	__slots__ = "left", "right", "_value", "__weakref__"	6✔
456	_is_scalar = False	6✔
457
458	def __init__(self, left, right):	6✔
459	self.left = left	4✔
460	self.right = right	4✔
461	self._value = None	4✔
462
463	def new(self, dtype=None, *, mask=None, name=None):	6✔
464	if (	4✔
465	mask is None
466	and self._value is not None
467	and (dtype is None or self._value.dtype == dtype)
468	):
469	rv = self._value	4✔
470	if name is not None:	4✔
471	rv.name = name	4✔
472	self._value = None	4✔
473	return rv	4✔
474	expr = self._to_expr()	4✔
475	return expr.new(dtype, mask=mask, name=name)	4✔
476
477	dup = new	6✔
478
479	def _to_expr(self):	6✔
480	if self._value is None:	4✔
481	# Rely on the default operator for `x @ y`
482	self._value = getattr(self.left, self.method_name)(self.right)	4✔
483	return self._value	4✔
484
485	def _get_value(self, attr=None, default=None):	6✔
486	expr = self._to_expr()	4✔
487	return expr._get_value(attr=attr, default=default)	4✔
488
489	def _format_expr(self):	6✔
490	return f"{self.left.name} {self._infix} {self.right.name}"	4✔
491
492	def _format_expr_html(self):	6✔
493	return f"{self.left._name_html} {self._infix} {self.right._name_html}"	4✔
494
495	def _repr_html_(self):	6✔
496	from . import formatting	4✔
497
498	if self.output_type.__name__ == "VectorExpression":	4✔
499	return formatting.format_vector_infix_expression_html(self)	4✔
500	elif self.output_type.__name__ == "MatrixExpression":	4✔
501	return formatting.format_matrix_infix_expression_html(self)	4✔
502	return formatting.format_scalar_infix_expression_html(self)	4✔
503
504	def __repr__(self):	6✔
505	from . import formatting	4✔
506
507	if self.output_type.__name__ == "VectorExpression":	4✔
508	return formatting.format_vector_infix_expression(self)	4✔
509	elif self.output_type.__name__ == "MatrixExpression":	4✔
510	return formatting.format_matrix_infix_expression(self)	4✔
511	return formatting.format_scalar_infix_expression(self)	4✔
512
513	@property	6✔
514	def dtype(self):	6✔
515	if self._value is not None:	4✔
516	return self._value.dtype	4✔
517	return self._to_expr().dtype	4✔
518
519
520	# Mistakes
521	utils._output_types[AmbiguousAssignOrExtract] = AmbiguousAssignOrExtract	6✔
522	utils._output_types[Assigner] = Assigner	6✔
523	utils._output_types[Updater] = Updater	6✔

metagraph-dev / grblas / 1862640369

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous