2061996320

Build # 2061996320

Build Type

github

Committed by GitHub

Commit Message

Merge 1e3317f60 into dad95fe4b

Pull Request Pull Request #177: WIP: begin adding user-defined types

Run Details

4397 of 4477 branches covered (98.21%)

Branch coverage included in aggregate %.

648 of 729 new or added lines in 14 files covered. (88.89%)

84 existing lines in 4 files now uncovered.

14126 of 14299 relevant lines covered (98.79%)

14.33 hits per line

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

94.67

/grblas/tests/test_pickle.py

import os
import pickle

import pytest

import grblas as gb


def unarypickle(x):
    return x + 1


def binarypickle(x, y):
    return x + y


def unaryanon(x):
    return x + 2


def binaryanon(x, y):
    return x + y


@pytest.mark.slow
def test_deserialize():
    thisdir = os.path.dirname(__file__)
    with open(os.path.join(thisdir, "pickle1.pkl"), "rb") as f:
        d = pickle.load(f)
    check_values(d)
    # Again!
    with open(os.path.join(thisdir, "pickle1.pkl"), "rb") as f:
        d = pickle.load(f)
    check_values(d)

    # Now that these operators have been registered, let's take them for a run
    d2 = {
        "unary_pickle": gb.unary.unary_pickle,
        "binary_pickle": gb.binary.binary_pickle,
        "monoid_pickle": gb.monoid.monoid_pickle,
        "semiring_pickle": gb.semiring.semiring_pickle,
    }
    pkl = pickle.dumps(d2)
    d3 = pickle.loads(pkl)
    assert d3["unary_pickle"] is gb.unary.unary_pickle
    assert d3["binary_pickle"] is gb.binary.binary_pickle
    assert d3["monoid_pickle"] is gb.monoid.monoid_pickle
    assert d3["semiring_pickle"] is gb.semiring.semiring_pickle


@pytest.mark.slow
def test_serialize():
    v = gb.Vector.from_values([1], 2)

    # unary_pickle = gb.operator.UnaryOp.register_new("unary_pickle", unarypickle)
    # binary_pickle = gb.operator.BinaryOp.register_new("binary_pickle", binarypickle)
    # monoid_pickle = gb.operator.Monoid.register_new("monoid_pickle", binary_pickle, 0)
    # semiring_pickle = gb.operator.Semiring.register_new(
    #     "semiring_pickle", monoid_pickle, binary_pickle
    # )

    unary_anon = gb.operator.UnaryOp.register_anonymous(unaryanon)
    binary_anon = gb.operator.BinaryOp.register_anonymous(binaryanon)
    monoid_anon = gb.operator.Monoid.register_anonymous(binary_anon, 0)
    semiring_anon = gb.operator.Semiring.register_anonymous(monoid_anon, binary_anon)
    d = {
        "scalar": gb.Scalar.from_value(2),
        "empty_scalar": gb.Scalar.new(bool),
        "vector": v,
        "matrix": gb.Matrix.from_values([2], [3], 4),
        "matrix.T": gb.Matrix.from_values([3], [4], 5).T,
        "vector.S": v.S,
        "vector.V": v.V,
        "~vector.S": ~v.S,
        "~vector.V": ~v.V,
        "unary.abs": gb.unary.abs,
        "binary.minus": gb.binary.minus,
        "monoid.lxor": gb.monoid.lxor,
        "semiring.plus_times": gb.semiring.plus_times,
        "unary.abs[int]": gb.unary.abs[int],
        "binary.minus[float]": gb.binary.minus[float],
        "monoid.lxor[bool]": gb.monoid.lxor[bool],
        "semiring.plus_times[float]": gb.semiring.plus_times[float],
        "unary.numpy.spacing": gb.unary.numpy.spacing,
        "binary.numpy.gcd": gb.binary.numpy.gcd,
        "monoid.numpy.logaddexp": gb.monoid.numpy.logaddexp,
        "semiring.numpy.logaddexp2_hypot": gb.semiring.numpy.logaddexp2_hypot,
        "unary.numpy.spacing[float]": gb.unary.numpy.spacing[float],
        "binary.numpy.gcd[int]": gb.binary.numpy.gcd[int],
        "monoid.numpy.logaddexp[float]": gb.monoid.numpy.logaddexp[float],
        "semiring.numpy.logaddexp2_hypot[float]": gb.semiring.numpy.logaddexp2_hypot[float],
        "agg.sum": gb.agg.sum,
        "agg.first[int]": gb.agg.first[int],
        "binary.absfirst": gb.binary.absfirst,
        "binary.absfirst[float]": gb.binary.absfirst[float],
        "binary.isclose": gb.binary.isclose,
        # "unary_pickle": unary_pickle,
        # "unary_pickle[UINT16]": unary_pickle["UINT16"],
        # "binary_pickle": binary_pickle,
        # "monoid_pickle": monoid_pickle,
        # "semiring_pickle": semiring_pickle,
        "unary_anon": unary_anon,
        "unary_anon[float]": unary_anon[float],
        "binary_anon": binary_anon,
        "monoid_anon": monoid_anon,
        "semiring_anon": semiring_anon,
        "dtypes.BOOL": gb.dtypes.BOOL,
        "dtypes._INDEX": gb.dtypes._INDEX,
        "all_indices": gb.expr._ALL_INDICES,
        "replace": gb.replace,
    }
    try:
        pkl = pickle.dumps(d)
    except Exception:  # pragma: no cover
        for key, val in d.items():
            try:
                pickle.dumps(val)
            except Exception as exc:
                print(f"Pickle error: {key} {exc!r}")
        raise
    d2 = pickle.loads(pkl)
    check_values(d)
    check_values(d2)


