#!/usr/bin/env python3 import re import sys from concurrent.futures import Future from typing import Callable import click import sqlalchemy from NodeGraphQt import BaseNode, NodeBaseWidget from NodeGraphQt import NodeGraph, Port from NodeGraphQt.constants import PortTypeEnum, NodePropWidgetEnum, ViewerEnum from NodeGraphQt.widgets.node_widgets import _NodeGroupBox, NodeLineEdit, NodeCheckBox from PySide2 import QtGui from PySide2.QtCore import Qt, QObject, QThread, Slot, Signal from PySide2.QtWidgets import QSlider, QLineEdit, QCheckBox, QGraphicsItem, QInputDialog, QDialog, QLabel, QSizePolicy from Qt import QtWidgets from sqlalchemy import create_engine from sqlalchemy.orm import Session from factorygame.data.common import chose_resource, resource_needs_update, chose_recipe from factorygame.data.sfp import SatisfactoryPlus, DEFAULT_IGNORE_FACTORIES from .models import Recipe, Resource, ResourceFlow, Base WORLD_INPUT_PORT_NAME = "World Input" WORLD_OUTPUT_PORT_NAME = "World Output" WORLD_PORT_COLOR = (0, 139, 41) CREATE_MACHINE_PORT_NAME = "Create Machine" INPUT_COLOR = (249, 169, 0) OUTPUT_COLOR = (204, 44, 36) OTHER_COLOR = (0, 83, 135) def generate_fgbg_stylesheet(bg_alpha: float = 1.0) -> str: dark_bg = QtGui.QColor(*ViewerEnum.BACKGROUND_COLOR.value).darker(120) dark_bg.setAlphaF(bg_alpha) bg_color = dark_bg.getRgb() text_color = tuple(map(str, map(lambda i, j: i - j, (255, 255, 255), bg_color))) return ( "* {" " background-color: rgba(" + ",".join(map(str, bg_color)) + ");" " color: rgb(" + ",".join(text_color) + ");" "}" ) def in_amount_name(label: str) -> str: return f"In {label} amount" def out_amount_name(label: str) -> str: return f"Out {label} amount" def port_amount_name(port: Port) -> str: if port.type_() == PortTypeEnum.IN: return in_amount_name(port.name()) elif port.type_() == PortTypeEnum.OUT: return out_amount_name(port.name()) else: raise TypeError(f"Invalid port type {port.type_()}") def add_resource_text( node: BaseNode, name: str, text: str, border_color: tuple, readonly: bool = False ) -> NodeLineEdit: node.add_text_input(name=name, label=name, text=text) widget: NodeLineEdit = node.get_widget(name) line_edit_widget: QLineEdit = widget.get_custom_widget() if readonly: line_edit_widget.setReadOnly(True) group: _NodeGroupBox = widget.widget() group.setMaximumWidth(220) group.adjustSize() if border_color: stylesheet = line_edit_widget.styleSheet() match = Machine.STYLESHEET_BORDER_COLOR_REGEX.match(stylesheet) stylesheet = ( stylesheet[: match.start(1)] + f"rgb({','.join(map(str, border_color))})" + stylesheet[match.end(1) :] ) line_edit_widget.setStyleSheet(stylesheet) line_edit_widget.update() return widget def parse_resource_amount(text: str) -> float: return float(text.strip().rstrip("min").rstrip().rstrip("/").rstrip()) def resource_amount_to_text(amount: float): return f"{amount:.2f} / min" class AsyncResourceFetcher(QThread): def __init__(self, parent, resource_label: str, engine: sqlalchemy.Engine, debug: bool): super().__init__(parent=parent) self.resource_label = resource_label self.engine = engine self.debug = debug def run(self): with Session(self.engine) as session, SatisfactoryPlus( ignore_factories=DEFAULT_IGNORE_FACTORIES, debug=self.debug ) as data_provider: resource = session.scalars(Resource.by_label(self.resource_label)).one() resource = data_provider.update_resource_recipes(session=session, resource=resource) if self.debug: print("AsyncResourceFetcher updated resource in separate thread", resource) session.commit() class AsyncResourceFinder(QThread): def __init__(self, parent, resource_label: str, engine: sqlalchemy.Engine, prompt: Callable, debug: bool): super().__init__(parent=parent) self.resource_label = resource_label self.engine = engine self.debug = debug self.prompt = prompt self.result = Future() def run(self): try: with ( Session(self.engine) as session, SatisfactoryPlus(ignore_factories=DEFAULT_IGNORE_FACTORIES, debug=self.debug) as data_provider, ): search_result_future = data_provider.search_for_resource( session=session, search=self.resource_label, prompt=self.prompt ) search_result = search_result_future.result(timeout=60) if search_result is None: if self.debug: print("AsyncResourceFinder search completed, but no result") self.result.set_result(None) return resource, exists_in_db = search_result if not exists_in_db or resource_needs_update(resource): resource = data_provider.update_resource_recipes(session=session, resource=resource) if self.debug: print("AsyncResourceFinder updated resource", resource) session.commit() session.refresh(resource) self.result.set_result(resource) except: self.result.set_exception(sys.exception()) class NodeSlider(NodeBaseWidget): MIN_VALUE = 1 MAX_VALUE = 250 DEFAULT_VALUE = 100 def __init__(self, name: str, label: str = "", parent: QGraphicsItem = None, readonly: bool = False): super(NodeSlider, self).__init__(parent) self.set_name(name) self.pure_label = label or name slider = QSlider(Qt.Horizontal) slider.setEnabled(not readonly) slider.setRange(self.MIN_VALUE, self.MAX_VALUE) slider.setValue(self.DEFAULT_VALUE) slider.setSingleStep(1) slider.setTickInterval(10) slider.setTickPosition(QSlider.TicksBelow) slider.valueChanged.connect(self.on_value_changed) slider.valueChanged.connect(self._update_label) self.set_custom_widget(slider) self._update_label() def get_custom_widget(self) -> QSlider: widget = super().get_custom_widget() assert isinstance(widget, QSlider), f"Unexpected widget, not a QSlider: {widget}" return widget def get_value(self) -> int: return self.get_custom_widget().value() def set_value(self, value: int): self.get_custom_widget().setValue(max(self.MIN_VALUE, min(self.MAX_VALUE, value))) def _update_label(self): self.set_label(f"{self.pure_label} ({self.get_value()}%)") class GlobalInput(BaseNode): __identifier__ = "factorygame" NODE_NAME = "Global Input" def __init__(self): super().__init__() self.model.width = 240 self.set_port_deletion_allowed(True) self.add_special_ports() self.output_resources: dict[str, float] = {} def add_special_ports(self): self.add_output(WORLD_OUTPUT_PORT_NAME, multi_output=False, color=WORLD_PORT_COLOR) self.add_output(CREATE_MACHINE_PORT_NAME, multi_output=False, color=OTHER_COLOR) def reorder_ports(self): self.delete_output(WORLD_OUTPUT_PORT_NAME) self.delete_output(CREATE_MACHINE_PORT_NAME) self.add_special_ports() def update_x_pos(self, graph: NodeGraph): min_x_pos = min(map(lambda node: node.x_pos(), filter(lambda node: node != self, graph.all_nodes()))) self.set_x_pos(min_x_pos - self.view.width - 150) def create_global_output(self, graph: NodeGraph, resource_label: str, initial_resource_amount: float) -> Port: # FIXME: support multiple resource outputs or add splitters new_output_port = self.add_output(name=resource_label, multi_output=False, color=OUTPUT_COLOR) widget = add_resource_text( node=self, name=out_amount_name(resource_label), text=resource_amount_to_text(initial_resource_amount), border_color=OUTPUT_COLOR, ) self.output_resources[resource_label] = initial_resource_amount widget.value_changed.connect(lambda: self.update_resource_output(resource_label)) self.reorder_ports() self.update_x_pos(graph=graph) return new_output_port def update_resource_output(self, resource_label: str): assert resource_label in self.output_resources widget: NodeLineEdit = self.get_widget(out_amount_name(resource_label)) new_amount = parse_resource_amount(widget.get_value()) if self.output_resources[resource_label] != new_amount: self.output_resources[resource_label] = new_amount widget.set_value(resource_amount_to_text(self.output_resources[resource_label])) resource_port = self.get_output(resource_label) for connected_port in resource_port.connected_ports(): node = connected_port.node() assert isinstance(node, Machine), f"Connected node must be a machine: {node}" node.update_input(resource_label, new_amount) class GlobalOutput(BaseNode): __identifier__ = "factorygame" NODE_NAME = "Global Output" def __init__(self): super().__init__() self.model.width = 240 self.set_port_deletion_allowed(True) self.add_special_ports() self.input_resources: dict[str, float] = {} def add_special_ports(self): self.add_input(WORLD_INPUT_PORT_NAME, multi_input=False, color=WORLD_PORT_COLOR) self.add_input(CREATE_MACHINE_PORT_NAME, multi_input=False, color=OTHER_COLOR) def reorder_ports(self): self.delete_input(WORLD_INPUT_PORT_NAME) self.delete_input(CREATE_MACHINE_PORT_NAME) self.add_special_ports() def update_x_pos(self, graph: NodeGraph): other_nodes = filter(lambda node: node != self, graph.all_nodes()) max_x = max(map(lambda node: node.x_pos() + node.view.width, other_nodes)) self.set_x_pos(max_x + 150) def create_global_input(self, graph: NodeGraph, resource_label: str, initial_resource_amount: float) -> Port: # FIXME: support multiple resource inputs or add mergers new_input_port = self.add_input(name=resource_label, multi_input=False, color=INPUT_COLOR) widget = add_resource_text( node=self, name=in_amount_name(resource_label), text=resource_amount_to_text(initial_resource_amount), border_color=INPUT_COLOR, ) line_edit_widget: QLineEdit = widget.get_custom_widget() line_edit_widget.setReadOnly(True) self.input_resources[resource_label] = initial_resource_amount self.reorder_ports() return new_input_port def update_input(self, resource_label: str, value: float): assert resource_label in self.input_resources widget: NodeLineEdit = self.get_widget(in_amount_name(resource_label)) if self.input_resources[resource_label] != value: self.input_resources[resource_label] = value widget.set_value(resource_amount_to_text(self.input_resources[resource_label])) class Machine(BaseNode): __identifier__ = "factorygame" NODE_NAME = "FactoryGame Machine" MAXIMUM_PERFORMANCE_PROP = "machine max perf" ACTUAL_PERFORMANCE_PROP = "machine actual perf" AUTOMATIC_PERFORMANCE_PROP = "machine automatic" STYLESHEET_BORDER_COLOR_REGEX = re.compile( r"QLineEdit\s*{[^{}]*\s*border:[^;]*(rgb\([^)]+\))", re.MULTILINE | re.DOTALL ) def __init__(self): super().__init__() self.model.width = 240 self.input_resources: dict[str, float] = {} self.possible_input_resources: dict[str, float] = {} self.output_resources: dict[str, float] = {} self.add_checkbox(Machine.AUTOMATIC_PERFORMANCE_PROP, text="Automatic Mode", state=True) widget: NodeCheckBox = self.get_widget(Machine.AUTOMATIC_PERFORMANCE_PROP) widget.value_changed.connect(self.recalculate_factor) checkbox_widget: QCheckBox = widget.get_custom_widget() checkbox_widget.setStyleSheet( checkbox_widget.styleSheet() + "\nQCheckBox {\n" f"background-color: transparent;\n" "}" ) self.add_text_input( name=Machine.ACTUAL_PERFORMANCE_PROP, label="Overall Production", text="100", ) widget: NodeLineEdit = self.get_widget(Machine.ACTUAL_PERFORMANCE_PROP) line_edit_widget: QLineEdit = widget.get_custom_widget() line_edit_widget.setReadOnly(True) def max_performance_changed(self): self.set_property(Machine.AUTOMATIC_PERFORMANCE_PROP, False) self.recalculate_factor() def recalculate_factor(self): max_factor: float = self.get_property(Machine.MAXIMUM_PERFORMANCE_PROP) / 100.0 if max_factor < 1.0 and self.get_property(Machine.AUTOMATIC_PERFORMANCE_PROP): per_machine_factor = 1.0 else: per_machine_factor = max_factor all_machines_factor = None for resource_label, wanted_resource in self.input_resources.items(): if len(self.get_input(resource_label).connected_ports()) != 0: new_factor = self.possible_input_resources[resource_label] / wanted_resource / per_machine_factor if all_machines_factor is None: all_machines_factor = new_factor elif new_factor < all_machines_factor: all_machines_factor = new_factor if all_machines_factor is None: all_machines_factor = per_machine_factor new_perf = int(all_machines_factor * 100.0) if int(self.get_property(Machine.ACTUAL_PERFORMANCE_PROP)) != new_perf: self.get_widget(name=Machine.ACTUAL_PERFORMANCE_PROP).set_value(str(new_perf)) self.actual_performance_changed(name=Machine.ACTUAL_PERFORMANCE_PROP, factor=all_machines_factor) if self.get_property(Machine.AUTOMATIC_PERFORMANCE_PROP): self.set_property(name=Machine.MAXIMUM_PERFORMANCE_PROP, value=100, push_undo=False) def update_input(self, resource_label: str, value: float): self.possible_input_resources[resource_label] = value self.recalculate_factor() def actual_performance_changed(self, name: str, factor: float): if name == Machine.ACTUAL_PERFORMANCE_PROP: for ingredient_label, amount in self.input_resources.items(): resource_text_widget = self.get_widget(in_amount_name(ingredient_label)) assert ( resource_text_widget is not None ), f"No ingredient resource text widget found for {ingredient_label}" resource_text_widget.set_value(resource_amount_to_text(amount * factor)) for result_label, amount in self.output_resources.items(): resource_text_widget = self.get_widget(out_amount_name(result_label)) assert resource_text_widget is not None, f"No result resource text widget found for {result_label}" new_output_value = amount * factor resource_text_widget.set_value(resource_amount_to_text(new_output_value)) for port in self.get_output(result_label).connected_ports(): node = port.node() node.update_input( resource_label=result_label, value=new_output_value, ) def assign_recipe(self, recipe: Recipe): for port_idx in range(len(self._inputs)): self.delete_input(port_idx) for port_idx in range(len(self._outputs)): self.delete_output(port_idx) self.set_property("name", recipe.join_factories(), push_undo=False) for ingredient in recipe.ingredients: resource_label = ingredient.resource.label if resource_label in self.input_resources: self.input_resources[resource_label] += ingredient.amount_per_minute() self.get_widget(in_amount_name(resource_label)).set_value( resource_amount_to_text(self.input_resources[resource_label]) ) else: port = self.add_input(resource_label, multi_input=False, color=INPUT_COLOR) port.add_accept_port_type(resource_label, PortTypeEnum.OUT.value, "factorygame.Machine") port.add_accept_port_type(resource_label, PortTypeEnum.OUT.value, "factorygame.GlobalInput") port.add_accept_port_type(CREATE_MACHINE_PORT_NAME, PortTypeEnum.OUT.value, "factorygame.GlobalInput") port.add_accept_port_type(WORLD_OUTPUT_PORT_NAME, PortTypeEnum.OUT.value, "factorygame.GlobalInput") self._add_readonly_resource_text( in_amount_name(resource_label), ingredient, self.input_resources, resource_label, border_color=INPUT_COLOR, ) for result in recipe.results: resource_label = result.resource.label if resource_label in self.output_resources: self.output_resources[resource_label] += result.amount_per_minute() self.get_widget(out_amount_name(resource_label)).set_value( resource_amount_to_text(self.output_resources[resource_label]) ) else: port = self.add_output(resource_label, multi_output=False, color=OUTPUT_COLOR) port.add_accept_port_type(resource_label, PortTypeEnum.IN.value, "factorygame.Machine") port.add_accept_port_type(resource_label, PortTypeEnum.IN.value, "factorygame.GlobalOutput") port.add_accept_port_type(CREATE_MACHINE_PORT_NAME, PortTypeEnum.IN.value, "factorygame.GlobalOutput") port.add_accept_port_type(WORLD_INPUT_PORT_NAME, PortTypeEnum.IN.value, "factorygame.GlobalOutput") self._add_readonly_resource_text( out_amount_name(resource_label), result, self.output_resources, resource_label, border_color=OUTPUT_COLOR, ) self.possible_input_resources.update(self.input_resources) slider = NodeSlider(name=Machine.MAXIMUM_PERFORMANCE_PROP, label="Overclocking Performance", parent=self.view) self.add_custom_widget(widget=slider, widget_type=NodePropWidgetEnum.SLIDER.value) slider.value_changed.connect(self.max_performance_changed) def _add_readonly_resource_text( self, name: str, flow: ResourceFlow, resource_amounts: dict[str, float], resource_label: str, border_color: tuple, ) -> NodeLineEdit: resource_amounts[resource_label] = flow.amount_per_minute() text = resource_amount_to_text(resource_amounts[resource_label]) return add_resource_text(node=self, name=name, text=text, border_color=border_color, readonly=True) def get_resource_output(self, resource_label: str) -> float: return self.output_resources[resource_label] * (int(self.get_property(Machine.ACTUAL_PERFORMANCE_PROP)) / 100.0) class GraphController(QObject): prompt_dialog_show = Signal(str, list, str) loading_dialog_show = Signal() loading_dialog_hide = Signal() def __init__(self, debug: bool, parent=None): super().__init__(parent=parent) self.debug = debug self.engine = create_engine("sqlite:///file.db", echo=debug) Base.metadata.create_all(bind=self.engine) self.graph = NodeGraph(parent=self) self.graph.widget.resize(1280, 720) self.graph.register_node(Machine) self.graph.register_node(GlobalInput) self.graph.register_node(GlobalOutput) self.global_input: GlobalInput = self.graph.create_node("factorygame.GlobalInput", push_undo=False) self.global_output: GlobalOutput = self.graph.create_node("factorygame.GlobalOutput", push_undo=False) self.graph.port_connected.connect(self.on_port_connected) self._prompt_dialog = QInputDialog(parent=self.graph.widget) self._prompt_dialog.setStyleSheet(generate_fgbg_stylesheet()) self._prompt_dialog.setModal(True) self._dialog_future = Future() self._prompt_dialog.rejected.connect(lambda: self._dialog_future.set_result(None)) self._prompt_dialog.accepted.connect(lambda: self._dialog_future.set_result(self._prompt_dialog.textValue())) self.prompt_dialog_show.connect(self.show_prompt_dialog) self._loading_dialog = QDialog(parent=self.graph.widget, f=(Qt.Dialog | Qt.ToolTip)) self._loading_dialog.setStyleSheet(generate_fgbg_stylesheet(0.5)) self._loading_dialog.setModal(True) self._loading_dialog.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) label = QLabel("Loading…", self._loading_dialog) label.setAlignment(Qt.AlignCenter) self.loading_dialog_show.connect(self.show_loading_dialog) self.loading_dialog_hide.connect(self.hide_loading_dialog) @Slot(str, list, str) def show_prompt_dialog(self, text: str, options: list, default: str = ""): assert self._prompt_dialog.isHidden(), "Prompt dialog already visible" self._prompt_dialog.setLabelText(text) self._prompt_dialog.setComboBoxItems(options) if default: self._prompt_dialog.setTextValue(default) self._prompt_dialog.show() @Slot() def show_loading_dialog(self): self._loading_dialog.show() @Slot() def hide_loading_dialog(self): self._loading_dialog.hide() def add_machine_from_search(self, search: str): recipe_selected_future = Future() def resource_found_db(resource: Resource | None): if resource is None: return def chose_recipe_async(): with Session(self.engine) as session: chose_recipe(session=session, resource=resource, prompt=self.dialog_prompt).add_done_callback( lambda fut: recipe_selected_future.set_result(fut.result()) ) if resource_needs_update(resource): fetch_future = self.fetch_recipes_async(resource_label=resource.label) fetch_future.add_done_callback(lambda fut: chose_recipe_async) else: chose_recipe_async() def resource_selected_or_search_cb(resource_future: Future[Resource | None]): resource = resource_future.result() if resource is None: search_future = self.search_resource_async(resource_label=search) search_future.add_done_callback(lambda fut: resource_found_db(fut.result())) else: resource_found_db(resource) def recipe_selected_cb(recipe_future: Future[Recipe | None]): recipe = recipe_future.result() if recipe is not None: recipe_machine: Machine = self.graph.create_node("factorygame.Machine", push_undo=False) recipe_machine.assign_recipe(recipe) recipe_machine.update() self.graph.auto_layout_nodes([self.global_input, recipe_machine, self.global_output]) self.global_input.set_y_pos(recipe_machine.y_pos()) self.global_output.set_y_pos(recipe_machine.y_pos()) self.global_input.update_x_pos(graph=self.graph) self.global_output.update_x_pos(graph=self.graph) self.graph.center_on([self.global_input, recipe_machine, self.global_output]) recipe_selected_future.add_done_callback(recipe_selected_cb) with Session(self.engine) as session: resource_future = chose_resource(session=session, resource_label=search, prompt=self.dialog_prompt) resource_future.add_done_callback(resource_selected_or_search_cb) def show(self): self.graph.widget.show() def on_port_connected(self, input_port: Port, output_port: Port): if self.debug: print(f"Port {output_port} connected to {input_port}") output_node = output_port.node() if output_node == self.global_input: resource_label = input_port.name() input_node = input_port.node() if output_port.name() == CREATE_MACHINE_PORT_NAME: output_port.clear_connections(push_undo=False, emit_signal=False) def recipe_selected_cb(recipe_future: Future[Recipe | None]): recipe = recipe_future.result() if recipe is not None: recipe_machine: Machine = self.graph.create_node("factorygame.Machine", push_undo=True) recipe_machine.assign_recipe(recipe) recipe_machine.update() recipe_machine.set_x_pos(input_node.x_pos() - recipe_machine.view.width - 100) recipe_machine.get_output(resource_label).connect_to(input_port) self.global_input.update_x_pos(graph=self.graph) if isinstance(input_node, Machine): input_node.update_input(resource_label, recipe_machine.get_resource_output(resource_label)) with Session(self.engine) as session: resource = session.scalars(Resource.by_label(resource_label)).one_or_none() def chose_recipe_async(): with Session(self.engine) as session: chose_recipe( session=session, resource=resource, prompt=self.dialog_prompt, ).add_done_callback(recipe_selected_cb) if resource_needs_update(resource): fetch_future = self.fetch_recipes_async(resource_label) fetch_future.add_done_callback(lambda fut: chose_recipe_async()) else: chose_recipe_async() elif output_port.name() == WORLD_OUTPUT_PORT_NAME: output_port.clear_connections(push_undo=False, emit_signal=False) for idx, port in enumerate(self.global_input.output_ports()): assert port.name() != resource_label, f"Duplicate output port for {resource_label}" # if port.name() == resource_label: # port.connect_to(input_port, push_undo=True, emit_signal=False) # return if isinstance(input_node, Machine): resource_amount = parse_resource_amount( str(input_node.get_property(in_amount_name(resource_label))) ) new_output_port = self.global_input.create_global_output( graph=self.graph, resource_label=resource_label, initial_resource_amount=resource_amount, ) new_output_port.connect_to(input_port, push_undo=True, emit_signal=False) input_node.update_input(resource_label, resource_amount) elif isinstance(output_node, Machine): input_node = input_port.node() resource_label = output_port.name() if input_node == self.global_output: if input_port.name() == CREATE_MACHINE_PORT_NAME: input_port.clear_connections(push_undo=False, emit_signal=False) def recipe_selected_cb(recipe_future: Future[Recipe | None]): recipe = recipe_future.result() if recipe is not None: recipe_machine: Machine = self.graph.create_node("factorygame.Machine", push_undo=True) recipe_machine.assign_recipe(recipe) recipe_machine.update() recipe_machine.set_x_pos(output_node.x_pos() + output_node.view.width + 100) output_port.connect_to(recipe_machine.get_input(resource_label)) self.global_output.update_x_pos(graph=self.graph) with Session(self.engine) as session: resource = session.scalars(Resource.by_label(resource_label)).one_or_none() def chose_recipe_async(): chose_recipe( session=session, resource=resource, prompt=self.dialog_prompt, ingredient=True ).add_done_callback(recipe_selected_cb) if resource_needs_update(resource): fetch_future = self.fetch_recipes_async(resource_label=resource_label) fetch_future.add_done_callback(lambda fut: chose_recipe_async()) else: chose_recipe_async() elif input_port.name() == WORLD_INPUT_PORT_NAME: input_port.clear_connections(push_undo=False, emit_signal=False) for idx, port in enumerate(self.global_output.output_ports()): assert port.name() != resource_label, f"Duplicate output port for {resource_label}" # if port.name() == resource_label: # port.connect_to(input_port, push_undo=True, emit_signal=False) # return resource_amount = output_node.get_resource_output(resource_label) new_input_port = self.global_output.create_global_input( graph=self.graph, resource_label=resource_label, initial_resource_amount=resource_amount, ) output_port.connect_to(new_input_port, push_undo=True, emit_signal=False) elif isinstance(input_node, Machine): resource_amount = output_node.get_resource_output(resource_label) input_node.update_input( resource_label, resource_amount, ) def fetch_recipes_async(self, resource_label): if self.debug: print("Fetching recipes for resource", resource_label) fetcher_thread = AsyncResourceFetcher( parent=self.graph, resource_label=resource_label, engine=self.engine, debug=self.debug, ) fetch_future = Future() self.loading_dialog_show.emit() fetch_future.add_done_callback(lambda fut: self.loading_dialog_hide.emit()) fetcher_thread.finished.connect(lambda: fetch_future.set_result(None)) fetcher_thread.start() return fetch_future def search_resource_async(self, resource_label) -> Future[Resource]: if self.debug: print("Searching resource", resource_label) loading_future = Future() def show_prompt(*args, **kwargs): loading_future.set_result(None) return self.dialog_prompt(*args, **kwargs) fetcher_thread = AsyncResourceFinder( parent=self.graph, resource_label=resource_label, engine=self.engine, prompt=show_prompt, debug=self.debug, ) self.loading_dialog_show.emit() loading_future.add_done_callback(lambda fut: self.loading_dialog_hide.emit()) fetcher_thread.start() return fetcher_thread.result def dialog_prompt(self, options: dict[int, str], text: str, default: int) -> Future[int | None]: if self.debug: print("Displaying QInputDialog with options:", ", ".join(options.values())) reversed_options: dict[str, int] = {value: key for key, value in options.items()} ret = Future() self._dialog_future = Future() def map_result(fut: Future): result = fut.result() if result is None: ret.set_result(None) else: ret.set_result(reversed_options[result]) self._dialog_future.add_done_callback(map_result) self.prompt_dialog_show.emit(text, list(reversed_options.keys()), options.get(default, "")) return ret @click.command @click.option("--debug", is_flag=True) @click.argument("search") def main(debug: bool, search: str): app = QtWidgets.QApplication([]) graph_controller = GraphController(debug=debug) graph_controller.show() graph_controller.add_machine_from_search(search=search) app.exec_() if __name__ == "__main__": main()