1809117680

Build Type

github

Committed by GitHub

Commit Message

Merge b685f02fa into 28700cfd1

Pull Request Pull Request #163: Allow Scalar objects to be backed by GrB_Scalar.

Run Details

3253 of 3284 branches covered (99.06%)

Branch coverage included in aggregate %.

401 of 412 new or added lines in 16 files covered. (97.33%)

30 existing lines in 2 files now uncovered.

13138 of 13181 relevant lines covered (99.67%)

4.17 hits per line

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

96.95

/grblas/scalar.py

import itertools

import numpy as np

from . import _automethods, backend, ffi, lib, utils
from .base import BaseExpression, BaseType, call
from .binary import isclose
from .dtypes import _INDEX, BOOL, lookup_dtype
from .exceptions import check_status
from .operator import get_typed_op
from .utils import _Pointer, output_type, wrapdoc

ffi_new = ffi.new


class Scalar(BaseType):
    """
    GraphBLAS Scalar
    Pseudo-object for GraphBLAS functions which accumlate into a scalar type
    """

    __slots__ = "_empty", "_is_cscalar"
    ndim = 0
    shape = ()
    _is_scalar = True
    _name_counter = itertools.count()

    def __init__(self, gb_obj, dtype, *, empty=False, is_cscalar=False, name=None):
        if name is None:
            name = f"s_{next(Scalar._name_counter)}"
        super().__init__(gb_obj, dtype, name)
        self._is_cscalar = is_cscalar
        if is_cscalar:
            self._empty = empty

    def __del__(self):
        gb_obj = getattr(self, "gb_obj", None)
        if gb_obj is not None and "GB_Scalar_opaque" in str(gb_obj):
            # it's difficult/dangerous to record the call, b/c `self.name` may not exist
            check_status(lib.GrB_Scalar_free(gb_obj), self)

    @property
    def is_cscalar(self):
        return self._is_cscalar

    @property
    def is_grbscalar(self):
        return not self._is_cscalar

    def __repr__(self):
        from .formatting import format_scalar

        return format_scalar(self)

    def _repr_html_(self, collapse=False):
        from .formatting import format_scalar_html

        return format_scalar_html(self)

    def __eq__(self, other):
        return self.isequal(other)

    def __bool__(self):
        if self._is_empty:
            return False
        return bool(self.value)

    def __float__(self):
        return float(self.value)

    def __int__(self):
        return int(self.value)

    def __complex__(self):
        return complex(self.value)

    def __neg__(self):
        dtype = self.dtype
        if dtype.name[0] == "U" or dtype == BOOL:
            raise TypeError(f"The negative operator, `-`, is not supported for {dtype.name} dtype")
        rv = Scalar.new(dtype, is_cscalar=self._is_cscalar, name=f"-{self.name}")
        if self._is_empty:
            return rv
        rv.value = -self.value
        return rv

    def __invert__(self):
        if self.dtype != BOOL:
            raise TypeError(
                f"The invert operator, `~`, is not supported for {self.dtype.name} dtype.  "
                "It is only supported for BOOL dtype."
            )
        rv = Scalar.new(BOOL, is_cscalar=self._is_cscalar, name=f"~{self.name}")
        if self._is_empty:
            return rv
        rv.value = not self.value
        return rv

    __index__ = __int__

    def __array__(self, dtype=None):
        if dtype is None:
            dtype = self.dtype.np_type
        return np.array(self.value, dtype=dtype)

    def isequal(self, other, *, check_dtype=False):
        """
        Check for exact equality

        If `check_dtype` is True, also checks that dtypes match
        For equality of floating point Vectors, consider using `isclose`
        """
        if type(other) is not Scalar:
            if other is None:
                return self._is_empty
            try:
                other = Scalar.from_value(other, is_cscalar=False, name="s_isequal")
            except TypeError:
                other = self._expect_type(
                    other,
                    Scalar,
                    within="isequal",
                    argname="other",
                    extra_message="Literal scalars also accepted.",
                )
            # Don't check dtype if we had to infer dtype of `other`
            check_dtype = False
        if check_dtype and self.dtype != other.dtype:
            return False
        if self._is_empty or other._is_empty:
            return self._is_empty is other._is_empty
        # For now, compare values in Python.  We can get more sophisticated
        return self.value == other.value

    def isclose(self, other, *, rel_tol=1e-7, abs_tol=0.0, check_dtype=False):
        """
        Check for approximate equality

        If `check_dtype` is True, also checks that dtypes match
        Closeness check is equivalent to `abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)`
        """
        if type(other) is not Scalar:
            if other is None:
                return self._is_empty
            try:
                other = Scalar.from_value(other, is_cscalar=False, name="s_isclose")
            except TypeError:
                other = self._expect_type(
                    other,
                    Scalar,
                    within="isclose",
                    argname="other",
                    extra_message="Literal scalars also accepted.",
                )
            # Don't check dtype if we had to infer dtype of `other`
            check_dtype = False
        if check_dtype and self.dtype != other.dtype:
            return False
        if self._is_empty or other._is_empty:
            return self._is_empty is other._is_empty
        # We can't yet call a UDF on a scalar as part of the spec, so let's do it ourselves
        isclose_func = isclose(rel_tol, abs_tol)
        isclose_func = get_typed_op(
            isclose_func,
            self.dtype,
            other.dtype,
            is_left_scalar=True,
            is_right_scalar=True,
            kind="binary",
        )
        return isclose_func.numba_func(self.value, other.value)

    def clear(self):
        if self._is_empty:
            return
        if self._is_cscalar:
            if self.dtype == bool:
                self.value = False
            else:
                self.value = 0
            self._empty = True
        else:
            call("GrB_Scalar_clear", [self])

    @property
    def is_empty(self):
        if self._is_cscalar:
            return self._empty
        return self.nvals == 0

    @property
    def _is_empty(self):
        """Like is_empty, but doesn't record calls"""
        if self._is_cscalar:
            return self._empty
        return self._nvals == 0

    @property
    def value(self):
        if self._is_empty:
            return None
        if self._is_cscalar:
            return self.gb_obj[0]
        else:
            scalar = Scalar.new(self.dtype, is_cscalar=True)
            if not self.name:
                # Empty name plays havoc on the recorder, so give it a placeholder name
                name = self.name
                self.name = "scalar"
                try:
                    call(f"GrB_Scalar_extractElement_{self.dtype.name}", [_Pointer(scalar), self])
                finally:
                    self.name = name
            else:
                call(f"GrB_Scalar_extractElement_{self.dtype.name}", [_Pointer(scalar), self])
            return scalar.gb_obj[0]

    @value.setter
    def value(self, val):
        if val is None:
            self.clear()
        elif self._is_cscalar:
            if type(val) is Scalar and val._is_empty:
                self.clear()
            else:
                self.gb_obj[0] = val
                self._empty = False
        else:
            val = _as_scalar(val, is_cscalar=True)  # XXX: set dtype to self.dtype?
            if val._is_empty:
                self.clear()
            else:
                call(f"GrB_Scalar_setElement_{val.dtype}", [self, val])

    @property
    def nvals(self):
        if self._is_cscalar:
            if self._empty:
                return 0
            return 1
        n = ffi_new("GrB_Index*")
        scalar = Scalar(n, _INDEX, name="s_nvals", is_cscalar=True, empty=True)
        call("GrB_Scalar_nvals", [_Pointer(scalar), self])
        return n[0]

    @property
    def _nvals(self):
        """Like nvals, but doesn't record calls"""
        if self._is_cscalar:
            if self._empty:
                return 0
            return 1
        n = ffi_new("GrB_Index*")
        check_status(lib.GrB_Scalar_nvals(n, self.gb_obj[0]), self)
        return n[0]

    @property
    def _carg(self):
        # i.e., return None if we are empty and a C scalar
        if not self._is_cscalar or not self._is_empty:
            return self.gb_obj[0]

    def dup(self, dtype=None, *, is_cscalar=None, name=None):
        """Create a new Scalar by duplicating this one"""
        if is_cscalar is None:
            is_cscalar = self._is_cscalar
        if not is_cscalar and not self._is_scalar and (dtype is None or dtype == self.dtype):
            scalar = ffi_new("GrB_Scalar*")
            new_scalar = Scalar(
                scalar, self.dtype, is_cscalar=False, name=name  # pragma: is_grbscalar
            )
            call("GrB_Scalar_dup", [_Pointer(new_scalar), self])
        elif dtype is None:
            new_scalar = Scalar.new(self.dtype, is_cscalar=is_cscalar, name=name)
            new_scalar.value = self.value
        else:
            new_scalar = Scalar.new(dtype, is_cscalar=is_cscalar, name=name)
            if not self._is_empty:
                new_scalar.value = new_scalar.dtype.np_type(self.value)
        return new_scalar

    def wait(self):
        pass

    @classmethod
    def new(cls, dtype, *, is_cscalar=False, name=None):
        """
        Create a new empty Scalar from the given type
        """
        dtype = lookup_dtype(dtype)
        if is_cscalar:
            new_scalar = ffi_new(f"{dtype.c_type}*")
        else:
            new_scalar = ffi_new("GrB_Scalar*")
        rv = cls(new_scalar, dtype, name=name, empty=True, is_cscalar=is_cscalar)
        if not is_cscalar:
            call("GrB_Scalar_new", [_Pointer(rv), dtype])
        return rv

    @classmethod
    def from_value(cls, value, dtype=None, *, is_cscalar=False, name=None):
        """Create a new Scalar from a Python value"""
        if dtype is None:
            if output_type(value) is Scalar:
                dtype = value.dtype
            else:
                try:
                    dtype = lookup_dtype(type(value))
                except ValueError:
                    raise TypeError(
                        f"Argument of from_value must be a known scalar type, not {type(value)}"
                    )
        new_scalar = cls.new(dtype, is_cscalar=is_cscalar, name=name)
        new_scalar.value = value
        return new_scalar

    def __reduce__(self):
        return Scalar._deserialize, (self.value, self.dtype, self._is_cscalar, self.name)

    @staticmethod
    def _deserialize(value, dtype, is_cscalar, name):
        return Scalar.from_value(value, dtype, is_cscalar=is_cscalar, name=name)

    def to_pygraphblas(self):  # pragma: no cover
        """Convert to a new `pygraphblas.Scalar`

        This copies data.
        """
        if backend != "suitesparse":
            raise RuntimeError(
                f"to_pygraphblas only works with 'suitesparse' backend, not {backend}"
            )
        import pygraphblas as pg

        return pg.Scalar.from_value(self.value)

    @classmethod
    def from_pygraphblas(cls, scalar):  # pragma: no cover
        """Convert a `pygraphblas.Scalar` to a new `grblas.Scalar`

        This copies data.
        """
        if backend != "suitesparse":
            raise RuntimeError(
                f"from_pygraphblas only works with 'suitesparse' backend, not {backend!r}"
            )
        import pygraphblas as pg

        if not isinstance(scalar, pg.Scalar):
            raise TypeError(f"Expected pygraphblas.Scalar object.  Got type: {type(scalar)}")
        dtype = lookup_dtype(scalar.gb_type)
        return cls.from_value(scalar[0], dtype)

    def _as_vector(self):
        """Copy this Scalar to a Vector

        In the future, we may _cast_ instead of _copy_ when using SuiteSparse.
        """
        from .vector import Vector

        if self._is_cscalar:
            rv = Vector.new(self.dtype, size=1)
            if not self._is_empty:
                rv[0] = self
        else:
            rv = Vector(
                ffi.cast("GrB_Vector*", self.gb_obj),
                self.dtype,
                parent=self,
            )
            rv._size = 1
        return rv


