2027687405

Build # 2027687405

Build Type

github

Committed by GitHub

Commit Message

Merge 42ec3bb23 into aededfdb5

Pull Request Pull Request #188: improved portability of first/last Aggregators and restored Matrix.diag()

Run Details

3916 of 4328 branches covered (90.48%)

Branch coverage included in aggregate %.

34 of 34 new or added lines in 7 files covered. (100.0%)

8 existing lines in 1 file now uncovered.

12607 of 13790 relevant lines covered (91.42%)

13.69 hits per line

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

91.55

/grblas/__init__.py

import sys as _sys
from importlib import import_module as _import_module
from importlib.abc import Loader as _Loader
from importlib.abc import MetaPathFinder as _MetaPathFinder

from . import backends, mask  # noqa
from ._version import get_versions  # noqa


class replace:
    """Singleton to indicate ``replace=True`` when updating objects.

    >>> C(mask, replace) << A.mxm(B)

    """

    def __repr__(self):
        return "replace"

    def __reduce__(self):
        return "replace"


replace = replace()


def get_config():
    import os

    import donfig
    import yaml

    filename = os.path.join(os.path.dirname(__file__), "grblas.yaml")
    config = donfig.Config("grblas")
    with open(filename) as f:
        defaults = yaml.safe_load(f)
    config.update_defaults(defaults)
    return config


config = get_config()
del get_config

backend = None
_init_params = None
_SPECIAL_ATTRS = {
    "Matrix",
    "Recorder",
    "Scalar",
    "Vector",
    "_agg",
    "_ss",
    "agg",
    "base",
    "binary",
    "descriptor",
    "dtypes",
    "exceptions",
    "expr",
    "ffi",
    "formatting",
    "infix",
    "io",
    "lib",
    "matrix",
    "monoid",
    "op",
    "operator",
    "recorder",
    "scalar",
    "semiring",
    "ss",
    "tests",
    "unary",
    "utils",
    "vector",
}


def __getattr__(name):
    """Auto-initialize if special attrs used without explicit init call by user"""
    if name in _SPECIAL_ATTRS:
        if _init_params is None:
            _init("suitesparse", None, automatic=True)
        if name not in globals():
            _load(name)
        return globals()[name]
    else:
        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")


def __dir__():
    return list(globals().keys() | _SPECIAL_ATTRS)


def init(backend="suitesparse", blocking=False):
    """Initialize the chosen backend.

    Parameters
    ----------
    backend : str, one of {"suitesparse"}
    blocking : bool
        Whether to call GrB_init with GrB_BLOCKING or GrB_NONBLOCKING

    """
    _init(backend, blocking)


def _init(backend_arg, blocking, automatic=False):
    global _init_params, backend, lib, ffi

    passed_params = dict(backend=backend_arg, blocking=blocking, automatic=automatic)
    if _init_params is not None:
        if blocking is None:
            passed_params["blocking"] = _init_params["blocking"]
        if _init_params != passed_params:
            from .exceptions import GrblasException

            if _init_params.get("automatic"):
                raise GrblasException("grblas objects accessed prior to manual initialization")
            else:
                raise GrblasException(
                    "grblas initialized multiple times with different init parameters"
                )
        # Already initialized with these parameters; nothing more to do
        return

    backend = backend_arg
    if backend == "suitesparse":
        from suitesparse_graphblas import ffi, initialize, is_initialized, lib

        if is_initialized():
            mode = ffi.new("GrB_Mode*")
            assert lib.GxB_Global_Option_get(lib.GxB_MODE, mode) == 0
            is_blocking = mode[0] == lib.GrB_BLOCKING
            if blocking is None:
                passed_params["blocking"] = is_blocking
            elif is_blocking != blocking:
                raise RuntimeError(
                    f"GraphBLAS has already been initialized with `blocking={is_blocking}`"
                )
        else:
            if blocking is None:
                blocking = False
                passed_params["blocking"] = blocking
            initialize(blocking=blocking, memory_manager="c")
    else:
        raise ValueError(f'Bad backend name.  Must be "suitesparse".  Got: {backend}')
    _init_params = passed_params


