def __init__(self, lower_bound: int, upper_bound: int, data_tick: int):
if not isinstance(lower_bound, int) or \
not isinstance(upper_bound, int) or \
not isinstance(data_tick, int):
raise TypeError("All inputs must be of type int.")
if (lower_bound > upper_bound) or \
(data_tick > upper_bound) or \
(data_tick < lower_bound):
raise ValueError(
"Invalid inputs. Check lower_/upper_bound and data_tick")
self._lower_bound = lower_bound
self._upper_bound = upper_bound
self._data_tick = data_tick
self._fraction = (data_tick - lower_bound) / (upper_bound -
lower_bound)
self._binding = AxisBinding.valueOf(self._fraction)
def test_valueOf_09(self):
with self.assertRaises(ValueError):
AxisBinding.valueOf(10)
def test_valueOf_08(self):
self.assertEqual(AxisBinding.CUSTOM_FRACTION, AxisBinding.valueOf(0.2))
def test_valueOf_07(self):
self.assertEqual(AxisBinding.MIDDLE, AxisBinding.valueOf(0.5))
def test_valueOf_06(self):
self.assertEqual(AxisBinding.END, AxisBinding.valueOf(1.0))
def test_valueOf_05(self):
self.assertEqual(AxisBinding.BEGINNING, AxisBinding.valueOf(0))
def test_valueOf_04(self):
with self.assertRaises(TypeError):
AxisBinding.valueOf({})
def test_valueOf_02(self):
with self.assertRaises(ValueError):
AxisBinding.valueOf("None Existing")
def test_valueOf_01(self):
self.assertEqual(AxisBinding.BEGINNING,
AxisBinding.valueOf("beGiNnIng"))
def __init__(self, lower_bound: Iterable[float],
upper_bound: Iterable[float], **kwargs):
"""
Initializes a ``TimeAxis`` object given the ``lower_bound``, ``upper_bound``, and either ``fraction`` or
``data_ticks``.
:param lower_bound: The lower bound time stamps as a ``long`` value (or something that could be casted to
``long``). The units must be in microseconds. The ``lower_bound`` values must be
monotonically increasing.
:param upper_bound: The upper bound time stamps as a ``long`` value (or something that could be casted to
``long``). The units must be in microseconds. The ``upper_bound`` does NOT need to be
monotonically increasing; however, they should not be smaller than their counter-part
``lower_bound``.
:param kwargs: One of the following keys (just one, not more) must be provided:
- ``fraction``:
- ``data_ticks``:
- ``binding``:
"""
# making sure at there is only one of the "fraction", "data_ticks", or "binding" are provided.
if sum(
list(
map(lambda e: 1 if e in kwargs else 0,
['fraction', 'data_ticks', 'binding']))) != 1:
raise ValueError(
"You must provide exactly just one of the 'fraction', 'data_ticks', or 'binding'."
)
self._bounds = Axis._create_bounds(lower_bound, upper_bound)
self._nelem = self._bounds.shape[1]
if "fraction" in kwargs:
self._fraction = np.asarray(kwargs["fraction"],
dtype="float64").reshape((1, -1))
Axis._fraction_sanity_check(self._fraction)
if (self._fraction.size != 1) and (self._fraction.size !=
self._nelem):
raise ValueError(
"Fraction must be either a single number, or as many as there "
"upper/lower bound values.")
self._data_ticks = Axis._calculate_data_ticks_fromFraction(
self._bounds[0, :], self._bounds[1, :], self._fraction)
self._binding = Axis._get_binding(self._fraction)
if "data_ticks" in kwargs:
self._data_ticks = np.asarray(kwargs["data_ticks"],
dtype="int64").reshape((1, -1))
Axis._data_ticks_sanity_check(self._data_ticks)
if self._data_ticks.size != self._nelem:
raise ValueError(
"Data Ticks must have as many elements as there are lower/upper bound values."
)
self._fraction = Axis._calculate_fraction_from_data_ticks(
self._bounds[0, :], self._bounds[1, :], self._data_ticks)
self._binding = Axis._get_binding(self._fraction)
if "binding" in kwargs:
self._binding = AxisBinding.valueOf(kwargs["binding"])
if self._binding == AxisBinding.CUSTOM_FRACTION:
raise ValueError(
"Can't guess the fraction for the Custom Fraction. Use the fraction option instead."
)
self._fraction = np.asarray(self._binding.fraction(),
dtype="float64").reshape((1, -1))
self._data_ticks = Axis._calculate_data_ticks_fromFraction(
self._bounds[0, :], self._bounds[1, :], self._fraction)
if self._binding in (AxisBinding.BEGINNING, AxisBinding.MIDDLE,
AxisBinding.END):
self._fraction = np.asarray([self._fraction[0][0]],
dtype="float64").reshape((1, -1))