def check_values(d):
    v = gb.Vector.from_values([1], 2)
    assert d["scalar"].isequal(gb.Scalar.from_value(2), check_dtype=True)
    assert d["empty_scalar"].isequal(gb.Scalar.new(bool), check_dtype=True)
    assert d["vector"].isequal(v, check_dtype=True)
    assert d["matrix"].isequal(gb.Matrix.from_values([2], [3], 4), check_dtype=True)
    assert d["matrix.T"].isequal(gb.Matrix.from_values([3], [4], 5).T, check_dtype=True)
    assert type(d["vector.S"]) is gb.mask.StructuralMask
    assert d["vector.S"].mask.isequal(v, check_dtype=True)
    assert type(d["vector.V"]) is gb.mask.ValueMask
    assert d["vector.V"].mask.isequal(v, check_dtype=True)
    assert type(d["~vector.S"]) is gb.mask.ComplementedStructuralMask
    assert d["~vector.S"].mask.isequal(v, check_dtype=True)
    assert type(d["~vector.V"]) is gb.mask.ComplementedValueMask
    assert d["~vector.V"].mask.isequal(v, check_dtype=True)
    assert d["unary.abs"] is gb.unary.abs
    assert d["binary.minus"] is gb.binary.minus
    assert d["monoid.lxor"] is gb.monoid.lxor
    assert d["semiring.plus_times"] is gb.semiring.plus_times
    assert d["unary.abs[int]"] is gb.unary.abs[int]
    assert d["binary.minus[float]"] is gb.binary.minus[float]
    assert d["monoid.lxor[bool]"] is gb.monoid.lxor[bool]
    assert d["semiring.plus_times[float]"] is gb.semiring.plus_times[float]
    assert d["unary.numpy.spacing"] is gb.unary.numpy.spacing
    assert d["binary.numpy.gcd"] is gb.binary.numpy.gcd
    assert d["monoid.numpy.logaddexp"] is gb.monoid.numpy.logaddexp
    assert d["semiring.numpy.logaddexp2_hypot"] is gb.semiring.numpy.logaddexp2_hypot
    assert d["unary.numpy.spacing[float]"] is gb.unary.numpy.spacing[float]
    assert d["binary.numpy.gcd[int]"] is gb.binary.numpy.gcd[int]
    assert d["monoid.numpy.logaddexp[float]"] is gb.monoid.numpy.logaddexp[float]
    assert d["semiring.numpy.logaddexp2_hypot[float]"] is gb.semiring.numpy.logaddexp2_hypot[float]
    assert d["agg.sum"] is gb.agg.sum
    assert d["agg.first[int]"] is gb.agg.first[int]
    assert d["binary.absfirst"] is gb.binary.absfirst
    assert d["binary.absfirst[float]"] is gb.binary.absfirst[float]
    assert d["binary.isclose"] is gb.binary.isclose
    if "unary_pickle" in d:
        assert d["unary_pickle"] is gb.unary.unary_pickle
    if "unary_pickle[UINT16]" in d:
        assert d["unary_pickle[UINT16]"] is gb.unary.unary_pickle["UINT16"]
    if "binary_pickle" in d:
        assert d["binary_pickle"] is gb.binary.binary_pickle
    if "monoid_pickle" in d:
        assert d["monoid_pickle"] is gb.monoid.monoid_pickle
    if "semiring_pickle" in d:
        assert d["semiring_pickle"] is gb.semiring.semiring_pickle
    d["unary_anon"]
    d["unary_anon[float]"]
    d["binary_anon"]
    d["monoid_anon"]
    d["semiring_anon"]
    assert d["dtypes.BOOL"] is gb.dtypes.BOOL
    assert d["dtypes._INDEX"] is gb.dtypes._INDEX
    assert d["all_indices"] is gb.expr._ALL_INDICES
    assert d["replace"] is gb.replace