class ScalarExpression(BaseExpression):
    __slots__ = "_is_cscalar"
    output_type = Scalar
    ndim = 0
    shape = ()
    _is_scalar = True

    def __init__(self, *args, is_cscalar, **kwargs):
        super().__init__(*args, **kwargs)
        self._is_cscalar = is_cscalar

    def construct_output(self, dtype=None, *, is_cscalar=None, name=None):
        if dtype is None:
            dtype = self.dtype
        if is_cscalar is None:
            is_cscalar = self._is_cscalar
        return Scalar.new(dtype, is_cscalar=is_cscalar, name=name)

    def new(self, dtype=None, *, is_cscalar=None, name=None):
        if is_cscalar is None:
            is_cscalar = self._is_cscalar
        return super()._new(dtype, None, name, is_cscalar=is_cscalar)

    dup = new

    def __repr__(self):
        from .formatting import format_scalar_expression

        return format_scalar_expression(self)

    def _repr_html_(self):
        from .formatting import format_scalar_expression_html

        return format_scalar_expression_html(self)

    is_cscalar = Scalar.is_cscalar
    is_grbscalar = Scalar.is_grbscalar

    # Begin auto-generated code: Scalar
    _get_value = _automethods._get_value
    __array__ = wrapdoc(Scalar.__array__)(property(_automethods.__array__))
    __bool__ = wrapdoc(Scalar.__bool__)(property(_automethods.__bool__))
    __complex__ = wrapdoc(Scalar.__complex__)(property(_automethods.__complex__))
    __eq__ = wrapdoc(Scalar.__eq__)(property(_automethods.__eq__))
    __float__ = wrapdoc(Scalar.__float__)(property(_automethods.__float__))
    __index__ = wrapdoc(Scalar.__index__)(property(_automethods.__index__))
    __int__ = wrapdoc(Scalar.__int__)(property(_automethods.__int__))
    __invert__ = wrapdoc(Scalar.__invert__)(property(_automethods.__invert__))
    __neg__ = wrapdoc(Scalar.__neg__)(property(_automethods.__neg__))
    _is_empty = wrapdoc(Scalar._is_empty)(property(_automethods._is_empty))
    _name_html = wrapdoc(Scalar._name_html)(property(_automethods._name_html))
    _nvals = wrapdoc(Scalar._nvals)(property(_automethods._nvals))
    gb_obj = wrapdoc(Scalar.gb_obj)(property(_automethods.gb_obj))
    is_empty = wrapdoc(Scalar.is_empty)(property(_automethods.is_empty))
    isclose = wrapdoc(Scalar.isclose)(property(_automethods.isclose))
    isequal = wrapdoc(Scalar.isequal)(property(_automethods.isequal))
    name = wrapdoc(Scalar.name)(property(_automethods.name))
    name = name.setter(_automethods._set_name)
    nvals = wrapdoc(Scalar.nvals)(property(_automethods.nvals))
    to_pygraphblas = wrapdoc(Scalar.to_pygraphblas)(property(_automethods.to_pygraphblas))
    value = wrapdoc(Scalar.value)(property(_automethods.value))
    wait = wrapdoc(Scalar.wait)(property(_automethods.wait))
    # These raise exceptions
    __and__ = Scalar.__and__
    __matmul__ = Scalar.__matmul__
    __or__ = Scalar.__or__
    __rand__ = Scalar.__rand__
    __rmatmul__ = Scalar.__rmatmul__
    __ror__ = Scalar.__ror__
    # End auto-generated code: Scalar


