scidash / sciunit / 603

pending completion

Build # 603

Build Type

Pull #143

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/scidash/sciunit/commit/<a class=hub.com/scidash/sciunit/commit/74b393585d781f109ca5127dc0a2c5cbefa4dfe5">74b393585<a href="https://github.com/scidash/sciunit/commit/74b393585d781f109ca5127dc0a2c5cbefa4dfe5">">Merge </a><a class="double-link" href="https://github.com/scidash/sciunit/commit/<a class="double-link" href="https://github.com/scidash/sciunit/commit/a3a5d73de927991456e3496da41a4f261265cec8">a3a5d73de</a>">a3a5d73de</a><a href="https://github.com/scidash/sciunit/commit/74b393585d781f109ca5127dc0a2c5cbefa4dfe5"> into 1b8bef6e9">1b8bef6e9</a>

Pull Request Pull Request #143: Add Most Type Hints

Run Details

290 of 290 new or added lines in 18 files covered. (100.0%)

1579 of 2137 relevant lines covered (73.89%)

2.96 hits per line

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

29.82

/sciunit/validators.py

"""Cerberus validator classes for SciUnit."""

import inspect

import quantities as pq
from cerberus import TypeDefinition, Validator
from typing import Any

def register_type(cls, name: str) -> None:
    """Register `name` as a type to validate as an instance of class `cls`

    Args:
        cls: a class
        name (str): the name to be registered
    """
    x = TypeDefinition(name, (cls,), ())
    Validator.types_mapping[name] = x
    

def register_quantity(quantity: pq.Quantity, name: str) -> None:
    """Register `name` as a type to validate as an instance of the class of `quantity`

    Args:
        quantity (pq.Quantity): a quantity
        name (str): the name to be registered
    """

    x = TypeDefinition(name, (quantity.__class__,), ())
    Validator.types_mapping[name] = x


class ObservationValidator(Validator):
    """Cerberus validator class for observations.

    Attributes:
        test (Test): [Description of `test`].
        _error (str, str): [Description of `_error`].
    """

    def __init__(self, *args, **kwargs):
        """ Constructor of ObservationValidator

        Must pass `test` as a keyword argument. Cannot be a positional argument without modifications to cerberus

        Raises:
            Exception: "Observation validator constructor must have a `test` keyword argument"
        """

        try:
            self.test = kwargs['test']
        except AttributeError:
            raise Exception(("Observation validator constructor must have "
                             "a `test` keyword argument"))
        super(ObservationValidator, self).__init__(*args, **kwargs)
        register_type(pq.quantity.Quantity, 'quantity')

    def _validate_iterable(self, is_iterable: bool, key: str, value: Any) -> None:
        """Validate fields with `iterable` key in schema set to True
        The rule's arguments are validated against this schema:
        {'type': 'boolean'}
        """
        if is_iterable:
            try:
                iter(value)
            except TypeError:
                self._error(key, "Must be iterable (e.g. a list or array)")


    def _validate_units(self, has_units: bool, key: str, value: Any) -> None:
        """Validate fields with `units` key in schema set to True.
        The rule's arguments are validated against this schema:
        {'type': 'boolean'}
        """
        if has_units:
            if isinstance(self.test.units, dict):
                required_units = self.test.units[key]
            else:
                required_units = self.test.units
            if not isinstance(value, pq.quantity.Quantity):
                self._error(key, "Must be a python quantity")
            if not isinstance(value, pq.quantity.Quantity):
                self._error(key, "Must be a python quantity")
            provided_units = value.simplified.units
            if not isinstance(required_units, pq.Dimensionless):
                required_units = required_units.simplified.units
            if not required_units == provided_units:
                self._error(key,
                            "Must have units of '%s'" % self.test.units.name)


class ParametersValidator(Validator):
    """Cerberus validator class for observations.

    Attributes:
        units_type ([type]): [description]
        _error (str, str): [description]
    """

    # doc is needed here
    units_map = {'time': 's', 'voltage': 'V', 'current': 'A'}

    def validate_quantity(self, value: pq.quantity.Quantity) -> None:
        """Validate that the value is of the `Quantity` type.

        Args:
            value (pq.quantity.Quantity): The Quantity instance to be validated.
        """
        if not isinstance(value, pq.quantity.Quantity):
            self._error('%s' % value, "Must be a Python quantity.")

    def validate_units(self, value: pq.quantity.Quantity) -> bool:
        """Validate units, assuming that it was called by _validate_type_*.

        Args:
            value (pq.quantity.Quantity): [description]

        Returns:
            bool: Whether it is valid.
        """
        self.validate_quantity(value)
        self.units_type = inspect.stack()[1][3].split('_')[-1]
        assert self.units_type, ("`validate_units` should not be called "
                                 "directly. It should be called by a "
                                 "_validate_type_* methods that sets "
                                 "`units_type`")
        units = getattr(pq, self.units_map[self.units_type])
        if not value.simplified.units == units:
            self._error('%s' % value,
                        "Must have dimensions of %s." % self.units_type)
        return True

    def _validate_type_time(self, value: pq.quantity.Quantity) -> bool:
        """Validate fields requiring `units` of seconds.

        Args:
            value (pq.quantity.Quantity): [description]

        Returns:
            bool: Whether it is valid.
        """
        return self.validate_units(value)

    def _validate_type_voltage(self, value: pq.quantity.Quantity) -> bool:
        """Validate fields requiring `units` of volts.

        Args:
            value (pq.quantity.Quantity): [description]

        Returns:
            bool: Whether it is valid.
        """
        return self.validate_units(value)

    def _validate_type_current(self, value: pq.quantity.Quantity) -> bool:
        """Validate fields requiring `units` of amps.

        Args:
            value (pq.quantity.Quantity): [description]

        Returns:
            bool: Whether it is valid.
        """
        return self.validate_units(value)

