def reload_file(sim_bridge=Inject('gearbox/sim_bridge'),
script_fn=Inject('gearbox/model_script_name'),
layout=Inject('gearbox/layout')):
if script_fn:
bind('gearbox/main/new_model_script_fn', script_fn)
close_file()
def __init__(self,
top=None,
live=True,
reload=True,
standalone=False,
sim_queue=None):
QtCore.QObject.__init__(self)
self.loop = QtCore.QEventLoop(self)
bind('sim/gearbox', self)
# self.queue = sim_queue
# if self.queue is None:
# self.queue = queue.Queue()
self.breakpoints = set()
self.live = live
self.done = False
self.reload = reload
self.standalone = standalone
self.running = False
self.thrd = QtCore.QThread()
self.moveToThread(self.thrd)
self.thrd.started.connect(self.run)
self.thrd.start()
def gktwave_delete(timekeep=Inject('gearbox/timekeep')):
print('Gtkwave deleted')
gtkwave = registry('gearbox/gtkwave/inst')
timekeep.timestep_changed.disconnect(gtkwave.update)
for b in gtkwave.buffers:
b.delete()
bind('gearbox/gtkwave/inst', None)
def __init__(self,
cont_refresh_step=100,
sim_bridge=Inject('gearbox/sim_bridge')):
super().__init__()
self._timestep = None
self._time_target = None
self._cont_refresh_step = cont_refresh_step
bind('gearbox/timestep', self.max_timestep)
sim_bridge.after_timestep.connect(self.sim_break)
sim_bridge.after_cleanup.connect(self.sim_break)
sim_bridge.model_closed.connect(self.model_closed)
sim_bridge.script_loaded.connect(self.model_loaded)
def timestep(self, val, sim_bridge=Inject('gearbox/sim_bridge')):
if (self.max_timestep is None) or (val > self.max_timestep):
self._time_target = val
self._timestep = self.max_timestep
sim_bridge.breakpoint(self.break_on_timestep)
if not sim_bridge.running:
sim_bridge.cont()
else:
if val != self._timestep:
self._timestep = val
bind('gearbox/timestep', self._timestep)
print("Timestep changed")
self.timestep_changed.emit(self._timestep)
def open_file_interact(
sim_bridge=Inject('gearbox/sim_bridge'),
prev_script_fn=Inject('gearbox/model_script_name'),
):
ret = QtWidgets.QFileDialog.getOpenFileName(
caption='Open file',
dir=os.getcwd(),
filter="PyGears script (*.py);;All files (*)")
script_fn = ret[0]
if script_fn:
if prev_script_fn:
bind('gearbox/main/new_model_script_fn', script_fn)
close_file()
else:
registry('gearbox/sim_bridge').invoke_method('run_model',
script_fn=script_fn)
def run_model(self, script_fn):
artifacts_dir = registry('sim/artifacts_dir')
if not artifacts_dir:
artifacts_dir = os.path.join(os.path.dirname(script_fn), 'build')
bind('sim/artifacts_dir', artifacts_dir)
print(f"Artifacts dir: {artifacts_dir}")
os.makedirs(artifacts_dir, exist_ok=True)
sys.path.append(os.path.dirname(script_fn))
# config['trace/ignore'].append(os.path.dirname(__file__))
config['trace/ignore'].append(runpy.__file__)
compilation_log_fn = os.path.join(artifacts_dir, 'compilation.log')
bind('gearbox/compilation_log_fn', compilation_log_fn)
bind('svgen/debug_intfs', ['*'])
os.system(f'rm -rf {compilation_log_fn}')
# import pdb; pdb.set_trace()
old_handlers = {}
for name in registry('logger'):
if name in logging.root.manager.loggerDict:
logger = logging.getLogger(name)
old_handlers[name] = logger.handlers.copy()
logger.handlers.clear()
logger.addHandler(
logger.get_logger_handler(
logging.FileHandler(compilation_log_fn)))
bind('gearbox/model_script_name', script_fn)
self.script_loading_started.emit()
self.err = None
self.cur_model_issue_id = None
try:
runpy.run_path(script_fn)
except Exception as e:
self.err = e
self.script_loaded.emit()
if not self.err:
root = registry('gear/hier_root')
if not root.child:
self.err = EmptyHierarchy('No PyGears model created')
exc_info = fake_exc_info((EmptyHierarchy, self.err, None),
script_fn, 0)
self.err = self.err.with_traceback(exc_info[2])
if self.err is not None:
pygears_excepthook(type(self.err), self.err,
self.err.__traceback__)
if self.err is None:
self.invoke_method('run_sim')
def main_loop(script_fn, layers=Inject('gearbox/layers')):
import faulthandler
faulthandler.enable(file=open('err.log', 'w'))
bind('gearbox/main/new_model_script_fn', None)
sys_args = sys.argv.copy()
# bind('gearbox/main/argv', sys_args)
load_rc('.gearbox', os.getcwd())
# app = QtWidgets.QApplication(sys.argv)
app = Application(sys_args)
with open(os.path.join(os.path.dirname(__file__), 'default.css')) as f:
stylesheet = f.read()
app.setStyleSheet(themify(stylesheet))
app.setWindowIcon(QtGui.QIcon('gearbox.png'))
app.setFont(QtGui.QFont("DejaVu Sans Mono", 10))
main_window = MainWindow()
main_window.setWindowTitle(f'Gearbox')
sim_bridge_inst = sim_bridge()
sim_bridge_inst.script_loading_started.connect(set_main_win_title)
sim_bridge_inst.script_loading_started.connect(load)
for l in layers:
l()
if script_fn:
load_rc('.pygears', os.path.dirname(script_fn))
sim_bridge_inst.invoke_method('run_model', script_fn=script_fn)
main_window.show()
ret = app.exec_()
script_fn = registry('gearbox/main/new_model_script_fn')
if script_fn:
print('Quitting: ', sys_args)
print(('gearbox', sys_args[0], script_fn))
os.execl(sys_args[0], 'gearbox', script_fn)
else:
sys.exit(ret)
def change_domain(self, domain):
current_menu = self.menuBar()
prev_domain = registry('gearbox/domain')
if prev_domain:
action = self.get_subaction(current_menu,
registry('gearbox/domain').title())
if action:
action.setVisible(False)
bind('gearbox/domain', domain)
if domain:
action = self.get_subaction(current_menu, domain.title())
if action:
action.setVisible(True)
self.domain_changed.emit(domain)
def graph_create(self, root=Inject('gear/hier_root')):
view = Graph()
bind('gearbox/graph', view)
# rtl_root = rtlgen(root, force=True)
rtl_root = rtlgen(root)
top_model = NodeModel(rtl_root)
bind('gearbox/graph_model', top_model)
view.top = top_model.view
top_model.view.layout()
view.fit_all()
self.buff = GraphBuffer(view, 'graph')
self.model_loaded.emit()
if not self.err:
self.working_model_loaded.emit()
return self.buff
def main(argv=sys.argv, layers=Inject('gearbox/layers')):
print(f"Started: {sys.argv}")
parser = argparse.ArgumentParser(
prog="Gearbox - GUI for the PyGears framework")
parser.add_argument('script',
help="PyGears script",
default=None,
nargs='?')
parser.add_argument('-d',
'--outdir',
metavar='outdir',
default=None,
help="Output directory")
args = parser.parse_args(argv[1:])
bind('sim/artifacts_dir', args.outdir)
main_loop(args.script)
def popup_desc(text, buff, w=MayInject('gearbox/popup_desc')):
if w is None:
w = PopupDesc()
bind('gearbox/popup_desc', w)
w.popup(text, buff)
def description():
viewer = Description()
DescriptionBuffer(viewer, 'description')
bind('gearbox/description', viewer)
def create_shortcut_repeater(main=Inject('gearbox/main/inst')):
bind('gearbox/shortcut_repeater', ShortcutRepeat(main))
def graph(
sim_bridge=Inject('gearbox/sim_bridge'),
root=Inject('gear/hier_root')):
bind('gearbox/graph_model_ctrl', GraphModelCtrl())
def graph_delete(self):
self.buff.delete()
del self.buff
bind('gearbox/graph', None)
bind('gearbox/graph_model', None)
from pygears.conf import bind
bind('gear/naming/pretty_sieve', True)
def gtkwave_create(sim_bridge=Inject('gearbox/sim_bridge')):
gtkwave = GtkWave()
bind('gearbox/gtkwave/inst', gtkwave)
single_shot_connect(sim_bridge.model_closed, gktwave_delete)
def which_key(main=Inject('gearbox/main/inst')):
w = WhichKey(main)
main.vbox.insertWidget(main.vbox.count() - 1, w)
bind('gearbox/which_key', w)
def timekeep(sim_bridge=Inject('gearbox/sim_bridge')):
bind('gearbox/timekeep', TimeKeep())