def print_goal(goal, achieved=False, level=None, indent=2):
""" Print a goals description with its icon. Achieved (True/False) will choose the correct icon
from the goal. If a level is specified, a tracker line will be added under the icon showing
the current level out of the required level for the goal. If level is > the required level,
achieved will be set to true.
"""
from clint.textui import puts
from clint.textui import indent as _indent
from clint.textui.cols import columns, console_width
if level is not None and level >= goal['level']:
achieved = True
icon = (goal['icon'].achieved() if achieved else goal['icon'].unachieved()).split('\n')
maxiw = max([len(str(_)) for _ in icon])
descw = console_width({})-maxiw-(indent + 4)
desc = '{0}\n{1}\n\n{2}'.format(goal['name'], '-'*len(goal['name']),
columns([goal['description'], descw])).split('\n')
if level is not None:
if level > goal['level']:
level = goal['level']
maxitw = max([len(_) for _ in icon])
icon.append(("%d/%d" % (level, goal['level'])).center(maxitw))
with _indent(indent):
for i, d in _zip_longest(icon, desc):
puts("{1:{0}} {2}".format(maxiw, str(i) if i is not None else "",
d.strip() if d is not None else ""))
def print_goal(goal, achieved=False, level=None, indent=2):
""" Print a goals description with its icon. Achieved (True/False) will choose the correct icon
from the goal. If a level is specified, a tracker line will be added under the icon showing
the current level out of the required level for the goal. If level is > the required level,
achieved will be set to true.
"""
from clint.textui import puts
from clint.textui import indent as _indent
from clint.textui.cols import columns, console_width
if level is not None and level >= goal['level']:
achieved = True
icon = (goal['icon'].achieved()
if achieved else goal['icon'].unachieved()).split('\n')
maxiw = max([len(str(_)) for _ in icon])
descw = console_width({}) - maxiw - (indent + 4)
desc = '{0}\n{1}\n\n{2}'.format(goal['name'], '-' * len(goal['name']),
columns([goal['description'],
descw])).split('\n')
if level is not None:
if level > goal['level']:
level = goal['level']
maxitw = max([len(_) for _ in icon])
icon.append(("%d/%d" % (level, goal['level'])).center(maxitw))
with _indent(indent):
for i, d in _zip_longest(icon, desc):
puts("{1:{0}} {2}".format(maxiw,
str(i) if i is not None else "",
d.strip() if d is not None else ""))
def _parse_log(self):
#parse the log for information, see readme for how to setup SpeedFan output so that the script
lw.log(['started parsing log'])
lw.log(['read the log file'])
first, last = self._read_log_file()
temps = []
speeds = []
voltages = []
percents = []
others = []
if first == '' or last == '':
return temps, speeds, voltages, percents, others
#pair up the heading with the value
lw.log(['pair up the heading with the value'])
for s_item, s_value in _zip_longest(first.split('\t'),
last.split('\t')):
item_type = s_item.split('.')[-1].rstrip().lower()
item_text = os.path.splitext(s_item)[0].rstrip()
#round the number, drop the decimal and then covert to a string
#skip the rounding for the voltage and other readings
if item_type == 'voltage' or item_type == 'other':
s_value = s_value.rstrip()
else:
try:
s_value = str(int(round(float(s_value.rstrip()))))
except ValueError:
s_value = str(
int(round(float(s_value.rstrip().replace(',', '.')))))
if item_type == "temp":
lw.log(['put the information in the temperature array'])
if self.TEMPSCALE == 'Celcius':
temps.append([item_text + ':', s_value + 'C'])
else:
temps.append([
item_text + ':',
str(int(round((float(s_value) * 1.8) + 32))) + 'F'
])
elif item_type == "speed":
lw.log(['put the information in the speed array'])
speeds.append([item_text + ':', s_value + 'rpm'])
elif item_type == "voltage":
lw.log(['put the information in the voltage array'])
voltages.append([item_text + ':', s_value + 'v'])
elif item_type == "percent":
lw.log(['put the information in the percent array'])
percents.append([item_text, s_value + '%'])
elif item_type == "other":
lw.log(['put the information in the other array'])
others.append([item_text + ":", s_value])
lw.log([
temps, speeds, voltages, percents, others,
'ended parsing log, displaying results'
])
return temps, speeds, voltages, percents, others
def path_range(start_path, end_path):
'Yield a sequence of paths from start_path (inclusive) to end_path (exclusive).'
# TODO: more descriptive name.
start = path_split(start_path)
end = path_split(end_path)
accum = []
for s, e in _zip_longest(start, end):
if s:
if s != e:
raise ValueError('paths diverge: start {!r}; end: {!r}'.format(s, e))
else:
yield path_join(*accum)
accum.append(e)
def extract_data_report(filename):
"""
@param filename: name of data report to open
@type filename: str
@return: headers and data from data report
@rtype: (list[str], list[str])
"""
with open(filename, 'r') as f:
headers = f.readline().split(',')
data = f.read().splitlines()
data = _zip_longest(*map(str.split, data, _repeat(',')), fillvalue='')
return headers, data
def main(path: _t.Optional[_t.Union[str, _Path]] = None) -> None:
"""Parse README from commandline argument.
Initialize ``Holder`` to contain expected, actual, and total values.
Enumerate over parsed ``Readme`` and populate the three containers.
1. Expected ``list`` from the README file directly
2. Actual from the actual command output
3. Total with a combination of both plus code-block headings
Run assertions on the actual and expected commands and print output
from the total ``list``.
Clear and initialize base key-values on each iteration.
If no errors are raised then print that the README is a success and
there are no errors in testing.
:raises OutputDocumentError: Raise if the expected ``list`` contains
nothing even though command output was captured.
"""
if path is None:
parser = _Parser()
path = parser.file
holder = _Holder()
_assert.syntax(path)
readme = _Readme()
readme.load(path)
_assert.code_blocks(readme)
if _exec_status.in_exec:
print("recursive exec not implemented")
else:
for count, element in enumerate(readme, 1):
code_block = f"code-block {count}"
holder.total.append_header(code_block)
_process(element, holder)
for position, _ in enumerate(
_zip_longest(holder.actual, holder.expected)):
actual, expected = holder.getpair(position)
_assert.actual_expected(actual, expected, code_block)
_assert.equality(actual, expected, code_block)
holder.display()
def __eq__(self, other):
if isinstance(other, OrderedDict):
return all(p==q for p, q in _zip_longest(self.items(), other.items()))
return dict.__eq__(self, other)
def zip_longest(fill_value, it1, it2):
return _zip_longest(it1, it2, fillvalue=fill_value)
def __eq__(self, other):
if isinstance(other, OrderedDict):
return all(p == q
for p, q in _zip_longest(self.items(), other.items()))
return dict.__eq__(self, other)
_redirect_stdout = redirect_stdout(captured_stdout)
_redirect_stdout.__enter__()
#################################
# main # only copy this section #
#################################
def solve(a, b):
print(a + b)
print(a)
T = int(input())
for _ in range(T):
a = int(input())
b = int(input())
solve(a, b)
######################################
# output # compare with 'output.txt' #
######################################
_redirect_stdout.__exit__(None, None, None)
with open('output.txt', 'r') as f:
out = f.read()
for x, y in _zip_longest(captured_stdout.getvalue().splitlines(),
out.splitlines()):
print('\n'.join(Differ().compare([x], [y])))
def grouper(iterable, n, fillvalue=None):
"""Itertools group recipe"""
args = [iter(iterable)] * n
return _zip_longest(*args, fillvalue=fillvalue)
