7083112050

Committed 04 Dec 2023 06:59AM UTC coverage: 86.465% (-0.9%) from 87.401%

Build # 7083112050

Build Type

push

github

Committed by

Christian-B

Commit Message

overrides checking

Run Details

1366 of 1707 branches covered (0.0%)

Branch coverage included in aggregate %.

14 of 49 new or added lines in 3 files covered. (28.57%)

21 existing lines in 1 file now uncovered.

3374 of 3775 relevant lines covered (89.38%)

0.89 hits per line

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

51.82

/spinn_utilities/overrides.py

# Copyright (c) 2017 The University of Manchester
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import inspect
from types import FunctionType, MethodType
from typing import (Any, Callable, get_type_hints,
                    Iterable, Optional, TypeVar, Union)
#: :meta private:
Method = TypeVar("Method", bound=Callable[..., Any])


class overrides(object):
    """
    A decorator for indicating that a method overrides another method in
    a superclass.  This checks that the method does actually exist,
    copies the doc-string for the method, and enforces that the method
    overridden is specified, making maintenance easier.
    """

    # This near constant is changed by unittests to check our code
    __CHECK_TYPES = False

    __slots__ = [
        # The method in the superclass that this method overrides
        "_superclass_method",
        # True if the doc string is to be extended, False to set if not set
        "_extend_doc",
        # Any additional arguments required by the subclass method
        "_additional_arguments",
        # True if the subclass method may have additional defaults
        "_extend_defaults",
        # True if the name check is relaxed
        "_relax_name_check",
        # The name of the thing being overridden for error messages
        "_override_name",
        # True if this method adds typing info not in the original
        "_adds_typing",
        # True if this method has a return Type narrower than the super
        "_return_narrowing",
        # Optional List of params that have been narrowed.
        "_params_narrowed"
    ]

    def __init__(
            self, super_class_method, extend_doc: bool = True,
            additional_arguments: Optional[Iterable[str]] = None,
            extend_defaults: bool = False, adds_typing: bool = False,
            return_narrowing: bool = False):
            #params_narrowed: Optional[Union[str, Iterable[str]]] = None):
        """
        :param super_class_method: The method to override in the superclass
        :param bool extend_doc:
            True the method doc string should be appended to the super-method
            doc string, False if the documentation should be set to the
            super-method doc string only if there isn't a doc string already
        :param iterable(str) additional_arguments:
            Additional arguments taken by the subclass method over the
            superclass method, e.g., that are to be injected
        :param bool extend_defaults:
            Whether the subclass may specify extra defaults for the parameters
        :param adds_typing:
            Allows more typing (of non additional) than in the subclass.
            Should only be used for builtin super classes
        :param return_narrowing:
            Declares that the return may be narrower than the super.
            Only needed if one of the types can not be imported (circular)
        :param params_narrowed:
            List of params that have been narrowed compared
            Code should assert the narrowing is correct!
        """
        if isinstance(super_class_method, property):
            super_class_method = super_class_method.fget
        if not isinstance(super_class_method, (FunctionType, MethodType)):
            raise TypeError("may only decorate method declarations; "
                            f"this is a {type(super_class_method)}")
        self._superclass_method = super_class_method
        self._extend_doc = bool(extend_doc)
        self._extend_defaults = bool(extend_defaults)
        self._relax_name_check = False
        self._override_name = "super class method"
        if additional_arguments is not None:
            self._additional_arguments = frozenset(additional_arguments)
        else:
            self._additional_arguments = frozenset()
        self._adds_typing = adds_typing
        self._return_narrowing = return_narrowing
        #if params_narrowed:
        #    if isinstance(params_narrowed, str):
        #        self._params_narrowed = [params_narrowed]
        #    else:
        #        self._params_narrowed = params_narrowed
        #else:
        #    self._params_narrowed = []

    @staticmethod
    def __match_defaults(default_args, super_defaults, extend_ok):
        if default_args is None:
            return super_defaults is None
        elif super_defaults is None:
            return extend_ok
        if extend_ok:
            return len(default_args) >= len(super_defaults)
        return len(default_args) == len(super_defaults)

    def __verify_method_arguments(self, method: Method):
        """
        Check that the arguments match.
        """
        method_args = inspect.getfullargspec(method)
        super_args = inspect.getfullargspec(self._superclass_method)
        all_args = [
            arg for arg in method_args.args
            if arg not in self._additional_arguments]
        default_args = None
        if method_args.defaults is not None:
            default_args = [
                arg for arg in method_args.defaults
                if arg not in self._additional_arguments]
        if len(all_args) != len(super_args.args):
            raise AttributeError(
                f"Method has {len(method_args.args)} arguments but "
                f"{self._override_name} has {len(super_args.args)} arguments")
        for arg, super_arg in zip(all_args, super_args.args):
            if arg != super_arg:
                raise AttributeError(f"Missing argument {super_arg}")
        if not self.__match_defaults(
                default_args, super_args.defaults, self._extend_defaults):
            raise AttributeError(
                f"Default arguments don't match {self._override_name}")

    @staticmethod
    def to_str(type_value):
        if isinstance(type_value, type):
            type_value = type_value.__name__
        else:
            type_value = str(type_value)
        type_value = type_value.removeprefix("typing.")
        if type_value.startswith("Optional[") and "." in type_value and type_value.endswith("]") and "Union" not in type_value:
            type_value = "Optional[" + type_value[type_value.rfind(".")+ 1:]
        return type_value

    def __is_similar_type(self, method_type, super_type, arg):
        # easiest case they are the same
        if method_type == super_type:
            return True

        try:
            return issubclass(method_type, super_type)
        except TypeError:
            # print(f"Unable to subtype {super_type} {type(super_type)} "
            #       f"for {arg}")
            pass

        # If either came from annotations
        if isinstance(method_type, str) or isinstance(super_type, str):
            # convert types to str
            method_type_s = self.to_str(method_type)
            super_type_s = self.to_str(super_type)
            # hopefully they are equal now
            if method_type_s == super_type_s:
                return True
            if arg == "return":
                if self._return_narrowing:
                    return True
                # Checking subclass would need a list of subtype to super type
                raise AttributeError(
                    f"Detected possible return type narrowing for "
                    f"{self._override_name}. "
                    f"{method_type_s} while super is typed as {super_type_s}. "
                    f"this can not be checked due to none imported types.  "
                    f"If narrowing mark @overrides as return_narrowing")
            else:
                raise AttributeError(
                    f"Method {self._override_name} has {arg} typed as "
                    f"{method_type} while super is typed as {super_type}. "
                    f"For not imported types they must be exactly the same")

        # Assuming typeVar or generic typing is used.
        # No way to check subtypes for these has been found
        if arg == "return":
            if self._return_narrowing:
                return True
            raise AttributeError(
                f"Detected possible return type narrowing in "
                f"{self._override_name}. If they should be the same use type "
                f"imported from the super if they are different "
                f"mark @overrides as return_narrowing")
        else:
            raise AttributeError(
                f"Method {self._override_name} has {arg} typed as "
                f"{method_type} while super is typed as {super_type}. "
                f"For generic types use type imported from the super")

    def __probable_narrow(self, method_type_s, super_type_s):
        if super_type_s.startswith("Union"):
            if method_type_s in super_type_s:
                return True
        for wider, narrows in [("Iterable", ["List", "Sequence"])]:
            super_end = super_type_s.removeprefix(wider)
            if super_type_s.startswith(wider):
                for narrow in narrows:
                    if method_type_s.startswith(narrow):
                        method_end = method_type_s.removeprefix(narrow)
                        if super_end == method_end:
                            return True
        return False

    def __verify_similar(self, method_type, super_type, arg):
        # easiest case they are the same
        if method_type == super_type:
            return

        try:
            if issubclass(method_type, super_type):
                return
        except TypeError:
            # print(f"Unable to subtype {super_type} {type(super_type)} "
            #       f"for {arg}")
            pass

        # convert types to fiddled str
        method_type_s = self.to_str(method_type)
        super_type_s = self.to_str(super_type)

        # hopefully they are equal now
        if method_type_s == super_type_s:
            return

        if arg == "return":
            # skip if caller says narrowing
            if self._return_narrowing:
                return
            if self.__probable_narrow(method_type_s, super_type_s):
                return
            raise AttributeError(
                f"Detected possible return type narrowing for "
                f"{self._override_name}. "
                f"{method_type} while super is typed as {super_type}. "
                f"If narrowing mark @overrides as return_narrowing")
        else:
            #if arg in self._params_narrowed:
            #    return
            raise AttributeError(
                f"Method {self._override_name} has {arg} typed as "
                f"{method_type} while super has {super_type}")

    def __verify_method_types(self, method: Method):
        if not self.__CHECK_TYPES:
            return
        try:
            method_types = get_type_hints(method)
        except NameError:
            # This happens if the Type can not be imported (circular)
            method_types = inspect.getfullargspec(method).annotations
        try:
            super_types = get_type_hints(self._superclass_method)
        except NameError:
            super_types = inspect.getfullargspec(
                self._superclass_method).annotations

        if self._adds_typing:
            for arg in super_types:
                if method_types[arg] != super_types[arg]:
                    raise AttributeError(
                        f"Method {self._override_name} has {arg} "
                        f"typed as {method_types[arg]} "
                        f"while super has {super_types[arg]}")
            return

        all_types = [
            arg for arg in method_types
            if arg not in self._additional_arguments]

        if len(all_types) != len(super_types):
            raise AttributeError(
                f"Method has {len(method_types)} typed arguments but "
                f"{self._override_name} has {len(super_types)}")

        for arg in all_types:
            if arg in super_types:
                self.__verify_similar(method_types[arg], super_types[arg], arg)
            else:
                raise AttributeError(
                    f"Method {self._override_name} has {arg} typed as "
                    f"{method_types[arg]} while super does not type it. "
                    f"If you can type the super "
                    f"if not mark @overrides as adds_typing")

    def __call__(self, method: Method) -> Method:
        """
        Apply the decorator to the given method.
        """
        # Check and fail if this is a property
        if isinstance(method, property):
            raise AttributeError(
                f"Please ensure that the {self.__class__.__name__} decorator "
                "is the last decorator before the method declaration")

        # Check that the name matches
        if (not self._relax_name_check and
                method.__name__ != self._superclass_method.__name__):
            raise AttributeError(
                f"{self._override_name} name "
                f"{self._superclass_method.__name__} does not match "
                f"{method.__name__}. Ensure {self.__class__.__name__} is the "
                "last decorator before the method declaration")

        # Check that the arguments match (except for __init__ as this might
        # take extra arguments or pass arguments not specified)
        if method.__name__ != "__init__":
            self.__verify_method_arguments(method)
            self.__verify_method_types(method)

        if (self._superclass_method.__doc__ is not None and
                method.__doc__ is None):
            method.__doc__ = self._superclass_method.__doc__
        elif (self._extend_doc and
                self._superclass_method.__doc__ is not None):
            method.__doc__ = (
                self._superclass_method.__doc__ + (method.__doc__ or ""))
        return method

    @classmethod
    def check_types(cls):
        cls.__CHECK_TYPES = True