def unarypickle_par(x):
    def inner(y):
        return x + y

    return inner


def binarypickle_par(z):
    def inner(x, y):
        return x + y + z

    return inner


def unaryanon_par(x):
    def inner(y):
        return y + x

    return inner


def binaryanon_par(z):
    def inner(x, y):
        return x + y + z

    return inner


def identity_par(z):
    return -z


@pytest.mark.slow
def test_serialize_parameterized():
    # unary_pickle = gb.operator.UnaryOp.register_new(
    #     "unary_pickle_par", unarypickle_par, parameterized=True
    # )
    # binary_pickle = gb.operator.BinaryOp.register_new(
    #     "binary_pickle_par", binarypickle_par, parameterized=True
    # )
    # monoid_pickle = gb.operator.Monoid.register_new("monoid_pickle_par", binary_pickle, 0)
    # semiring_pickle = gb.operator.Semiring.register_new(
    #     "semiring_pickle_par", monoid_pickle, binary_pickle
    # )

    unary_anon = gb.operator.UnaryOp.register_anonymous(unaryanon_par, parameterized=True)
    binary_anon = gb.operator.BinaryOp.register_anonymous(binaryanon_par, parameterized=True)
    monoid_anon = gb.operator.Monoid.register_anonymous(binary_anon, 0)
    monoid2_anon = gb.operator.Monoid.register_anonymous(binary_anon, identity_par)
    semiring_anon = gb.operator.Semiring.register_anonymous(monoid_anon, binary_anon)
    d = {
        "binary.isclose(rel_tol=1., abs_tol=1.)": gb.binary.isclose(rel_tol=1.0, abs_tol=1.0),
        "unary_anon": unary_anon,
        "binary_anon": binary_anon,
        "monoid_anon": monoid_anon,
        "monoid2_anon": monoid2_anon,
        "semiring_anon": semiring_anon,
        "unary_anon(0)": unary_anon(0),
        "binary_anon(0)": binary_anon(0),
        "monoid_anon(0)": monoid_anon(0),
        "monoid2_anon(0)": monoid2_anon(0),
        "semiring_anon(0)": semiring_anon(0),
        "unary_anon(0)[int]": unary_anon(0)[int],
        # "unary_pickle": unary_pickle,
        # "binary_pickle": binary_pickle,
        # "monoid_pickle": monoid_pickle,
        # "semiring_pickle": semiring_pickle,
        # "unary_pickle(0)": unary_pickle(0),
        # "binary_pickle(0)": binary_pickle(0),
        # "monoid_pickle(0)": monoid_pickle(0),
        # "semiring_pickle(0)": semiring_pickle(0),
        # "unary_pickle(0)[UINT16]": unary_pickle(0)["UINT16"],
    }
    try:
        pkl = pickle.dumps(d)
    except Exception:  # pragma: no cover
        for key, val in d.items():
            try:
                pickle.dumps(val)
            except Exception as exc:
                print(f"Pickle error: {key} {exc!r}")
        raise
    pickle.loads(pkl)  # TODO: check results