def _as_scalar(scalar, dtype=None, *, is_cscalar):
    if type(scalar) is not Scalar:
        return Scalar.from_value(scalar, dtype, is_cscalar=is_cscalar, name="")
    elif scalar._is_cscalar != is_cscalar or dtype is not None and scalar.dtype != dtype:
        return scalar.dup(dtype, is_cscalar=is_cscalar, name=scalar.name)
    else:
        return scalar


utils._output_types[Scalar] = Scalar
utils._output_types[ScalarExpression] = Scalar

1	import itertools	6✔
2
3	import numpy as np	6✔
4
5	from . import _automethods, backend, ffi, lib, utils	6✔
6	from .base import BaseExpression, BaseType, call	6✔
7	from .binary import isclose	6✔
8	from .dtypes import _INDEX, BOOL, lookup_dtype	6✔
9	from .exceptions import check_status	6✔
10	from .operator import get_typed_op	6✔
11	from .utils import _Pointer, output_type, wrapdoc	6✔
12
13	ffi_new = ffi.new	6✔
14
15
16	class Scalar(BaseType):	6✔
17	"""
18	GraphBLAS Scalar
19	Pseudo-object for GraphBLAS functions which accumlate into a scalar type
20	"""
21
22	__slots__ = "_empty", "_is_cscalar"	6✔
23	ndim = 0	6✔
24	shape = ()	6✔
25	_is_scalar = True	6✔
26	_name_counter = itertools.count()	6✔
27
28	def __init__(self, gb_obj, dtype, *, empty=False, is_cscalar=False, name=None):	6✔
29	if name is None:	4✔
30	name = f"s_{next(Scalar._name_counter)}"	4✔
31	super().__init__(gb_obj, dtype, name)	4✔
32	self._is_cscalar = is_cscalar	4✔
33	if is_cscalar:	4✔
34	self._empty = empty	4✔
35
36	def __del__(self):	6✔
37	gb_obj = getattr(self, "gb_obj", None)	4✔
38	if gb_obj is not None and "GB_Scalar_opaque" in str(gb_obj):	4✔
39	# it's difficult/dangerous to record the call, b/c `self.name` may not exist
40	check_status(lib.GrB_Scalar_free(gb_obj), self)	4✔
41
42	@property	6✔
43	def is_cscalar(self):	6✔
44	return self._is_cscalar	4✔
45
46	@property	6✔
47	def is_grbscalar(self):	6✔
48	return not self._is_cscalar	4✔
49
50	def __repr__(self):	6✔
51	from .formatting import format_scalar	4✔
52
53	return format_scalar(self)	4✔
54
55	def _repr_html_(self, collapse=False):	6✔
56	from .formatting import format_scalar_html	4✔
57
58	return format_scalar_html(self)	4✔
59
60	def __eq__(self, other):	6✔
61	return self.isequal(other)	4✔
62
63	def __bool__(self):	6✔
64	if self._is_empty:	4✔
65	return False	4✔
66	return bool(self.value)	4✔
67
68	def __float__(self):	6✔
69	return float(self.value)	4✔
70
71	def __int__(self):	6✔
72	return int(self.value)	4✔
73
74	def __complex__(self):	6✔
75	return complex(self.value)	4✔
76
77	def __neg__(self):	6✔
78	dtype = self.dtype	4✔
79	if dtype.name[0] == "U" or dtype == BOOL:	4✔
80	raise TypeError(f"The negative operator, `-`, is not supported for {dtype.name} dtype")	4✔
81	rv = Scalar.new(dtype, is_cscalar=self._is_cscalar, name=f"-{self.name}")	4✔
82	if self._is_empty:	4✔
83	return rv	4✔
84	rv.value = -self.value	4✔
85	return rv	4✔
86
87	def __invert__(self):	6✔
88	if self.dtype != BOOL:	4✔
89	raise TypeError(	4✔
90	f"The invert operator, `~`, is not supported for {self.dtype.name} dtype. "
91	"It is only supported for BOOL dtype."
92	)
93	rv = Scalar.new(BOOL, is_cscalar=self._is_cscalar, name=f"~{self.name}")	4✔
94	if self._is_empty:	4✔
95	return rv	4✔
96	rv.value = not self.value	4✔
97	return rv	4✔
98
99	__index__ = __int__	6✔
100
101	def __array__(self, dtype=None):	6✔
102	if dtype is None:	4✔
103	dtype = self.dtype.np_type	4✔
104	return np.array(self.value, dtype=dtype)	4✔
105
106	def isequal(self, other, *, check_dtype=False):	6✔
107	"""
108	Check for exact equality
109
110	If `check_dtype` is True, also checks that dtypes match
111	For equality of floating point Vectors, consider using `isclose`
112	"""
113	if type(other) is not Scalar:	4✔
114	if other is None:	4✔
115	return self._is_empty	4✔
116	try:	4✔
117	other = Scalar.from_value(other, is_cscalar=False, name="s_isequal")	4✔
118	except TypeError:	4✔
119	other = self._expect_type(	4✔
120	other,
121	Scalar,
122	within="isequal",
123	argname="other",
124	extra_message="Literal scalars also accepted.",
125	)
126	# Don't check dtype if we had to infer dtype of `other`
127	check_dtype = False	4✔
128	if check_dtype and self.dtype != other.dtype:	4✔
129	return False	4✔
130	if self._is_empty or other._is_empty:	4✔
131	return self._is_empty is other._is_empty	4✔
132	# For now, compare values in Python. We can get more sophisticated
133	return self.value == other.value	4✔
134
135	def isclose(self, other, *, rel_tol=1e-7, abs_tol=0.0, check_dtype=False):	6✔
136	"""
137	Check for approximate equality
138
139	If `check_dtype` is True, also checks that dtypes match
140	Closeness check is equivalent to `abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)`
141	"""
142	if type(other) is not Scalar:	4✔
143	if other is None:	4✔
144	return self._is_empty	2✔
145	try:	4✔
146	other = Scalar.from_value(other, is_cscalar=False, name="s_isclose")	4✔
147	except TypeError:	2✔
148	other = self._expect_type(	2✔
149	other,
150	Scalar,
151	within="isclose",
152	argname="other",
153	extra_message="Literal scalars also accepted.",
154	)
155	# Don't check dtype if we had to infer dtype of `other`
156	check_dtype = False	4✔
157	if check_dtype and self.dtype != other.dtype:	4✔
158	return False	2✔
159	if self._is_empty or other._is_empty:	4✔
160	return self._is_empty is other._is_empty	2✔
161	# We can't yet call a UDF on a scalar as part of the spec, so let's do it ourselves
162	isclose_func = isclose(rel_tol, abs_tol)	4✔
163	isclose_func = get_typed_op(	4✔
164	isclose_func,
165	self.dtype,
166	other.dtype,
167	is_left_scalar=True,
168	is_right_scalar=True,
169	kind="binary",
170	)
171	return isclose_func.numba_func(self.value, other.value)	4✔
172
173	def clear(self):	6✔
174	if self._is_empty:	4✔
175	return	4✔
176	if self._is_cscalar:	4✔
177	if self.dtype == bool:	4✔
178	self.value = False	4✔
179	else:
180	self.value = 0	4✔
181	self._empty = True	4✔
182	else:
183	call("GrB_Scalar_clear", [self])	4✔
184
185	@property	6✔
186	def is_empty(self):	6✔
187	if self._is_cscalar:	4✔
188	return self._empty	4✔
189	return self.nvals == 0	4✔
190
191	@property	6✔
192	def _is_empty(self):	6✔
193	"""Like is_empty, but doesn't record calls"""
194	if self._is_cscalar:	4✔
195	return self._empty	4✔
196	return self._nvals == 0	4✔
197
198	@property	6✔
199	def value(self):	6✔
200	if self._is_empty:	4✔
201	return None	4✔
202	if self._is_cscalar:	4✔
203	return self.gb_obj[0]	4✔
204	else:
205	scalar = Scalar.new(self.dtype, is_cscalar=True)	4✔
206	if not self.name:	4✔
207	# Empty name plays havoc on the recorder, so give it a placeholder name
208	name = self.name	4✔
209	self.name = "scalar"	4✔
210	try:	4✔
211	call(f"GrB_Scalar_extractElement_{self.dtype.name}", [_Pointer(scalar), self])	4✔
212	finally:
213	self.name = name	4✔
214	else:
215	call(f"GrB_Scalar_extractElement_{self.dtype.name}", [_Pointer(scalar), self])	4✔
216	return scalar.gb_obj[0]	4✔
217
218	@value.setter	6✔
219	def value(self, val):	6✔
220	if val is None:	4✔
221	self.clear()	4✔
222	elif self._is_cscalar:	4✔
223	if type(val) is Scalar and val._is_empty:	4!
NEW 224	self.clear()	×
225	else:
226	self.gb_obj[0] = val	4✔
227	self._empty = False	4✔
228	else:
229	val = _as_scalar(val, is_cscalar=True) # XXX: set dtype to self.dtype?	4✔
230	if val._is_empty:	4!
NEW 231	self.clear()	×
232	else:
233	call(f"GrB_Scalar_setElement_{val.dtype}", [self, val])	4✔
234
235	@property	6✔
236	def nvals(self):	6✔
237	if self._is_cscalar:	4✔
238	if self._empty:	4✔
239	return 0	4✔
240	return 1	4✔
241	n = ffi_new("GrB_Index*")	4✔
242	scalar = Scalar(n, _INDEX, name="s_nvals", is_cscalar=True, empty=True)	4✔
243	call("GrB_Scalar_nvals", [_Pointer(scalar), self])	4✔
244	return n[0]	4✔
245
246	@property	6✔
247	def _nvals(self):	6✔
248	"""Like nvals, but doesn't record calls"""
249	if self._is_cscalar:	4✔
250	if self._empty:	4!
NEW 251	return 0	×
252	return 1	4✔
253	n = ffi_new("GrB_Index*")	4✔
254	check_status(lib.GrB_Scalar_nvals(n, self.gb_obj[0]), self)	4✔
255	return n[0]	4✔
256
257	@property	6✔
258	def _carg(self):	6✔
259	# i.e., return None if we are empty and a C scalar
260	if not self._is_cscalar or not self._is_empty:	4!
261	return self.gb_obj[0]	4✔
262
263	def dup(self, dtype=None, *, is_cscalar=None, name=None):	6✔
264	"""Create a new Scalar by duplicating this one"""
265	if is_cscalar is None:	4✔
266	is_cscalar = self._is_cscalar	4✔
267	if not is_cscalar and not self._is_scalar and (dtype is None or dtype == self.dtype):	4!
NEW 268	scalar = ffi_new("GrB_Scalar*")	×
NEW 269	new_scalar = Scalar(	×
270	scalar, self.dtype, is_cscalar=False, name=name # pragma: is_grbscalar
271	)
NEW 272	call("GrB_Scalar_dup", [_Pointer(new_scalar), self])	×
273	elif dtype is None:	4✔
274	new_scalar = Scalar.new(self.dtype, is_cscalar=is_cscalar, name=name)	4✔
275	new_scalar.value = self.value	4✔
276	else:
277	new_scalar = Scalar.new(dtype, is_cscalar=is_cscalar, name=name)	4✔
278	if not self._is_empty:	4✔
279	new_scalar.value = new_scalar.dtype.np_type(self.value)	4✔
280	return new_scalar	4✔
281
282	def wait(self):	6✔
283	pass	4✔
284
285	@classmethod	6✔
286	def new(cls, dtype, *, is_cscalar=False, name=None):	6✔
287	"""
288	Create a new empty Scalar from the given type
289	"""
290	dtype = lookup_dtype(dtype)	4✔
291	if is_cscalar:	4✔
292	new_scalar = ffi_new(f"{dtype.c_type}*")	4✔
293	else:
294	new_scalar = ffi_new("GrB_Scalar*")	4✔
295	rv = cls(new_scalar, dtype, name=name, empty=True, is_cscalar=is_cscalar)	4✔
296	if not is_cscalar:	4✔
297	call("GrB_Scalar_new", [_Pointer(rv), dtype])	4✔
298	return rv	4✔
299
300	@classmethod	6✔
301	def from_value(cls, value, dtype=None, *, is_cscalar=False, name=None):	6✔
302	"""Create a new Scalar from a Python value"""
303	if dtype is None:	4✔
304	if output_type(value) is Scalar:	4✔
305	dtype = value.dtype	4✔
306	else:
307	try:	4✔
308	dtype = lookup_dtype(type(value))	4✔
309	except ValueError:	4✔
310	raise TypeError(	4✔
311	f"Argument of from_value must be a known scalar type, not {type(value)}"
312	)
313	new_scalar = cls.new(dtype, is_cscalar=is_cscalar, name=name)	4✔
314	new_scalar.value = value	4✔
315	return new_scalar	4✔
316
317	def __reduce__(self):	6✔
318	return Scalar._deserialize, (self.value, self.dtype, self._is_cscalar, self.name)	4✔
319
320	@staticmethod	6✔
321	def _deserialize(value, dtype, is_cscalar, name):	6✔
322	return Scalar.from_value(value, dtype, is_cscalar=is_cscalar, name=name)	4✔
323
324	def to_pygraphblas(self): # pragma: no cover
325	"""Convert to a new `pygraphblas.Scalar`
326
327	This copies data.
328	"""
329	if backend != "suitesparse":
330	raise RuntimeError(
331	f"to_pygraphblas only works with 'suitesparse' backend, not {backend}"
332	)
333	import pygraphblas as pg
334
335	return pg.Scalar.from_value(self.value)
336
337	@classmethod	6✔
338	def from_pygraphblas(cls, scalar): # pragma: no cover
339	"""Convert a `pygraphblas.Scalar` to a new `grblas.Scalar`
340
341	This copies data.
342	"""
343	if backend != "suitesparse":
344	raise RuntimeError(
345	f"from_pygraphblas only works with 'suitesparse' backend, not {backend!r}"
346	)
347	import pygraphblas as pg
348
349	if not isinstance(scalar, pg.Scalar):
350	raise TypeError(f"Expected pygraphblas.Scalar object. Got type: {type(scalar)}")
351	dtype = lookup_dtype(scalar.gb_type)
352	return cls.from_value(scalar[0], dtype)
353
354	def _as_vector(self):	6✔
355	"""Copy this Scalar to a Vector
356
357	In the future, we may _cast_ instead of _copy_ when using SuiteSparse.
358	"""
359	from .vector import Vector	4✔
360
361	if self._is_cscalar:	4✔
362	rv = Vector.new(self.dtype, size=1)	4✔
363	if not self._is_empty:	4✔
364	rv[0] = self	4✔
365	else:
366	rv = Vector(	4✔
367	ffi.cast("GrB_Vector*", self.gb_obj),
368	self.dtype,
369	parent=self,
370	)
371	rv._size = 1	4✔
372	return rv	4✔
373
374
375	class ScalarExpression(BaseExpression):	6✔
376	__slots__ = "_is_cscalar"	6✔
377	output_type = Scalar	6✔
378	ndim = 0	6✔
379	shape = ()	6✔
380	_is_scalar = True	6✔
381
382	def __init__(self, args, is_cscalar, *kwargs):	6✔
383	super().__init__(args, *kwargs)	4✔
384	self._is_cscalar = is_cscalar	4✔
385
386	def construct_output(self, dtype=None, *, is_cscalar=None, name=None):	6✔
387	if dtype is None:	4✔
388	dtype = self.dtype	4✔
389	if is_cscalar is None:	4✔
390	is_cscalar = self._is_cscalar	4✔
391	return Scalar.new(dtype, is_cscalar=is_cscalar, name=name)	4✔
392
393	def new(self, dtype=None, *, is_cscalar=None, name=None):	6✔
394	if is_cscalar is None:	4!
395	is_cscalar = self._is_cscalar	4✔
396	return super()._new(dtype, None, name, is_cscalar=is_cscalar)	4✔
397
398	dup = new	6✔
399
400	def __repr__(self):	6✔
401	from .formatting import format_scalar_expression	4✔
402
403	return format_scalar_expression(self)	4✔
404
405	def _repr_html_(self):	6✔
406	from .formatting import format_scalar_expression_html	4✔
407
408	return format_scalar_expression_html(self)	4✔
409
410	is_cscalar = Scalar.is_cscalar	6✔
411	is_grbscalar = Scalar.is_grbscalar	6✔
412
413	# Begin auto-generated code: Scalar
414	_get_value = _automethods._get_value	6✔
415	__array__ = wrapdoc(Scalar.__array__)(property(_automethods.__array__))	6✔
416	__bool__ = wrapdoc(Scalar.__bool__)(property(_automethods.__bool__))	6✔
417	__complex__ = wrapdoc(Scalar.__complex__)(property(_automethods.__complex__))	6✔
418	__eq__ = wrapdoc(Scalar.__eq__)(property(_automethods.__eq__))	6✔
419	__float__ = wrapdoc(Scalar.__float__)(property(_automethods.__float__))	6✔
420	__index__ = wrapdoc(Scalar.__index__)(property(_automethods.__index__))	6✔
421	__int__ = wrapdoc(Scalar.__int__)(property(_automethods.__int__))	6✔
422	__invert__ = wrapdoc(Scalar.__invert__)(property(_automethods.__invert__))	6✔
423	__neg__ = wrapdoc(Scalar.__neg__)(property(_automethods.__neg__))	6✔
424	_is_empty = wrapdoc(Scalar._is_empty)(property(_automethods._is_empty))	6✔
425	_name_html = wrapdoc(Scalar._name_html)(property(_automethods._name_html))	6✔
426	_nvals = wrapdoc(Scalar._nvals)(property(_automethods._nvals))	6✔
427	gb_obj = wrapdoc(Scalar.gb_obj)(property(_automethods.gb_obj))	6✔
428	is_empty = wrapdoc(Scalar.is_empty)(property(_automethods.is_empty))	6✔
429	isclose = wrapdoc(Scalar.isclose)(property(_automethods.isclose))	6✔
430	isequal = wrapdoc(Scalar.isequal)(property(_automethods.isequal))	6✔
431	name = wrapdoc(Scalar.name)(property(_automethods.name))	6✔
432	name = name.setter(_automethods._set_name)	6✔
433	nvals = wrapdoc(Scalar.nvals)(property(_automethods.nvals))	6✔
434	to_pygraphblas = wrapdoc(Scalar.to_pygraphblas)(property(_automethods.to_pygraphblas))	6✔
435	value = wrapdoc(Scalar.value)(property(_automethods.value))	6✔
436	wait = wrapdoc(Scalar.wait)(property(_automethods.wait))	6✔
437	# These raise exceptions
438	__and__ = Scalar.__and__	6✔
439	__matmul__ = Scalar.__matmul__	6✔
440	__or__ = Scalar.__or__	6✔
441	__rand__ = Scalar.__rand__	6✔
442	__rmatmul__ = Scalar.__rmatmul__	6✔
443	__ror__ = Scalar.__ror__	6✔
444	# End auto-generated code: Scalar
445
446
447	def _as_scalar(scalar, dtype=None, *, is_cscalar):	6✔
448	if type(scalar) is not Scalar:	4✔
449	return Scalar.from_value(scalar, dtype, is_cscalar=is_cscalar, name="")	4✔
450	elif scalar._is_cscalar != is_cscalar or dtype is not None and scalar.dtype != dtype:	4✔
451	return scalar.dup(dtype, is_cscalar=is_cscalar, name=scalar.name)	4✔
452	else:
453	return scalar	4✔
454
455
456	utils._output_types[Scalar] = Scalar	6✔
457	utils._output_types[ScalarExpression] = Scalar	6✔

metagraph-dev / grblas / 1809117680

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