1	# Copyright (c) 2017 The University of Manchester
2	#
3	# Licensed under the Apache License, Version 2.0 (the "License");
4	# you may not use this file except in compliance with the License.
5	# You may obtain a copy of the License at
6	#
7	# https://www.apache.org/licenses/LICENSE-2.0
8	#
9	# Unless required by applicable law or agreed to in writing, software
10	# distributed under the License is distributed on an "AS IS" BASIS,
11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	# See the License for the specific language governing permissions and
13	# limitations under the License.
14
15	import inspect	1✔
16	from types import FunctionType, MethodType	1✔
17	from typing import (Any, Callable, get_type_hints,	1✔
18	Iterable, Optional, TypeVar, Union)
19	#: :meta private:
20	Method = TypeVar("Method", bound=Callable[..., Any])	1✔
21
22
23	class overrides(object):	1✔
24	"""
25	A decorator for indicating that a method overrides another method in
26	a superclass. This checks that the method does actually exist,
27	copies the doc-string for the method, and enforces that the method
28	overridden is specified, making maintenance easier.
29	"""
30
31	# This near constant is changed by unittests to check our code
32	__CHECK_TYPES = False	1✔
33
34	__slots__ = [	1✔
35	# The method in the superclass that this method overrides
36	"_superclass_method",
37	# True if the doc string is to be extended, False to set if not set
38	"_extend_doc",
39	# Any additional arguments required by the subclass method
40	"_additional_arguments",
41	# True if the subclass method may have additional defaults
42	"_extend_defaults",
43	# True if the name check is relaxed
44	"_relax_name_check",
45	# The name of the thing being overridden for error messages
46	"_override_name",
47	# True if this method adds typing info not in the original
48	"_adds_typing",
49	# True if this method has a return Type narrower than the super
50	"_return_narrowing",
51	# Optional List of params that have been narrowed.
52	"_params_narrowed"
53	]
54
55	def __init__(	1✔
56	self, super_class_method, extend_doc: bool = True,
57	additional_arguments: Optional[Iterable[str]] = None,
58	extend_defaults: bool = False, adds_typing: bool = False,
59	return_narrowing: bool = False):
60	#params_narrowed: Optional[Union[str, Iterable[str]]] = None):
61	"""
62	:param super_class_method: The method to override in the superclass
63	:param bool extend_doc:
64	True the method doc string should be appended to the super-method
65	doc string, False if the documentation should be set to the
66	super-method doc string only if there isn't a doc string already
67	:param iterable(str) additional_arguments:
68	Additional arguments taken by the subclass method over the
69	superclass method, e.g., that are to be injected
70	:param bool extend_defaults:
71	Whether the subclass may specify extra defaults for the parameters
72	:param adds_typing:
73	Allows more typing (of non additional) than in the subclass.
74	Should only be used for builtin super classes
75	:param return_narrowing:
76	Declares that the return may be narrower than the super.
77	Only needed if one of the types can not be imported (circular)
78	:param params_narrowed:
79	List of params that have been narrowed compared
80	Code should assert the narrowing is correct!
81	"""
82	if isinstance(super_class_method, property):	1✔
83	super_class_method = super_class_method.fget	1✔
84	if not isinstance(super_class_method, (FunctionType, MethodType)):	1!
85	raise TypeError("may only decorate method declarations; "	×
86	f"this is a {type(super_class_method)}")
87	self._superclass_method = super_class_method	1✔
88	self._extend_doc = bool(extend_doc)	1✔
89	self._extend_defaults = bool(extend_defaults)	1✔
90	self._relax_name_check = False	1✔
91	self._override_name = "super class method"	1✔
92	if additional_arguments is not None:	1✔
93	self._additional_arguments = frozenset(additional_arguments)	1✔
94	else:
95	self._additional_arguments = frozenset()	1✔
96	self._adds_typing = adds_typing	1✔
97	self._return_narrowing = return_narrowing	1✔
98	#if params_narrowed:
99	# if isinstance(params_narrowed, str):
100	# self._params_narrowed = [params_narrowed]
101	# else:
102	# self._params_narrowed = params_narrowed
103	#else:
104	# self._params_narrowed = []
105
106	@staticmethod	1✔
107	def __match_defaults(default_args, super_defaults, extend_ok):	1✔
108	if default_args is None:	1✔
109	return super_defaults is None	1✔
110	elif super_defaults is None:	1✔
111	return extend_ok	1✔
112	if extend_ok:	1✔
113	return len(default_args) >= len(super_defaults)	1✔
114	return len(default_args) == len(super_defaults)	1✔
115
116	def __verify_method_arguments(self, method: Method):	1✔
117	"""
118	Check that the arguments match.
119	"""
120	method_args = inspect.getfullargspec(method)	1✔
121	super_args = inspect.getfullargspec(self._superclass_method)	1✔
122	all_args = [	1✔
123	arg for arg in method_args.args
124	if arg not in self._additional_arguments]
125	default_args = None	1✔
126	if method_args.defaults is not None:	1✔
127	default_args = [	1✔
128	arg for arg in method_args.defaults
129	if arg not in self._additional_arguments]
130	if len(all_args) != len(super_args.args):	1✔
131	raise AttributeError(	1✔
132	f"Method has {len(method_args.args)} arguments but "
133	f"{self._override_name} has {len(super_args.args)} arguments")
134	for arg, super_arg in zip(all_args, super_args.args):	1✔
135	if arg != super_arg:	1✔
136	raise AttributeError(f"Missing argument {super_arg}")	1✔
137	if not self.__match_defaults(	1✔
138	default_args, super_args.defaults, self._extend_defaults):
139	raise AttributeError(	1✔
140	f"Default arguments don't match {self._override_name}")
141
142	@staticmethod	1✔
143	def to_str(type_value):	1✔
UNCOV 144	if isinstance(type_value, type):	×
UNCOV 145	type_value = type_value.__name__	×
146	else:
147	type_value = str(type_value)	×
NEW 148	type_value = type_value.removeprefix("typing.")	×
NEW 149	if type_value.startswith("Optional[") and "." in type_value and type_value.endswith("]") and "Union" not in type_value:	×
NEW 150	type_value = "Optional[" + type_value[type_value.rfind(".")+ 1:]	×
NEW 151	return type_value	×
152
153	def __is_similar_type(self, method_type, super_type, arg):	1✔
154	# easiest case they are the same
155	if method_type == super_type:	×
UNCOV 156	return True	×
157
158	try:	×
UNCOV 159	return issubclass(method_type, super_type)	×
160	except TypeError:	×
161	# print(f"Unable to subtype {super_type} {type(super_type)} "
162	# f"for {arg}")
163	pass	×
164
165	# If either came from annotations
166	if isinstance(method_type, str) or isinstance(super_type, str):	×
167	# convert types to str
NEW 168	method_type_s = self.to_str(method_type)	×
NEW 169	super_type_s = self.to_str(super_type)	×
170	# hopefully they are equal now
NEW 171	if method_type_s == super_type_s:	×
UNCOV 172	return True	×
UNCOV 173	if arg == "return":	×
UNCOV 174	if self._return_narrowing:	×
UNCOV 175	return True	×
176	# Checking subclass would need a list of subtype to super type
UNCOV 177	raise AttributeError(	×
178	f"Detected possible return type narrowing for "
179	f"{self._override_name}. "
180	f"{method_type_s} while super is typed as {super_type_s}. "
181	f"this can not be checked due to none imported types. "
182	f"If narrowing mark @overrides as return_narrowing")
183	else:
UNCOV 184	raise AttributeError(	×
185	f"Method {self._override_name} has {arg} typed as "
186	f"{method_type} while super is typed as {super_type}. "
187	f"For not imported types they must be exactly the same")
188
189	# Assuming typeVar or generic typing is used.
190	# No way to check subtypes for these has been found
UNCOV 191	if arg == "return":	×
UNCOV 192	if self._return_narrowing:	×
UNCOV 193	return True	×
194	raise AttributeError(	×
195	f"Detected possible return type narrowing in "
196	f"{self._override_name}. If they should be the same use type "
197	f"imported from the super if they are different "
198	f"mark @overrides as return_narrowing")
199	else:
UNCOV 200	raise AttributeError(	×
201	f"Method {self._override_name} has {arg} typed as "
202	f"{method_type} while super is typed as {super_type}. "
203	f"For generic types use type imported from the super")
204
205	def __probable_narrow(self, method_type_s, super_type_s):	1✔
NEW 206	if super_type_s.startswith("Union"):	×
NEW 207	if method_type_s in super_type_s:	×
NEW 208	return True	×
NEW 209	for wider, narrows in [("Iterable", ["List", "Sequence"])]:	×
NEW 210	super_end = super_type_s.removeprefix(wider)	×
NEW 211	if super_type_s.startswith(wider):	×
NEW 212	for narrow in narrows:	×
NEW 213	if method_type_s.startswith(narrow):	×
NEW 214	method_end = method_type_s.removeprefix(narrow)	×
NEW 215	if super_end == method_end:	×
NEW 216	return True	×
NEW 217	return False	×
218
219	def __verify_similar(self, method_type, super_type, arg):	1✔
220	# easiest case they are the same
221	if method_type == super_type:	1!
222	return	1✔
223
NEW 224	try:	×
NEW 225	if issubclass(method_type, super_type):	×
NEW 226	return	×
NEW 227	except TypeError:	×
228	# print(f"Unable to subtype {super_type} {type(super_type)} "
229	# f"for {arg}")
NEW 230	pass	×
231
232	# convert types to fiddled str
NEW 233	method_type_s = self.to_str(method_type)	×
NEW 234	super_type_s = self.to_str(super_type)	×
235
236	# hopefully they are equal now
NEW 237	if method_type_s == super_type_s:	×
NEW 238	return	×
239
NEW 240	if arg == "return":	×
241	# skip if caller says narrowing
NEW 242	if self._return_narrowing:	×
NEW 243	return	×
NEW 244	if self.__probable_narrow(method_type_s, super_type_s):	×
NEW 245	return	×
NEW 246	raise AttributeError(	×
247	f"Detected possible return type narrowing for "
248	f"{self._override_name}. "
249	f"{method_type} while super is typed as {super_type}. "
250	f"If narrowing mark @overrides as return_narrowing")
251	else:
252	#if arg in self._params_narrowed:
253	# return
NEW 254	raise AttributeError(	×
255	f"Method {self._override_name} has {arg} typed as "
256	f"{method_type} while super has {super_type}")
257
258	def __verify_method_types(self, method: Method):	1✔
259	if not self.__CHECK_TYPES:	1✔
260	return	1✔
261	try:	1✔
262	method_types = get_type_hints(method)	1✔
263	except NameError:	×
264	# This happens if the Type can not be imported (circular)
UNCOV 265	method_types = inspect.getfullargspec(method).annotations	×
266	try:	1✔
267	super_types = get_type_hints(self._superclass_method)	1✔
268	except NameError:	×
269	super_types = inspect.getfullargspec(	×
270	self._superclass_method).annotations
271
272	if self._adds_typing:	1!
UNCOV 273	for arg in super_types:	×
UNCOV 274	if method_types[arg] != super_types[arg]:	×
UNCOV 275	raise AttributeError(	×
276	f"Method {self._override_name} has {arg} "
277	f"typed as {method_types[arg]} "
278	f"while super has {super_types[arg]}")
UNCOV 279	return	×
280
281	all_types = [	1✔
282	arg for arg in method_types
283	if arg not in self._additional_arguments]
284
285	if len(all_types) != len(super_types):	1!
UNCOV 286	raise AttributeError(	×
287	f"Method has {len(method_types)} typed arguments but "
288	f"{self._override_name} has {len(super_types)}")
289
290	for arg in all_types:	1✔
291	if arg in super_types:	1!
292	self.__verify_similar(method_types[arg], super_types[arg], arg)	1✔
293	else:
UNCOV 294	raise AttributeError(	×
295	f"Method {self._override_name} has {arg} typed as "
296	f"{method_types[arg]} while super does not type it. "
297	f"If you can type the super "
298	f"if not mark @overrides as adds_typing")
299
300	def __call__(self, method: Method) -> Method:	1✔
301	"""
302	Apply the decorator to the given method.
303	"""
304	# Check and fail if this is a property
305	if isinstance(method, property):	1✔
306	raise AttributeError(	1✔
307	f"Please ensure that the {self.__class__.__name__} decorator "
308	"is the last decorator before the method declaration")
309
310	# Check that the name matches
311	if (not self._relax_name_check and	1✔
312	method.__name__ != self._superclass_method.__name__):
313	raise AttributeError(	1✔
314	f"{self._override_name} name "
315	f"{self._superclass_method.__name__} does not match "
316	f"{method.__name__}. Ensure {self.__class__.__name__} is the "
317	"last decorator before the method declaration")
318
319	# Check that the arguments match (except for __init__ as this might
320	# take extra arguments or pass arguments not specified)
321	if method.__name__ != "__init__":	1!
322	self.__verify_method_arguments(method)	1✔
323	self.__verify_method_types(method)	1✔
324
325	if (self._superclass_method.__doc__ is not None and	1✔
326	method.__doc__ is None):
327	method.__doc__ = self._superclass_method.__doc__	1✔
328	elif (self._extend_doc and	1✔
329	self._superclass_method.__doc__ is not None):
330	method.__doc__ = (	1✔
331	self._superclass_method.__doc__ + (method.__doc__ or ""))
332	return method	1✔
333
334	@classmethod	1✔
335	def check_types(cls):	1✔
336	cls.__CHECK_TYPES = True	1✔

SpiNNakerManchester / SpiNNUtils / 7083112050

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