def test_create():
test_cui = py_cui.PyCUI(4, 5, simulated_terminal=[30, 100])
assert test_cui._height == 26
assert test_cui._width == 100
assert test_cui._title_bar.get_text().strip() == 'PyCUI Window'
assert test_cui._simulated_terminal == [30, 100]
assert test_cui._exit_key == py_cui.keys.KEY_Q_LOWER
def main():
"""Program entrypoint, create CUI, wrapper object and start it
"""
root = py_cui.PyCUI(4, 7)
root.set_title('2048')
root.toggle_unicode_borders()
cui_2048 = CUI2048(root)
root.start()
def main():
root = py_cui.PyCUI(7, 7)
is_admin = check_admin_status()
if is_admin:
root.set_title(f'UniPkg {__version__} - Administrator')
else:
root.set_title(f'UniPkg {__version__}')
root.toggle_unicode_borders()
_ = UniPkgManager(root)
root.enable_logging()
root.start()
def test_add_text_box():
test_cui = py_cui.PyCUI(4, 5, simulated_terminal=[30, 100])
test_cui.add_text_box('Demo', 1, 1)
assert len(test_cui.get_widgets().keys()) == 1
for key in test_cui.get_widgets().keys():
assert key == 'Widget0'
break
widget = test_cui.get_widgets()['Widget0']
assert isinstance(widget, py_cui.widgets.TextBox)
assert widget.get_id() == 'Widget0'
row, col = widget.get_grid_cell()
assert row == 1
assert col == 1
def main():
"""Entry point for pyautogit. Parses arguments, and initializes the CUI
"""
target, credentials, args = parse_args()
save_metadata = not args['nosavemetadata']
debug_logging = args['debug']
target_abs = os.path.abspath(target)
input_type = 'repo'
if not is_git_repo(target):
input_type = 'workspace'
# Make sure we have write permissions
if not os.access(target, os.W_OK):
print('ERROR - Permission error for target {}'.format(target_abs))
exit(-1)
if input_type == 'repo' and not os.access(os.path.dirname(target_abs),
os.W_OK):
print(
'ERROR - Permission denied for parent workspace {} of repository {}'
.format(os.path.dirname(target_abs), target_abs))
exit(-1)
if debug_logging:
if input_type == 'repo':
LOGGER.set_log_file_path('../.pyautogit/{}.log'.format(
str(datetime.datetime.today()).split(' ')[0]))
else:
LOGGER.set_log_file_path('.pyautogit/{}.log'.format(
str(datetime.datetime.today()).split(' ')[0]))
LOGGER.toggle_logging()
LOGGER.write('Initialized debug logging')
root = py_cui.PyCUI(5, 4)
if debug_logging:
root.enable_logging(log_file_path='.pyautogit/py_cui_root.log')
# Use feature added in py_cui 0.0.3 to add unicode widget borders
root.toggle_unicode_borders()
_ = PyAutogitManager(root, target, input_type, save_metadata, credentials)
LOGGER.write('Parsed args. Target location - {}'.format(target_abs))
LOGGER.write('Initial state - {}'.format(input_type))
LOGGER.write('Initialized manager object, starting CUI...')
root.start()
def draw_player():
"""
TUI driver
"""
root = py_cui.PyCUI(5, 7, auto_focus_buttons=True)
root.set_title(f"CUI Audio Player - v{VERSION_TAG}")
root.set_widget_border_characters("╔", "╗", "╚", "╝", "═", "║")
root.set_refresh_timeout(0.1)
# this don't have to be a second. Might be an example of downside of ABC
player_ref = AudioPlayer(root)
assert player_ref
# Preventing unused variable check
root.start()
def __init__(self):
super().__init__()
self.root = py_cui.PyCUI(3, 3)
self.widget_set_A = self.root.create_new_widget_set(3, 3)
self.widget_set_A.add_button('2nd window',
1,
1,
command=self.open_set_B)
self.root.apply_widget_set(self.widget_set_A)
self.widget_set_B = self.root.create_new_widget_set(5, 5)
self.text_box_B = self.widget_set_B.add_text_box('Test',
0,
0,
column_span=2)
self.text_box_B.add_key_command(py_cui.keys.KEY_ENTER, self.open_set_A)
#!/usr/bin/env python3
import py_cui
class App:
def __init__(self, master):
self.master = master
self.g1 = self.master.add_scroll_menu('GRID1',
0, 0, row_span=6, column_span=2)
self.g4 = self.master.add_slider('slider', 6, 0, row_span=1,
column_span=6, padx=1, pady=0,
min_val=8, max_val=100, step=5,
init_val=20)
# update slider
self.g4.set_slider_step(3)
root = py_cui.PyCUI(9,6)
root.set_title('Test Slider')
s = App(root)
root.start()
# this is some hacky shit so that no item is selected and you don't see the first lines marked in every widget. This does not work after refresh.
self.todo_scroll_cell.set_selected_item_index(-1)
self.in_progress_scroll_cell.set_selected_item_index(-1)
self.done_scroll_cell.set_selected_item_index(-1)
# these are the texts for each widget that are shown at the bottom border of the TUI
self.todo_scroll_cell.set_focus_text(
'FUNNEL | ESC - OverView | ENTER - move to DOING')
self.in_progress_scroll_cell.set_focus_text(
'DOING | ESC - OverView | ENTER - move to DONE')
self.done_scroll_cell.set_focus_text(
'DONE | ESC - OverView | DEL - remove selected item')
root = py_cui.PyCUI(8, 6)
if(config['debug']):
root.enable_logging(logging_level=logging.ERROR)
if(config['unicode_borders']):
root.toggle_unicode_borders()
# this text is shown in overview mode at the bottom border of the TUI
root.set_status_bar_text(
'q - quit | TAB - cycle through widgets | f - find and mark | r - refresh | o - open TODO.txt')
# set some titles...
root.set_title('TodoTxTui')
s = SimpleTodoList(root)
root.start()
import textwrap
import py_cui
from functools import partial
def get_str_type(value):
if isinstance(value, np.ndarray):
return (f'{type(value)} of shape {value.shape}')
else:
return type(value)
menu_width = 4
jdata = joblib.load(sys.argv[1])
root = py_cui.PyCUI(2, 10)
class MenuOperator():
def __init__(self, data):
self.data = data
self.stack = []
self.select = []
self.menu = root.add_scroll_menu("Title",
0,
0,
row_span=1,
column_span=menu_width,
padx=1,
pady=0)
self.text = root.add_text_block("Info",
def main():
root = py_cui.PyCUI(3, 3)
wrapper = Pyk3uiApp(root)
root.start()
import py_cui
root = py_cui.PyCUI(10, 10)
root.add_button("Quit", 0, 0, command=exit)
root.add_label("info", 5, 0)
cb = root.add_checkbox_menu("Box", 3, 5)
cb.add_item("test1")
cb.add_item("test2")
root.add_label("info2", 8, 0)
root.add_label("info2", 5, 5)
root.add_label("info2", 0, 8)
root.add_label("info2", 0, 5)
root.start()
def __init__(self, device: Controller, config_file=""):
self.labels = [
"Current range: {}, Voltage: {}, Mode: {}",
"DC/DC Converter: {}",
"Pulse generation: {}",
"Number of n-plets: {}",
"Time between pulses: {}ms",
"N-plet repetition rate: {}pps",
"Delay after trigger: {}ms",
"Pulse widths: {} (unit: μs)",
"Pulse amplitudes: {} (unit: mA)",
"Output channels (unipolar): {}",
"Channel pairs (bipolar): {}",
"Battery: {}%",
"Common electrode: {}",
"Pulse generation parameters possible: {}"
]
self.device = device
self.master = py_cui.PyCUI(30, 10)
self.master.set_title("Bimatrix controller (Battery: {}%)".format(device.read_battery()))
span = 5
self.stats = self.master.add_block_label(self.labels[0].format(
device.current_range, device.voltage, device.mode),
0, 0, column_span=span, center=False)
self.converter = self.master.add_block_label(self.labels[1].format(self._bool_to_string(
device.pulse_generator_dc_converter_status)),
1, 0, column_span=span, center=False)
self.pulse_generation = self.master.add_block_label(self.labels[2].format(self._bool_to_string(
device.pulse_generator_triggered)),
2, 0, column_span=span, center=False)
self.num_nplet = self.master.add_block_label(self.labels[3].format(
device.num_nplets if device.num_nplets != 0 else "0 (Infinite)"),
3, 0, column_span=span, center=False)
self.electrode = self.master.add_block_label(self.labels[12].format(device.common_electrode),
0, 5, column_span=span, center=False)
self.time_between = self.master.add_block_label(self.labels[4].format(device.time_between),
1, 5, column_span=span, center=False)
self.repetition_rate = self.master.add_block_label(self.labels[5].format(device.repetition_rate),
2, 5, column_span=span, center=False)
self.delay = self.master.add_block_label(self.labels[6].format(device.delay),
3, 5, column_span=span, center=False)
self.valid = self.master.add_block_label(self.labels[13].format(False),
4, 0, column_span=5, center=False)
self.widths = self.master.add_block_label(self.labels[7].format(device.pulse_widths),
5, 0, column_span=10, center=False)
self.amplitudes = self.master.add_block_label(self.labels[8].format(
self._calculate_amplitudes(device.pulse_amplitudes, device.mode)),
6, 0, column_span=10, center=False)
self.outputs = self.master.add_block_label(self.labels[9].format(device.output_channels),
7, 0, column_span=10, center=False)
self.pairs = self.master.add_block_label(self.labels[10].format(device.channel_pairs),
8, 0, column_span=10, center=False)
self.command_prompt = self.master.add_text_box("Command: ", 29, 0, column_span=10)
self.command_history = self.master.add_scroll_menu("Command history", 17, 0, row_span=11, column_span=10)
self.command_list = self.master.add_scroll_menu("Commands", 9, 0, row_span=8, column_span=10)
commands = [
"battery: Update battery information",
"mode <mode>: Set stimulatio mode (unipolar or bipolar)",
"range <range>: ",
"voltage <voltage>: Set voltage in Volts (70-150)",
"dc: trigger dc converter, dc <status>: set dc converter on or off",
"trigger: trigger pulse generator (activate stimulation)",
"nplets <num>: set the number of n-plets to be generated (0 [Infinity] - 16777215)",
"time_between <time>: set time between pulses in ms (1-255)",
"repetition_rate <rate>: set repetition rate in nplets-per-second (1-400)",
"delay <delay>: set stimulation delay after trigger in ms (0 - 16777215)",
"widths [widths]: set width for every pulse, each width separated by space",
"amplitudes [amplitudes]: set amplitude for every pulse, list of comma separated values. " +
"high: x/10 mA, low: x/100 mA",
"output [channels]: list of channels in format x,y,z;i,j,k",
"pairs [channels]: list of channels pairs in format x;y x;y",
"common_electrode: set common electrode to cathode or anode",
]
self.command_list.add_item_list(commands)
self.command_prompt.add_key_command(py_cui.keys.KEY_ENTER, self.send_command)
self.master.add_key_command(py_cui.keys.KEY_A_LOWER, self.increase_amplitudes)
self.master.add_key_command(py_cui.keys.KEY_Z_LOWER, self.decrease_amplitudes)
self.master.add_key_command(py_cui.keys.KEY_S_LOWER, self.increase_widths)
self.master.add_key_command(py_cui.keys.KEY_X_LOWER, self.decrease_widths)
self.master.add_key_command(py_cui.keys.KEY_D_LOWER, self.increase_repetition_rate)
self.master.add_key_command(py_cui.keys.KEY_C_LOWER, self.decrease_repetition_rate)
self.master.add_key_command(py_cui.keys.KEY_F_LOWER, self.increase_time_between)
self.master.add_key_command(py_cui.keys.KEY_V_LOWER, self.decrease_time_between)
if config_file:
f = open(config_file, "r")
for line in f:
out = self._parse_input(line)
self.command_history.add_item(out)
self.master.start()
s.connect((ip, port))
s.close()
return True
except Exception as e: # Must be generic as socket exception class does not inherit from BaseException... why?!
return False
if __name__ == "__main__":
if not os.path.exists(CONFIG_FILE[0]):
CONFIG_FILE[0] = CONFIG_FILE[1]
with open(CONFIG_FILE[0], 'r') as f:
JSON_DATA = json.load(f)
root = py_cui.PyCUI(24, 16)
root.set_refresh_timeout(1)
# tcpQueryWidget = TCPQueryWidget.from_ip_data(JSON_DATA['tcp_monitoring'][0],
# root=root, row=0, col=0, col_span=3, row_span=1)
tcpQueryWidgets: List[TCPQueryWidget] = []
row = 0
col = 0
col_span = 3
row_span = 1
for ip_data in JSON_DATA['tcp_monitoring']:
tcpQueryWidgets.append(
TCPQueryWidget.from_ip_data(
def _WIDGETSET(rows, cols, height, width):
return py_cui.widget_set.WidgetSet(rows,
cols,
LOGGER,
root=py_cui.PyCUI(rows, cols),
simulated_terminal=[height, width])
def parse_args():
# Parse some basic arguments (requires target directory)
parser = argparse.ArgumentParser(
description='An extension on nano for editing directories in CLI.')
parser.add_argument('directory', help='Target directory to edit.')
args = vars(parser.parse_args())
if 'directory' not in args.keys():
return '.'
elif not os.path.exists(args['directory']):
print('ERROR - {} path does not exist'.format(args['directory']))
exit()
elif not os.path.isdir(args['directory']):
print('ERROR - {} is not a directory'.format(args['directory']))
exit()
return args['directory']
# Collect some argument information
dir = parse_args()
# Initialize the PyCUI object, and set the title
root = py_cui.PyCUI(7, 8)
root.set_title('Super Nano v{}'.format(__version__))
# Create the wrapper instance object.
frame = SuperNano(root, dir)
# Start the CUI
root.start()
def _PYCUI(rows, cols, height, width):
return py_cui.PyCUI(rows, cols, simulated_terminal=[height, width])
text = list(visualizer(data))
num_per_char = visualizer.num_per_ch
quotient = 0
for quotient_ in itertools.count(1):
if quotient_ * num_per_char > -min_:
quotient = quotient_
break
if not quotient:
for line_idx in range(0, len(text) - 1):
text[line_idx] += f" _ {min_ + num_per_char * (len(text) - 1 - line_idx)}"
else:
for idx, multiplier in zip(reversed(range(len(text))), range(-quotient, len(text))):
text[idx] += f"_ {multiplier * num_per_char}"
text.append("| " * (len(self._data) // 2))
draw_target.set_text("\n".join(text))
if __name__ == "__main__":
root = py_cui.PyCUI(5, 2)
ref = Main(root)
root.set_widget_border_characters("╔", "╗", "╚", "╝", "═", "║")
root.set_refresh_timeout(0.1)
root.start()
# to not block the draw calls.
self.master.show_loading_icon_popup('Please Wait', 'Loading')
operation_thread = threading.Thread(target=self.long_operation)
operation_thread.start()
def show_loading_bar(self):
""" Function that shows the usage for spawning a loading bar popup """
self.master.show_loading_bar_popup('Incrementing a counter...', 100)
operation_thread = threading.Thread(target=self.long_operation)
operation_thread.start()
def long_operation(self):
""" A simple function that demonstrates a long callback operation performed while loading popup is open """
counter = 0
for i in range(0, 100):
time.sleep(0.1)
counter= counter +1
self.master.status_bar.set_text(str(counter))
# When using a bar indicator, we will increment the completed counter
self.master.increment_loading_bar()
self.master.stop_loading_popup()
# Create the CUI, pass it to the wrapper object, and start it
root = py_cui.PyCUI(3, 3)
root.set_title('CUI Popups Example')
s = PopupExample(root)
root.start()
def run_tui(article_list):
root = py_cui.PyCUI(8, 8)
root.set_title("KCK RSS Reader")
s = TUI(root, article_list, width=root._width)
root.start()