@pytest.mark.slow
def test_deserialize_parameterized():
    thisdir = os.path.dirname(__file__)
    with open(os.path.join(thisdir, "pickle2.pkl"), "rb") as f:
        pickle.load(f)  # TODO: check results
    # Again!
    with open(os.path.join(thisdir, "pickle2.pkl"), "rb") as f:
        pickle.load(f)  # TODO: check results

1	import os	15✔
2	import pickle	15✔
3
4	import pytest	15✔
5
6	import grblas as gb	15✔
7
8
9	def unarypickle(x):	15✔
UNCOV 10	return x + 1	×
11
12
13	def binarypickle(x, y):	15✔
UNCOV 14	return x + y	×
15
16
17	def unaryanon(x):	15✔
UNCOV 18	return x + 2	×
19
20
21	def binaryanon(x, y):	15✔
UNCOV 22	return x + y	×
23
24
25	@pytest.mark.slow	15✔
26	def test_deserialize():	15✔
27	thisdir = os.path.dirname(__file__)	9✔
28	with open(os.path.join(thisdir, "pickle1.pkl"), "rb") as f:	9✔
29	d = pickle.load(f)	9✔
30	check_values(d)	9✔
31	# Again!
32	with open(os.path.join(thisdir, "pickle1.pkl"), "rb") as f:	9✔
33	d = pickle.load(f)	9✔
34	check_values(d)	9✔
35
36	# Now that these operators have been registered, let's take them for a run
37	d2 = {	9✔
38	"unary_pickle": gb.unary.unary_pickle,
39	"binary_pickle": gb.binary.binary_pickle,
40	"monoid_pickle": gb.monoid.monoid_pickle,
41	"semiring_pickle": gb.semiring.semiring_pickle,
42	}
43	pkl = pickle.dumps(d2)	9✔
44	d3 = pickle.loads(pkl)	9✔
45	assert d3["unary_pickle"] is gb.unary.unary_pickle	9✔
46	assert d3["binary_pickle"] is gb.binary.binary_pickle	9✔
47	assert d3["monoid_pickle"] is gb.monoid.monoid_pickle	9✔
48	assert d3["semiring_pickle"] is gb.semiring.semiring_pickle	9✔
49
50
51	@pytest.mark.slow	15✔
52	def test_serialize():	15✔
53	v = gb.Vector.from_values([1], 2)	9✔
54
55	# unary_pickle = gb.operator.UnaryOp.register_new("unary_pickle", unarypickle)
56	# binary_pickle = gb.operator.BinaryOp.register_new("binary_pickle", binarypickle)
57	# monoid_pickle = gb.operator.Monoid.register_new("monoid_pickle", binary_pickle, 0)
58	# semiring_pickle = gb.operator.Semiring.register_new(
59	# "semiring_pickle", monoid_pickle, binary_pickle
60	# )
61
62	unary_anon = gb.operator.UnaryOp.register_anonymous(unaryanon)	9✔
63	binary_anon = gb.operator.BinaryOp.register_anonymous(binaryanon)	9✔
64	monoid_anon = gb.operator.Monoid.register_anonymous(binary_anon, 0)	9✔
65	semiring_anon = gb.operator.Semiring.register_anonymous(monoid_anon, binary_anon)	9✔
66	d = {	9✔
67	"scalar": gb.Scalar.from_value(2),
68	"empty_scalar": gb.Scalar.new(bool),
69	"vector": v,
70	"matrix": gb.Matrix.from_values([2], [3], 4),
71	"matrix.T": gb.Matrix.from_values([3], [4], 5).T,
72	"vector.S": v.S,
73	"vector.V": v.V,
74	"~vector.S": ~v.S,
75	"~vector.V": ~v.V,
76	"unary.abs": gb.unary.abs,
77	"binary.minus": gb.binary.minus,
78	"monoid.lxor": gb.monoid.lxor,
79	"semiring.plus_times": gb.semiring.plus_times,
80	"unary.abs[int]": gb.unary.abs[int],
81	"binary.minus[float]": gb.binary.minus[float],
82	"monoid.lxor[bool]": gb.monoid.lxor[bool],
83	"semiring.plus_times[float]": gb.semiring.plus_times[float],
84	"unary.numpy.spacing": gb.unary.numpy.spacing,
85	"binary.numpy.gcd": gb.binary.numpy.gcd,
86	"monoid.numpy.logaddexp": gb.monoid.numpy.logaddexp,
87	"semiring.numpy.logaddexp2_hypot": gb.semiring.numpy.logaddexp2_hypot,
88	"unary.numpy.spacing[float]": gb.unary.numpy.spacing[float],
89	"binary.numpy.gcd[int]": gb.binary.numpy.gcd[int],
90	"monoid.numpy.logaddexp[float]": gb.monoid.numpy.logaddexp[float],
91	"semiring.numpy.logaddexp2_hypot[float]": gb.semiring.numpy.logaddexp2_hypot[float],
92	"agg.sum": gb.agg.sum,
93	"agg.first[int]": gb.agg.first[int],
94	"binary.absfirst": gb.binary.absfirst,
95	"binary.absfirst[float]": gb.binary.absfirst[float],
96	"binary.isclose": gb.binary.isclose,
97	# "unary_pickle": unary_pickle,
98	# "unary_pickle[UINT16]": unary_pickle["UINT16"],
99	# "binary_pickle": binary_pickle,
100	# "monoid_pickle": monoid_pickle,
101	# "semiring_pickle": semiring_pickle,
102	"unary_anon": unary_anon,
103	"unary_anon[float]": unary_anon[float],
104	"binary_anon": binary_anon,
105	"monoid_anon": monoid_anon,
106	"semiring_anon": semiring_anon,
107	"dtypes.BOOL": gb.dtypes.BOOL,
108	"dtypes._INDEX": gb.dtypes._INDEX,
109	"all_indices": gb.expr._ALL_INDICES,
110	"replace": gb.replace,
111	}
112	try:	9✔
113	pkl = pickle.dumps(d)	9✔
114	except Exception: # pragma: no cover
115	for key, val in d.items():
116	try:
117	pickle.dumps(val)
118	except Exception as exc:
119	print(f"Pickle error: {key} {exc!r}")
120	raise
121	d2 = pickle.loads(pkl)	9✔
122	check_values(d)	9✔
123	check_values(d2)	9✔
124
125
126	def check_values(d):	15✔
127	v = gb.Vector.from_values([1], 2)	9✔
128	assert d["scalar"].isequal(gb.Scalar.from_value(2), check_dtype=True)	9✔
129	assert d["empty_scalar"].isequal(gb.Scalar.new(bool), check_dtype=True)	9✔
130	assert d["vector"].isequal(v, check_dtype=True)	9✔
131	assert d["matrix"].isequal(gb.Matrix.from_values([2], [3], 4), check_dtype=True)	9✔
132	assert d["matrix.T"].isequal(gb.Matrix.from_values([3], [4], 5).T, check_dtype=True)	9✔
133	assert type(d["vector.S"]) is gb.mask.StructuralMask	9✔
134	assert d["vector.S"].mask.isequal(v, check_dtype=True)	9✔
135	assert type(d["vector.V"]) is gb.mask.ValueMask	9✔
136	assert d["vector.V"].mask.isequal(v, check_dtype=True)	9✔
137	assert type(d["~vector.S"]) is gb.mask.ComplementedStructuralMask	9✔
138	assert d["~vector.S"].mask.isequal(v, check_dtype=True)	9✔
139	assert type(d["~vector.V"]) is gb.mask.ComplementedValueMask	9✔
140	assert d["~vector.V"].mask.isequal(v, check_dtype=True)	9✔
141	assert d["unary.abs"] is gb.unary.abs	9✔
142	assert d["binary.minus"] is gb.binary.minus	9✔
143	assert d["monoid.lxor"] is gb.monoid.lxor	9✔
144	assert d["semiring.plus_times"] is gb.semiring.plus_times	9✔
145	assert d["unary.abs[int]"] is gb.unary.abs[int]	9✔
146	assert d["binary.minus[float]"] is gb.binary.minus[float]	9✔
147	assert d["monoid.lxor[bool]"] is gb.monoid.lxor[bool]	9✔
148	assert d["semiring.plus_times[float]"] is gb.semiring.plus_times[float]	9✔
149	assert d["unary.numpy.spacing"] is gb.unary.numpy.spacing	9✔
150	assert d["binary.numpy.gcd"] is gb.binary.numpy.gcd	9✔
151	assert d["monoid.numpy.logaddexp"] is gb.monoid.numpy.logaddexp	9✔
152	assert d["semiring.numpy.logaddexp2_hypot"] is gb.semiring.numpy.logaddexp2_hypot	9✔
153	assert d["unary.numpy.spacing[float]"] is gb.unary.numpy.spacing[float]	9✔
154	assert d["binary.numpy.gcd[int]"] is gb.binary.numpy.gcd[int]	9✔
155	assert d["monoid.numpy.logaddexp[float]"] is gb.monoid.numpy.logaddexp[float]	9✔
156	assert d["semiring.numpy.logaddexp2_hypot[float]"] is gb.semiring.numpy.logaddexp2_hypot[float]	9✔
157	assert d["agg.sum"] is gb.agg.sum	9✔
158	assert d["agg.first[int]"] is gb.agg.first[int]	9✔
159	assert d["binary.absfirst"] is gb.binary.absfirst	9✔
160	assert d["binary.absfirst[float]"] is gb.binary.absfirst[float]	9✔
161	assert d["binary.isclose"] is gb.binary.isclose	9✔
162	if "unary_pickle" in d:	9✔
163	assert d["unary_pickle"] is gb.unary.unary_pickle	9✔
164	if "unary_pickle[UINT16]" in d:	9✔
165	assert d["unary_pickle[UINT16]"] is gb.unary.unary_pickle["UINT16"]	9✔
166	if "binary_pickle" in d:	9✔
167	assert d["binary_pickle"] is gb.binary.binary_pickle	9✔
168	if "monoid_pickle" in d:	9✔
169	assert d["monoid_pickle"] is gb.monoid.monoid_pickle	9✔
170	if "semiring_pickle" in d:	9✔
171	assert d["semiring_pickle"] is gb.semiring.semiring_pickle	9✔
172	d["unary_anon"]	9✔
173	d["unary_anon[float]"]	9✔
174	d["binary_anon"]	9✔
175	d["monoid_anon"]	9✔
176	d["semiring_anon"]	9✔
177	assert d["dtypes.BOOL"] is gb.dtypes.BOOL	9✔
178	assert d["dtypes._INDEX"] is gb.dtypes._INDEX	9✔
179	assert d["all_indices"] is gb.expr._ALL_INDICES	9✔
180	assert d["replace"] is gb.replace	9✔
181
182
183	def unarypickle_par(x):	15✔
184	def inner(y):	9✔
UNCOV 185	return x + y	×
186
187	return inner	9✔
188
189
190	def binarypickle_par(z):	15✔
191	def inner(x, y):	9✔
UNCOV 192	return x + y + z	×
193
194	return inner	9✔
195
196
197	def unaryanon_par(x):	15✔
198	def inner(y):	9✔
UNCOV 199	return y + x	×
200
201	return inner	9✔
202
203
204	def binaryanon_par(z):	15✔
205	def inner(x, y):	9✔
UNCOV 206	return x + y + z	×
207
208	return inner	9✔
209
210
211	def identity_par(z):	15✔
212	return -z	9✔
213
214
215	@pytest.mark.slow	15✔
216	def test_serialize_parameterized():	15✔
217	# unary_pickle = gb.operator.UnaryOp.register_new(
218	# "unary_pickle_par", unarypickle_par, parameterized=True
219	# )
220	# binary_pickle = gb.operator.BinaryOp.register_new(
221	# "binary_pickle_par", binarypickle_par, parameterized=True
222	# )
223	# monoid_pickle = gb.operator.Monoid.register_new("monoid_pickle_par", binary_pickle, 0)
224	# semiring_pickle = gb.operator.Semiring.register_new(
225	# "semiring_pickle_par", monoid_pickle, binary_pickle
226	# )
227
228	unary_anon = gb.operator.UnaryOp.register_anonymous(unaryanon_par, parameterized=True)	9✔
229	binary_anon = gb.operator.BinaryOp.register_anonymous(binaryanon_par, parameterized=True)	9✔
230	monoid_anon = gb.operator.Monoid.register_anonymous(binary_anon, 0)	9✔
231	monoid2_anon = gb.operator.Monoid.register_anonymous(binary_anon, identity_par)	9✔
232	semiring_anon = gb.operator.Semiring.register_anonymous(monoid_anon, binary_anon)	9✔
233	d = {	9✔
234	"binary.isclose(rel_tol=1., abs_tol=1.)": gb.binary.isclose(rel_tol=1.0, abs_tol=1.0),
235	"unary_anon": unary_anon,
236	"binary_anon": binary_anon,
237	"monoid_anon": monoid_anon,
238	"monoid2_anon": monoid2_anon,
239	"semiring_anon": semiring_anon,
240	"unary_anon(0)": unary_anon(0),
241	"binary_anon(0)": binary_anon(0),
242	"monoid_anon(0)": monoid_anon(0),
243	"monoid2_anon(0)": monoid2_anon(0),
244	"semiring_anon(0)": semiring_anon(0),
245	"unary_anon(0)[int]": unary_anon(0)[int],
246	# "unary_pickle": unary_pickle,
247	# "binary_pickle": binary_pickle,
248	# "monoid_pickle": monoid_pickle,
249	# "semiring_pickle": semiring_pickle,
250	# "unary_pickle(0)": unary_pickle(0),
251	# "binary_pickle(0)": binary_pickle(0),
252	# "monoid_pickle(0)": monoid_pickle(0),
253	# "semiring_pickle(0)": semiring_pickle(0),
254	# "unary_pickle(0)[UINT16]": unary_pickle(0)["UINT16"],
255	}
256	try:	9✔
257	pkl = pickle.dumps(d)	9✔
258	except Exception: # pragma: no cover
259	for key, val in d.items():
260	try:
261	pickle.dumps(val)
262	except Exception as exc:
263	print(f"Pickle error: {key} {exc!r}")
264	raise
265	pickle.loads(pkl) # TODO: check results	9✔
266
267
268	@pytest.mark.slow	15✔
269	def test_deserialize_parameterized():	15✔
270	thisdir = os.path.dirname(__file__)	9✔
271	with open(os.path.join(thisdir, "pickle2.pkl"), "rb") as f:	9✔
272	pickle.load(f) # TODO: check results	9✔
273	# Again!
274	with open(os.path.join(thisdir, "pickle2.pkl"), "rb") as f:	9✔
275	pickle.load(f) # TODO: check results	9✔

metagraph-dev / grblas / 2061996320

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