_NEEDS_OPERATOR = {
    "grblas._agg",
    "grblas.agg",
    "grblas.base",
    "grblas.io",
    "grblas.matrix",
    "grblas.scalar",
    "grblas.vector",
    "grblas.recorder",
    "grblas.ss",
}


def _load(name):
    if name in {"Matrix", "Vector", "Scalar", "Recorder"}:
        module_name = name.lower()
        if module_name not in globals():
            _load(module_name)
        module = globals()[module_name]
        val = getattr(module, name)
        globals()[name] = val
    else:
        # Everything else is a module
        module = _import_module(f".{name}", __name__)
        globals()[name] = module


class _GrblasModuleFinder(_MetaPathFinder):
    def find_spec(self, fullname, path, target=None):
        if fullname in _NEEDS_OPERATOR and "operator" not in globals():
            _load("operator")
            name = fullname[7:]  # Trim "grblas."
            if name in globals():
                # Make sure we execute the module only once
                module = globals()[name]
                spec = module.__spec__
                spec.loader = _SkipLoad(module, spec.loader)
                return spec


class _SkipLoad(_Loader):
    def __init__(self, module, orig_loader):
        self.module = module
        self.orig_loader = orig_loader

    def create_module(self, spec):
        return self.module

    def exec_module(self, module):
        # Don't execute the module, but restore the original loader
        module.__spec__.loader = self.orig_loader


_sys.meta_path.insert(0, _GrblasModuleFinder())

__version__ = get_versions()["version"]
del get_versions

__all__ = [key for key in __dir__() if not key.startswith("_")]

