def test_exceptional():
Quantity.set_prefs(spacer=None, show_label=None, label_fmt=None, label_fmt_full=None, show_desc=False)
Quantity.set_prefs(prec='full')
q=Quantity('light = inf Hz -- a high frequency')
assert '{}'.format(q) == 'inf Hz'
assert '{:.8}'.format(q) == 'inf Hz'
assert '{:.8s}'.format(q) == 'inf Hz'
assert '{:.8S}'.format(q) == 'light = inf Hz'
assert '{:.8q}'.format(q) == 'inf Hz'
assert '{:.8Q}'.format(q) == 'light = inf Hz'
assert '{:r}'.format(q) == 'inf'
assert '{:R}'.format(q) == 'light = inf'
assert '{:u}'.format(q) == 'Hz'
assert '{:.4f}'.format(q) == 'inf'
assert '{:.4F}'.format(q) == 'light = inf'
assert '{:e}'.format(q) == 'inf'
assert '{:E}'.format(q) == 'light = inf'
assert '{:g}'.format(q) == 'inf'
assert '{:G}'.format(q) == 'light = inf'
assert '{:n}'.format(q) == 'light'
assert '{:d}'.format(q) == 'a high frequency'
assert '{:.2p}'.format(q) == 'inf Hz'
assert '{:,.2p}'.format(q) == 'inf Hz'
assert '{:.2P}'.format(q) == 'light = inf Hz'
assert '{:,.2P}'.format(q) == 'light = inf Hz'
def test_scaled_format():
Quantity.set_prefs(spacer=None, show_label=None, label_fmt=None, label_fmt_full=None, show_desc=False)
Quantity.set_prefs(prec=None)
q=Quantity('Tboil = 100 °C -- boiling point of water')
assert '{}'.format(q) == '100 °C'
assert '{:.8}'.format(q) == '100 °C'
assert '{:.8s°F}'.format(q) == '212 °F'
assert '{:.8S°F}'.format(q) == 'Tboil = 212 °F'
assert '{:.8q°F}'.format(q) == '212 °F'
assert '{:.8Q°F}'.format(q) == 'Tboil = 212 °F'
assert '{:r°F}'.format(q) == '212'
assert '{:R°F}'.format(q) == 'Tboil = 212'
assert '{:u°F}'.format(q) == '°F'
assert '{:f°F}'.format(q) == '212'
assert '{:F°F}'.format(q) == 'Tboil = 212'
assert '{:e°F}'.format(q) == '2.12e+02'
assert '{:E°F}'.format(q) == 'Tboil = 2.12e+02'
assert '{:g°F}'.format(q) == '212'
assert '{:G°F}'.format(q) == 'Tboil = 212'
assert '{:n°F}'.format(q) == 'Tboil'
assert '{:d°F}'.format(q) == 'boiling point of water'
assert '{!r}'.format(q) == "Quantity('100 °C')"
assert '{:.8s°C}'.format(q) == '100 °C'
assert '{:p°F}'.format(q) == '212 °F'
assert '{:,.2p°F}'.format(q) == '212 °F'
assert '{:P°F}'.format(q) == 'Tboil = 212 °F'
assert '{:,.2P°F}'.format(q) == 'Tboil = 212 °F'
assert '{:#p°F}'.format(q) == '212.0000 °F'
assert '{:#,.2p°F}'.format(q) == '212.00 °F'
assert '{:#P°F}'.format(q) == 'Tboil = 212.0000 °F'
assert '{:#,.2P°F}'.format(q) == 'Tboil = 212.00 °F'
def test_scaled_format():
Quantity.set_prefs(spacer=None,
show_label=None,
label_fmt=None,
label_fmt_full=None,
show_desc=False)
Quantity.set_prefs(prec=None)
if sys.version_info.major == 3:
q = Quantity('Tboil = 100 °C -- boiling point of water')
assert '{}'.format(q) == '100 °C'
assert '{:.8}'.format(q) == '100 °C'
assert '{:.8s°F}'.format(q) == '212 °F'
assert '{:.8S°F}'.format(q) == 'Tboil = 212 °F'
assert '{:.8q°F}'.format(q) == '212 °F'
assert '{:.8Q°F}'.format(q) == 'Tboil = 212 °F'
assert '{:r°F}'.format(q) == '212'
assert '{:R°F}'.format(q) == 'Tboil = 212'
assert '{:u°F}'.format(q) == '°F'
assert '{:f°F}'.format(q) == '212.0000'
assert '{:F°F}'.format(q) == 'Tboil = 212.0000'
assert '{:e°F}'.format(q) == '2.1200e+02'
assert '{:E°F}'.format(q) == 'Tboil = 2.1200e+02'
assert '{:g°F}'.format(q) == '212'
assert '{:G°F}'.format(q) == 'Tboil = 212'
assert '{:n°F}'.format(q) == 'Tboil'
assert '{:d°F}'.format(q) == 'boiling point of water'
assert '{:X°F}'.format(q) == '100 °C'
assert '{!r}'.format(q) == "Quantity('100 °C')"
assert '{:.8s°C}'.format(q) == '100 °C'
def _gate_changed(self):
try:
Quantity(self.gateText.value)
except:
return
if Quantity(self.gateText.value) == 0:
return
self.gate = Quantity(self.gateText.value)
if self.gate > self.memory * self.interval:
self.gate = self.memory * self.interval
elif self.gate < self.minInterval:
self.gate = self.minInterval
self.gate = int(math.ceil(self.gate / self.interval)) * self.interval
self.resolution = self._get_resolution(1 / self.gate)
resls = self.resolutionBox.options
resls = [r[0] for r in resls]
self.resolutionBox._line = resls.index(
Quantity(self.resolution, "Hz").render())
self.resolutionBox._value = self.resolutionBox._line
self.samples = self.gate / self.interval
self.samplesText._value = Quantity(self.samples, "S").render()
def test_format():
Quantity.set_prefs(spacer=None,
show_label=None,
label_fmt=None,
label_fmt_full=None,
show_desc=False)
q = Quantity('f = 1420.405751786 MHz -- frequency of hydrogen line')
assert '{}'.format(q) == '1.4204 GHz'
assert '{:.8}'.format(q) == '1.42040575 GHz'
assert '{:.8s}'.format(q) == '1.42040575 GHz'
assert '{:.8S}'.format(q) == 'f = 1.42040575 GHz'
assert '{:.8q}'.format(q) == '1.42040575 GHz'
assert '{:.8Q}'.format(q) == 'f = 1.42040575 GHz'
assert '{:r}'.format(q) == '1.4204G'
assert '{:R}'.format(q) == 'f = 1.4204G'
assert '{:u}'.format(q) == 'Hz'
assert '{:f}'.format(q) == '1420405751.7860'
assert '{:F}'.format(q) == 'f = 1420405751.7860'
assert '{:e}'.format(q) == '1.4204e+09'
assert '{:E}'.format(q) == 'f = 1.4204e+09'
assert '{:g}'.format(q) == '1.4204e+09'
assert '{:G}'.format(q) == 'f = 1.4204e+09'
assert '{:n}'.format(q) == 'f'
assert '{:d}'.format(q) == 'frequency of hydrogen line'
assert '{:X}'.format(q) == '1.4204 GHz'
q = Quantity('2ns')
assert float(q) == 2e-9
def test_width():
Quantity.set_prefs(spacer=None, show_label=None, label_fmt=None, label_fmt_full=None, show_desc=False)
Quantity.set_prefs(prec='full')
q=Quantity('f = 1420.405751786 MHz -- frequency of hydrogen line')
assert '{:25}'.format(q) == ' 1.420405751786 GHz'
assert '{:>25.8}'.format(q) == ' 1.42040575 GHz'
assert '{:25.8s}'.format(q) == ' 1.42040575 GHz'
assert '{:<25.8s}'.format(q) == '1.42040575 GHz '
assert '{:^25.8S}'.format(q) == ' f = 1.42040575 GHz '
assert '{:25.8q}'.format(q) == ' 1.42040575 GHz'
assert '{:>25.8Q}'.format(q) == ' f = 1.42040575 GHz'
assert '{:<25r}'.format(q) == '1.420405751786G '
assert '{:^25R}'.format(q) == ' f = 1.420405751786G '
assert '{:25u}'.format(q) == 'Hz '
assert '{:>25.4f}'.format(q) == ' 1420405751.786'
assert '{:<25.4F}'.format(q) == 'f = 1420405751.786 '
assert '{:^25e}'.format(q) == ' 1.420405751786e+09 '
assert '{:25E}'.format(q) == ' f = 1.420405751786e+09'
assert '{:>25g}'.format(q) == ' 1420405751.786'
assert '{:<25G}'.format(q) == 'f = 1420405751.786 '
assert '{:^25n}'.format(q) == ' f '
assert '{:30d}'.format(q) == 'frequency of hydrogen line '
assert '{:>25.2p}'.format(q) == ' 1420405751.79 Hz'
assert '{:<25,.2p}'.format(q) == '1,420,405,751.79 Hz '
assert '{:^25.2P}'.format(q) == ' f = 1420405751.79 Hz '
assert '{:25,.2P}'.format(q) == ' f = 1,420,405,751.79 Hz'
assert '{:#25.3q}'.format(q) == ' 1.420 GHz'
assert '{:#25.6p}'.format(q) == ' 1420405751.786000 Hz'
assert '{:25.0q}'.format(q) == ' 1 GHz'
assert '{:25.0p}'.format(q) == ' 1420405752 Hz'
assert '{:#25.0q}'.format(q) == ' 1 GHz'
assert '{:#25.0p}'.format(q) == ' 1420405752. Hz'
def test_plus_minus():
if sys.version_info.major <= 3:
return
with Quantity.prefs(
spacer=None,
show_label=None,
label_fmt=None,
label_fmt_full=None,
show_desc=False,
prec=4,
plus=Quantity.plus_sign,
minus=Quantity.minus_sign,
map_sf=Quantity.map_sf_to_sci_notation,
):
qpp = Quantity('+1Ms')
qpm = Quantity('+1us')
qmp = Quantity('-1Ms')
qmm = Quantity('-1us')
assert '{}'.format(qpp) == '1 Ms'
assert '{}'.format(qpm) == '1 µs'
assert '{}'.format(qmp) == '−1 Ms'
assert '{}'.format(qmm) == '−1 µs'
assert '{0:e} {0:u}'.format(qpp) == '1e＋06 s'
assert '{0:e} {0:u}'.format(qpm) == '1e−06 s'
assert '{0:e} {0:u}'.format(qmp) == '−1e＋06 s'
assert '{0:e} {0:u}'.format(qmm) == '−1e−06 s'
assert '{:.8p}'.format(qpp) == '1000000 s'
assert '{:.8p}'.format(qpm) == '0.000001 s'
assert '{:.8p}'.format(qmp) == '−1000000 s'
assert '{:.8p}'.format(qmm) == '−0.000001 s'
def test_billow():
Quantity.reset_prefs()
qs = Quantity.extract(r"""
C3 = 250.7nF
f_corner (f₀) = 500mHz
w_corner (ω₀) = 2*pi*f_corner 'rads/s'
Aw = C3*sqrt(w_corner) '√Ω'
""",
predefined=dict(sqrt=math.sqrt))
C3 = qs.pop('C3')
assert str(C3) == '250.7 nF'
assert C3.units == 'F'
assert C3.name == 'C3'
f_corner = qs.pop('f_corner')
assert str(f_corner) == '500 mHz'
assert f_corner.units == 'Hz'
assert f_corner.name == 'f₀'
w_corner = qs.pop('w_corner')
assert str(w_corner) == '3.1416 rads/s'
assert w_corner.units == 'rads/s'
assert w_corner.name == 'ω₀'
Aw = qs.pop('Aw')
assert str(Aw) == '444.35 n√Ω'
assert Aw.units == '√Ω'
assert Aw.name == 'Aw'
assert not qs
def test_linear_conversion():
Quantity.reset_prefs()
conversion = UnitConversion('USD', 'BTC', 100000)
assert str(conversion) == 'USD ← 100000*BTC'
result = conversion.convert(1, 'BTC', 'USD')
assert str(result) == '100 kUSD'
result = conversion.convert(1, 'USD', 'BTC')
assert str(result) == '10 uBTC'
result = conversion.convert(from_units='BTC', to_units='USD')
assert str(result) == '100 kUSD'
result = conversion.convert(from_units='USD', to_units='BTC')
assert str(result) == '10 uBTC'
result = conversion.convert('BTC')
assert str(result) == '100 kUSD'
result = conversion.convert('USD')
assert str(result) == '10 uBTC'
result = conversion.convert(10)
assert str(result) == '1 MUSD'
dollar = Quantity('200000 USD')
bitcoin = conversion.convert(dollar)
assert str(bitcoin) == '2 BTC'
dollar = conversion.convert(bitcoin)
assert str(dollar) == '200 kUSD'
def test_affiliate():
Quantity.reset_prefs()
qs = Quantity.extract(r"""
This is a non conforming line.
Fin = 10MHz -- input frequency
-- Fin = 10MHz -- input frequency
Tstop = 5/Fin "s" -- stop time
This is a non conforming line.
""")
f_in = qs.pop('Fin')
assert f_in.is_close(Quantity(1e7, 'Hz'), check_units=True)
assert f_in.is_close(1e7)
assert f_in.units == 'Hz'
assert f_in.name == 'Fin'
assert f_in.desc == 'input frequency'
t_stop = qs.pop('Tstop')
assert t_stop.is_close(Quantity(5 / f_in, 's'), check_units=True)
assert t_stop.is_close(5 / f_in)
assert t_stop.units == 's'
assert t_stop.name == 'Tstop'
assert t_stop.desc == 'stop time'
assert not qs
def loader(res_file, ind_file, cap_file, res_list, ind_list, cap_list):
# load the values for resistors, capacitors and inductors
# from the component files to the respective lists
with open(res_file) as res:
for line in res:
line = line.strip()
if len(line) != 0:
res_val = Quantity(line)
res_list.append(res_val)
with open(cap_file) as cap:
for line in cap:
line = line.strip()
if len(line) != 0:
cap_val = Quantity(line)
cap_list.append(cap_val)
with open(ind_file) as ind:
for line in ind:
line = line.strip()
if len(line) != 0:
ind_val = Quantity(line)
ind_list.append(ind_val)
return res_list, cap_list, ind_list
def asker():
# ask for the circuit's characteristic parameter
bode = input("input cutoff frequency/omega: [f/w] [value][prefix][unit]: ")
inputs = bode.split()
if len(inputs) == 2:
fw_flag, val = inputs
val_bode = Quantity(val)
elif len(inputs) == 3:
fw_flag, val, unit = inputs
val_bode = Quantity(str(val) + unit)
elif len(inputs) == 4:
fw_flag, val, prefix, unit = inputs
val_bode = Quantity(str(val) + prefix + unit)
# switch the parameter according to the frequency/omega flag
if fw_flag == "w":
omega_bode = float(val_bode)
else:
omega_bode = to_omega(val_bode)
print(f"{fw_flag} ok.")
# ask for the circuit composition
circuit = input("input circuit type: [RC, RL, LC]: ")
c1 = circuit.lower()
circuit = c1.strip()
print(f"{circuit} ok.")
return omega_bode, circuit, fw_flag
def test_README():
if sys.version_info < (3, 6):
# code used in doctests assumes python3.6
return
Quantity.reset_prefs()
rv = doctest.testfile('../README.rst', optionflags=doctest.ELLIPSIS)
assert rv.failed == 0
assert rv.attempted == 29
def process_event(self, event):
super(MainView, self).process_event(event)
if isinstance(event, KeyboardEvent):
if event.key_code in [Screen.KEY_TAB]:
self.timebaseText._value = str(self.timebase)
self.intervalText._value = Quantity(self.interval,
"s").render()
self.rateText._value = Quantity(self.rate, "Hz").render()
self.gateText._value = Quantity(self.gate, "s").render()
def test_basilica():
Quantity.reset_prefs()
qs = Quantity.extract('XAU = 1.9 k$/oz # price of gold on 23 July 2020')
xau = qs.pop('XAU')
assert xau.is_close(Quantity(1900, '$/oz'), check_units=True)
assert xau.is_close(1900)
assert xau.units == '$/oz'
assert xau.name == 'XAU'
assert xau.desc == 'price of gold on 23 July 2020'
assert not qs
def calculateAndDisplayRMSVoltage(self):
data = self.widgetDigitizedView.getDigitizedData()
data = self.widgetCursorControl.getZero_pixels() - data
data = data * self.getVoltsPerPixel()
rms = np.sqrt(np.mean(np.square(data)))
rms = Quantity(rms, "V")
rmsAC = np.sqrt(np.mean(np.square(data - np.mean(data))))
rmsAC = Quantity(rmsAC, "V")
self.labelVRMS_Display.setText(str(rms))
self.labelVRMSAC_Display.setText(str(rmsAC))
def test_reader():
Quantity.reset_prefs()
with Quantity.prefs(known_units='Zippy'):
for line in data1.splitlines():
v, s1, s2, s3, s4, s5 = [
c.strip() for c in line.strip().split(';')
]
print('Trying: v={v}, s1={s1}, s2={s2}, s3={s3}, s4={s4}, s5={s5}'.
format(**locals()))
q = Quantity(v, binary=True)
res = str(q)
exp = '{v}: expected <{s1}>, got <{res}>.'.format(**locals())
assert s1 == res, exp
res = q.binary()
exp = '{v}: expected <{s2}>, got <{res}>.'.format(**locals())
assert s2 == res, exp
res = q.binary(prec=4, strip_zeros=False)
exp = '{v}: expected <{s3}>, got <{res}>.'.format(**locals())
assert s3 == res, exp
res = q.binary(strip_zeros=True,
strip_radix=False,
show_units=False)
exp = '{v}: expected <{s4}>, got <{res}>.'.format(**locals())
assert s4 == res, exp
res = q.binary(prec='full', strip_zeros=False)
exp = '{v}: expected <{s5}>, got <{res}>.'.format(**locals())
assert s5 == res, exp
def test_writer_prec():
Quantity.reset_prefs()
for line in data2.splitlines():
v, p0, p1, p2, p3, p4 = [c.strip() for c in line.strip().split(';')]
print('Trying: v={v}, p0={p0}, p1={p1}, p2={p2}, p3={p3}, p4={p4}'.
format(**locals()))
q = Quantity(v)
res = q.binary(prec=0)
exp = '{v}: expected <{p0}>, got <{res}>.'.format(**locals())
assert res == p0, exp
res = q.binary(prec=1)
exp = '{v}: expected <{p1}>, got <{res}>.'.format(**locals())
assert res == p1, exp
res = q.binary(prec=2)
exp = '{v}: expected <{p2}>, got <{res}>.'.format(**locals())
assert res == p2, exp
res = q.binary(prec=3)
exp = '{v}: expected <{p3}>, got <{res}>.'.format(**locals())
assert res == p3, exp
res = q.binary(prec=4)
exp = '{v}: expected <{p4}>, got <{res}>.'.format(**locals())
assert res == p4, exp
def test_bulletin():
qs = Quantity.extract(r"""
Fclk = 50MHz # clock frequency
""")
f_clk = qs.pop('Fclk')
assert f_clk.is_close(Quantity(5e7, 'Hz'), check_units=True)
assert f_clk.is_close(5e7)
assert f_clk.units == 'Hz'
assert f_clk.name == 'Fclk'
assert f_clk.desc == 'clock frequency'
assert not qs
def test_wager():
qs = Quantity.extract(r"""
Fclk ($F_{\rm clk}$) = 50MHz -- clock frequency
""")
f_clk = qs.pop('Fclk')
assert f_clk.is_close(Quantity(5e7, 'Hz'), check_units=True)
assert f_clk.is_close(5e7)
assert f_clk.units == 'Hz'
assert f_clk.name == r'$F_{\rm clk}$'
assert f_clk.desc == 'clock frequency'
assert not qs
def test_anatomy():
Quantity.reset_prefs()
qs = Quantity.extract(
r"""
Rin = ∞Ω -- input resistance
""", )
Rin = qs.pop('Rin')
assert float(Rin) == float('inf')
assert Rin.units == 'Ω'
assert Rin.is_infinite() == 'inf'
assert not qs
def test_deduce():
qs = Quantity.extract(r"""
Fclk = 50MHz
""")
f_clk = qs.pop('Fclk')
assert f_clk.is_close(Quantity(5e7, 'Hz'), check_units=True)
assert f_clk.is_close(5e7)
assert f_clk.units == 'Hz'
assert f_clk.name == 'Fclk'
assert f_clk.desc == ''
assert not qs
def test_disallow():
Quantity.reset_prefs()
qs = Quantity.extract(
r"""
rate = 64GiB/s -- bit rate
""",
binary=True,
)
rate = qs.pop('rate')
assert float(rate) == 68719476736
assert rate.units == 'B/s'
assert not qs
def test_proof():
Quantity.reset_prefs()
qs = Quantity.extract(r"""
$F_{\rm clk}$ = 50MHz -- clock frequency
""")
f_clk = qs.pop(r'$F_{\rm clk}$')
assert f_clk.is_close(Quantity(5e7, 'Hz'), check_units=True)
assert f_clk.is_close(5e7)
assert f_clk.units == 'Hz'
assert f_clk.name == r'$F_{\rm clk}$'
assert f_clk.desc == 'clock frequency'
assert not qs
def test_roomful():
Quantity.reset_prefs()
qs = Quantity.extract(r"""
Fclk: 50MHz // clock frequency
""")
f_clk = qs.pop('Fclk')
assert f_clk.is_close(Quantity(5e7, 'Hz'), check_units=True)
assert f_clk.is_close(5e7)
assert f_clk.units == 'Hz'
assert f_clk.name == 'Fclk'
assert f_clk.desc == 'clock frequency'
assert not qs
def _plot(self):
# create plot
fig = plt.figure()
ax = plt.subplot(111)
ax.scatter(self.times,
self.frequencies,
color="#00A2FF",
label='Frequency')
# grid
plt.grid(b=True,
which='major',
color='k',
linestyle='-',
alpha=0.2,
linewidth=0.3)
plt.grid(b=True,
which='minor',
color='k',
linestyle='-',
alpha=0.15,
linewidth=0.15)
plt.minorticks_on()
# limits
#ax.set_xlim([freq.min(),freq.max()])
#plt.xticks([0,len(freq)], freq)
# layout
fig.set_tight_layout(True)
plt.rcParams.update({'font.size': 8})
avg = Quantity(self.frequencies.mean(), "Hz")
avg = SetPrecisionToResolution(avg, self.resolution / 10.0)
std = Quantity(self.frequencies.std(), "Hz")
ax.annotate(
"Sample rate: %s, gate time: %s\nmean: %s, std: %s" %
(Quantity(self.rate, "Hz").render(), Quantity(
self.gate, "s").render(), avg.render(), std.render()),
xy=(1, 0),
xycoords='axes fraction',
fontsize=8,
xytext=(-5, 5),
textcoords='offset points',
ha='right',
va='bottom')
# axis labels
plt.xlabel("Time [s]")
plt.ylabel("Frequency [Hz]")
#PYTHON....There's a matplotlib bug coming up here'
with warnings.catch_warnings():
warnings.simplefilter(action='ignore', category=FutureWarning)
plt.show()
def test_workout():
qs = Quantity.extract(r"""
Fclk = 50MHz -- clock frequency
This is an arbitrary line of text.
This is an line of text that: triggers the line processing but still should be ignored..
""")
f_clk = qs.pop('Fclk')
assert f_clk.is_close(Quantity(5e7, 'Hz'), check_units=True)
assert f_clk.is_close(5e7)
assert f_clk.units == 'Hz'
assert f_clk.name == 'Fclk'
assert f_clk.desc == 'clock frequency'
assert not qs
def _interval_changed(self):
try:
Quantity(self.intervalText.value)
except:
return
self.timebase, self.interval = self._get_timebase(
Quantity(self.intervalText.value).real)
self.rate = 1 / self.interval
self.timebaseText._value = str(self.timebase)
self.rateText._value = Quantity(self.rate, "Hz").render()
self._set_resolution()
def timer(label=None):
from quantiphy import Quantity
from time import time
global start_time, last_time
t = time()
if label:
print('{label}: delta = {delta}, cumulative = {elapsed}'.format(
label,
elapsed=Quantity(t - start_time, 's'),
delta=Quantity(t - last_time, 's'),
))
else:
start_time = t
last_time = t
def transaction(self, tokens, date=None, comment='', fees=0, source=None):
t = self.Transaction(tokens, date, comment, fees, source)
ident = t.ident()
assert ident not in self.transactions, f'{ident} not unique'
self.transactions[ident] = t
kind = tokens.name()
num_tokens = float(tokens)
self.totals[kind] = Quantity(num_tokens + self.totals.get(kind, 0),
units=tokens.UNITS)
self.costs[kind] = Dollars(t.proceeds + self.costs.get(kind, 0))
if t.proceeds > 0:
self.purchased[kind] = Quantity(
num_tokens + self.purchased.get(kind, 0), tokens.UNITS)
return t