1	"""Cerberus validator classes for SciUnit."""
2
3	import inspect	4✔
4
5	import quantities as pq	4✔
6	from cerberus import TypeDefinition, Validator	4✔
7	from typing import Any	4✔
8
9	def register_type(cls, name: str) -> None:	4✔
10	"""Register `name` as a type to validate as an instance of class `cls`
11
12	Args:
13	cls: a class
14	name (str): the name to be registered
15	"""
16	x = TypeDefinition(name, (cls,), ())	×
17	Validator.types_mapping[name] = x	×
18
19
20	def register_quantity(quantity: pq.Quantity, name: str) -> None:	4✔
21	"""Register `name` as a type to validate as an instance of the class of `quantity`
22
23	Args:
24	quantity (pq.Quantity): a quantity
25	name (str): the name to be registered
26	"""
27
28	x = TypeDefinition(name, (quantity.__class__,), ())	×
29	Validator.types_mapping[name] = x	×
30
31
32	class ObservationValidator(Validator):	4✔
33	"""Cerberus validator class for observations.
34
35	Attributes:
36	test (Test): [Description of `test`].
37	_error (str, str): [Description of `_error`].
38	"""
39
40	def __init__(self, args, *kwargs):	4✔
41	""" Constructor of ObservationValidator
42
43	Must pass `test` as a keyword argument. Cannot be a positional argument without modifications to cerberus
44
45	Raises:
46	Exception: "Observation validator constructor must have a `test` keyword argument"
47	"""
48
49	try:	×
50	self.test = kwargs['test']	×
51	except AttributeError:	×
52	raise Exception(("Observation validator constructor must have "	×
53	"a `test` keyword argument"))
54	super(ObservationValidator, self).__init__(args, *kwargs)	×
55	register_type(pq.quantity.Quantity, 'quantity')	×
56
57	def _validate_iterable(self, is_iterable: bool, key: str, value: Any) -> None:	4✔
58	"""Validate fields with `iterable` key in schema set to True
59	The rule's arguments are validated against this schema:
60	{'type': 'boolean'}
61	"""
62	if is_iterable:	×
63	try:	×
64	iter(value)	×
65	except TypeError:	×
66	self._error(key, "Must be iterable (e.g. a list or array)")	×
67
68
69	def _validate_units(self, has_units: bool, key: str, value: Any) -> None:	4✔
70	"""Validate fields with `units` key in schema set to True.
71	The rule's arguments are validated against this schema:
72	{'type': 'boolean'}
73	"""
74	if has_units:	×
75	if isinstance(self.test.units, dict):	×
76	required_units = self.test.units[key]	×
77	else:
78	required_units = self.test.units	×
79	if not isinstance(value, pq.quantity.Quantity):	×
80	self._error(key, "Must be a python quantity")	×
81	if not isinstance(value, pq.quantity.Quantity):	×
82	self._error(key, "Must be a python quantity")	×
83	provided_units = value.simplified.units	×
84	if not isinstance(required_units, pq.Dimensionless):	×
85	required_units = required_units.simplified.units	×
86	if not required_units == provided_units:	×
87	self._error(key,	×
88	"Must have units of '%s'" % self.test.units.name)
89
90
91	class ParametersValidator(Validator):	4✔
92	"""Cerberus validator class for observations.
93
94	Attributes:
95	units_type ([type]): [description]
96	_error (str, str): [description]
97	"""
98
99	# doc is needed here
100	units_map = {'time': 's', 'voltage': 'V', 'current': 'A'}	4✔
101
102	def validate_quantity(self, value: pq.quantity.Quantity) -> None:	4✔
103	"""Validate that the value is of the `Quantity` type.
104
105	Args:
106	value (pq.quantity.Quantity): The Quantity instance to be validated.
107	"""
108	if not isinstance(value, pq.quantity.Quantity):	×
109	self._error('%s' % value, "Must be a Python quantity.")	×
110
111	def validate_units(self, value: pq.quantity.Quantity) -> bool:	4✔
112	"""Validate units, assuming that it was called by _validate_type_*.
113
114	Args:
115	value (pq.quantity.Quantity): [description]
116
117	Returns:
118	bool: Whether it is valid.
119	"""
120	self.validate_quantity(value)	×
121	self.units_type = inspect.stack()[1][3].split('_')[-1]	×
122	assert self.units_type, ("`validate_units` should not be called "	×
123	"directly. It should be called by a "
124	"_validate_type_* methods that sets "
125	"`units_type`")
126	units = getattr(pq, self.units_map[self.units_type])	×
127	if not value.simplified.units == units:	×
128	self._error('%s' % value,	×
129	"Must have dimensions of %s." % self.units_type)
130	return True	×
131
132	def _validate_type_time(self, value: pq.quantity.Quantity) -> bool:	4✔
133	"""Validate fields requiring `units` of seconds.
134
135	Args:
136	value (pq.quantity.Quantity): [description]
137
138	Returns:
139	bool: Whether it is valid.
140	"""
141	return self.validate_units(value)	×
142
143	def _validate_type_voltage(self, value: pq.quantity.Quantity) -> bool:	4✔
144	"""Validate fields requiring `units` of volts.
145
146	Args:
147	value (pq.quantity.Quantity): [description]
148
149	Returns:
150	bool: Whether it is valid.
151	"""
152	return self.validate_units(value)	×
153
154	def _validate_type_current(self, value: pq.quantity.Quantity) -> bool:	4✔
155	"""Validate fields requiring `units` of amps.
156
157	Args:
158	value (pq.quantity.Quantity): [description]
159
160	Returns:
161	bool: Whether it is valid.
162	"""
163	return self.validate_units(value)	×

scidash / sciunit / 603

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