1	import sys as _sys	15✔
2	from importlib import import_module as _import_module	15✔
3	from importlib.abc import Loader as _Loader	15✔
4	from importlib.abc import MetaPathFinder as _MetaPathFinder	15✔
5
6	from . import backends, mask # noqa	15✔
7	from ._version import get_versions # noqa	15✔
8
9
10	class replace:	15✔
11	"""Singleton to indicate ``replace=True`` when updating objects.
12
13	>>> C(mask, replace) << A.mxm(B)
14
15	"""
16
17	def __repr__(self):	15✔
18	return "replace"	15✔
19
20	def __reduce__(self):	15✔
21	return "replace"	×
22
23
24	replace = replace()	15✔
25
26
27	def get_config():	15✔
28	import os	15✔
29
30	import donfig	15✔
31	import yaml	15✔
32
33	filename = os.path.join(os.path.dirname(__file__), "grblas.yaml")	15✔
34	config = donfig.Config("grblas")	15✔
35	with open(filename) as f:	15✔
36	defaults = yaml.safe_load(f)	15✔
37	config.update_defaults(defaults)	15✔
38	return config	15✔
39
40
41	config = get_config()	15✔
42	del get_config	15✔
43
44	backend = None	15✔
45	_init_params = None	15✔
46	_SPECIAL_ATTRS = {	15✔
47	"Matrix",
48	"Recorder",
49	"Scalar",
50	"Vector",
51	"_agg",
52	"_ss",
53	"agg",
54	"base",
55	"binary",
56	"descriptor",
57	"dtypes",
58	"exceptions",
59	"expr",
60	"ffi",
61	"formatting",
62	"infix",
63	"io",
64	"lib",
65	"matrix",
66	"monoid",
67	"op",
68	"operator",
69	"recorder",
70	"scalar",
71	"semiring",
72	"ss",
73	"tests",
74	"unary",
75	"utils",
76	"vector",
77	}
78
79
80	def __getattr__(name):	15✔
81	"""Auto-initialize if special attrs used without explicit init call by user"""
82	if name in _SPECIAL_ATTRS:	15✔
83	if _init_params is None:	15✔
84	_init("suitesparse", None, automatic=True)	15✔
85	if name not in globals():	15✔
86	_load(name)	15✔
87	return globals()[name]	15✔
88	else:
89	raise AttributeError(f"module {__name__!r} has no attribute {name!r}")	15✔
90
91
92	def __dir__():	15✔
93	return list(globals().keys() \| _SPECIAL_ATTRS)	15✔
94
95
96	def init(backend="suitesparse", blocking=False):	15✔
97	"""Initialize the chosen backend.
98
99	Parameters
100	----------
101	backend : str, one of {"suitesparse"}
102	blocking : bool
103	Whether to call GrB_init with GrB_BLOCKING or GrB_NONBLOCKING
104
105	"""
106	_init(backend, blocking)	15✔
107
108
109	def _init(backend_arg, blocking, automatic=False):	15✔
110	global _init_params, backend, lib, ffi
111
112	passed_params = dict(backend=backend_arg, blocking=blocking, automatic=automatic)	15✔
113	if _init_params is not None:	15✔
114	if blocking is None:	15✔
115	passed_params["blocking"] = _init_params["blocking"]	15✔
116	if _init_params != passed_params:	15✔
117	from .exceptions import GrblasException	15✔
118
119	if _init_params.get("automatic"):	15✔
120	raise GrblasException("grblas objects accessed prior to manual initialization")	15✔
121	else:
122	raise GrblasException(	15✔
123	"grblas initialized multiple times with different init parameters"
124	)
125	# Already initialized with these parameters; nothing more to do
126	return	15✔
127
128	backend = backend_arg	15✔
129	if backend == "suitesparse":	15✔
130	from suitesparse_graphblas import ffi, initialize, is_initialized, lib	15✔
131
132	if is_initialized():	15✔
133	mode = ffi.new("GrB_Mode*")	15✔
134	assert lib.GxB_Global_Option_get(lib.GxB_MODE, mode) == 0	15✔
135	is_blocking = mode[0] == lib.GrB_BLOCKING	15✔
136	if blocking is None:	15✔
137	passed_params["blocking"] = is_blocking	15✔
138	elif is_blocking != blocking:	15✔
139	raise RuntimeError(	15✔
140	f"GraphBLAS has already been initialized with `blocking={is_blocking}`"
141	)
142	else:
143	if blocking is None:	15✔
144	blocking = False	15✔
145	passed_params["blocking"] = blocking	15✔
146	initialize(blocking=blocking, memory_manager="c")	15✔
147	else:
148	raise ValueError(f'Bad backend name. Must be "suitesparse". Got: {backend}')	15✔
149	_init_params = passed_params	15✔
150
151
152	_NEEDS_OPERATOR = {	15✔
153	"grblas._agg",
154	"grblas.agg",
155	"grblas.base",
156	"grblas.io",
157	"grblas.matrix",
158	"grblas.scalar",
159	"grblas.vector",
160	"grblas.recorder",
161	"grblas.ss",
162	}
163
164
165	def _load(name):	15✔
166	if name in {"Matrix", "Vector", "Scalar", "Recorder"}:	15✔
167	module_name = name.lower()	15✔
168	if module_name not in globals():	15!
169	_load(module_name)	×
170	module = globals()[module_name]	15✔
171	val = getattr(module, name)	15✔
172	globals()[name] = val	15✔
173	else:
174	# Everything else is a module
175	module = _import_module(f".{name}", __name__)	15✔
176	globals()[name] = module	15✔
177
178
179	class _GrblasModuleFinder(_MetaPathFinder):	15✔
180	def find_spec(self, fullname, path, target=None):	15✔
181	if fullname in _NEEDS_OPERATOR and "operator" not in globals():	15✔
182	_load("operator")	15✔
183	name = fullname[7:] # Trim "grblas."	15✔
184	if name in globals():	15!
185	# Make sure we execute the module only once
UNCOV 186	module = globals()[name]	×
UNCOV 187	spec = module.__spec__	×
UNCOV 188	spec.loader = _SkipLoad(module, spec.loader)	×
UNCOV 189	return spec	×
190
191
192	class _SkipLoad(_Loader):	15✔
193	def __init__(self, module, orig_loader):	15✔
UNCOV 194	self.module = module	×
UNCOV 195	self.orig_loader = orig_loader	×
196
197	def create_module(self, spec):	15✔
UNCOV 198	return self.module	×
199
200	def exec_module(self, module):	15✔
201	# Don't execute the module, but restore the original loader
UNCOV 202	module.__spec__.loader = self.orig_loader	×
203
204
205	_sys.meta_path.insert(0, _GrblasModuleFinder())	15✔
206
207	__version__ = get_versions()["version"]	15✔
208	del get_versions	15✔
209
210	__all__ = [key for key in __dir__() if not key.startswith("_")]	15✔

metagraph-dev / grblas / 2027687405

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