def at_speed(self, speed):
"""
Find how long it would take to process this amount of data at a certain
speed.
:param speed: The speed of processing.
:return: The time taken as a `datetime.timedelta`.
"""
from nibble import Duration
scale = self.bits / speed.information.bits
return Duration(seconds=speed.duration.total_seconds() * scale)
def from_quantity_units(cls, quantity, information_unit, duration_unit):
"""
Initialise a new speed object from a quantity and unit string.
:param quantity: The number of the unit.
:param information_unit: The information part of the unit, e.g. 'GiB'.
:param duration_unit: The duration part of the unit, e.g. 'week'.
:return: A `Speed` object representing the quantity and unit.
"""
information = Information.from_quantity_unit(quantity, information_unit)
duration = Duration.from_quantity_unit(1, duration_unit)
return Speed(information, duration)
def t_ID(self, t):
r'[a-zA-Z]+'
if t.value in self._RESERVED.keys():
t.type = self._RESERVED[t.value]
return t
if Information.is_valid_symbol(t.value) or \
Information.is_valid_category(t.value):
t.type = self._INFORMATION_UNIT
return t
if Duration.is_valid_symbol(t.value):
t.type = self._DURATION_UNIT
return t
raise LexingError('Unrecognised token or unit \'{0.value}\' at '
'position {0.lexpos}'.format(t))
def __format__(self, format_spec):
# Defaults to <the most appropriate binary bytes unit> per second
# [number format|][ ][unit symbol or category][/[quantity][ ]time unit]
lhs, _, time = format_spec.partition('/')
if time:
match = self.DURATION_REGEX.match(time)
if match:
# quantity provided
quantity = float(match.group(1))
if quantity.is_integer():
quantity = int(quantity)
unit = match.group(2)
else:
# no quantity
quantity = 1
unit = time
if not lhs:
# this is a workaround to maintain the separator '/m' should
# result in a separator not being printed, but '' is passed to
# Information as the lhs, so it goes to default formatting
lhs = 'bB'
else:
quantity = 1
unit = 's'
try:
nanos = quantity * Duration.unit_nanoseconds(unit)
except ValueError as e:
raise TypeError(e)
information = self.information * nanos / self.duration.nanoseconds
time_fmt = unit if quantity == 1 else '{0}{1}'.format(quantity, unit)
return '{0:{1}}/{2}'.format(information, lhs, time_fmt)
def test_eq_true(self):
self.assertEqual(Duration(seconds=1.5), Duration(milliseconds=1500))
def test_init_weeks(self):
self.assertEqual(Duration(weeks=1),
Duration(nanoseconds=10 ** 9 * 60 * 60 * 24 * 7))
def test_ne_false(self):
self.assertFalse(Speed.FORTY_GIGABIT != Speed(
Information(80, Information.GIGABITS), Duration(seconds=2)))
def test_for_duration(self):
self.assertEqual(self._SPEED.for_duration(Duration(minutes=1)),
self._INFORMATION * 60)
def test_from_quantity_units(self):
self.assertEqual(
Speed.from_quantity_units(1.35, 'kB', 'weeks'),
Speed(Information(1.35, Information.KILOBYTES), Duration(weeks=1)))
def test_truediv_high(self): # 1.66 should go up
self.assertEqual(
Speed(Information(10), Duration(1)) / 6,
Speed(Information(20), Duration(10)))
def test_from_timedelta(self):
self.assertEqual(
Duration.from_timedelta(datetime.timedelta(milliseconds=3500)),
Duration(seconds=3.5))
def test_total_seconds(self):
self.assertEqual(Duration(seconds=1.5).total_seconds(),
datetime.timedelta(seconds=1.5).total_seconds())
def test_is_valid_symbol_false(self):
self.assertFalse(Duration.is_valid_symbol('dz'))
def test_is_valid_symbol_true(self):
self.assertTrue(Duration.is_valid_symbol('d'))
def test_from_quantity_unit(self):
self.assertEqual(Duration.from_quantity_unit(1.35, 'hours'),
Duration(hours=1.35))
def test_init_years(self):
self.assertEqual(Duration(years=1),
Duration(nanoseconds=10 ** 9 * 60 * 60 * 730 * 12))
def test_init_months(self):
self.assertEqual(Duration(months=1),
Duration(nanoseconds=10 ** 9 * 60 * 60 * 730))
def test_add(self):
self.assertEqual(
Speed(Information(500, Information.MEGABITS)) +
Speed(Information(2.5, Information.GIGABITS), Duration(seconds=5)),
Speed.GIGABIT)
def test_sub(self):
self.assertEqual(
Speed.TEN_GIGABIT - Speed.GIGABIT,
Speed(Information(90, Information.GIGABITS), Duration(seconds=10)))
def test_timedelta(self):
self.assertEqual(Duration(minutes=91.5).timedelta,
datetime.timedelta(seconds=5490))
def test_floordiv_low(self): # 1.33 should go down
self.assertEqual(
Speed(Information(4), Duration(1)) // 3,
Speed(Information(1), Duration(1)))
def test_lt_true(self):
self.assertLess(Duration(1), Duration(10))
def test_floordiv_high(self): # 1.66 should go down
self.assertEqual(
Speed(Information(10), Duration(1)) // 6,
Speed(Information(1), Duration(1)))
def test_le_false(self):
self.assertFalse(Duration(10) <= Duration(1))
def test_eq_true(self):
self.assertEqual(
Speed.GIGABIT,
Speed(Information(10, Information.GIGABITS), Duration(seconds=10)))
def test_le_true_equal(self):
self.assertLessEqual(Duration(10), Duration(10))
def test_str_y(self):
self.assertEqual(str(Duration(months=24)), '2 years')
def test_eq_false(self):
self.assertFalse(Duration(seconds=2) == Duration(milliseconds=22))
def test_eq_bad_class(self):
with self.assertRaises(TypeError):
_ = Duration(1) == 1
def test_init_days(self):
self.assertEqual(Duration(days=1),
Duration(nanoseconds=10 ** 9 * 60 * 60 * 24))
