def INITIALIZE():
from PyFlow.UI.Tool import REGISTER_TOOL
from PyFlow.UI.Widgets.InputWidgets import REGISTER_UI_INPUT_WIDGET_PIN_FACTORY
from PyFlow.UI.Canvas.UINodeBase import REGISTER_UI_NODE_FACTORY
from PyFlow.UI.Canvas.UIPinBase import REGISTER_UI_PIN_FACTORY
# TODO: Check for duplicated package names
for importer, modname, ispkg in pkgutil.iter_modules(Packages.__path__):
if ispkg:
mod = importer.find_module(modname).load_module(modname)
package = getattr(mod, modname)()
__PACKAGES[modname] = package
for name, package in __PACKAGES.items():
packageName = package.__class__.__name__
for node in package.GetNodeClasses().values():
node._packageName = packageName
for pin in package.GetPinClasses().values():
pin._packageName = packageName
uiPinsFactory = package.UIPinsFactory()
REGISTER_UI_PIN_FACTORY(packageName, uiPinsFactory)
uiPinInputWidgetsFactory = package.PinsInputWidgetFactory()
REGISTER_UI_INPUT_WIDGET_PIN_FACTORY(packageName, uiPinInputWidgetsFactory)
uiNodesFactory = package.UINodesFactory()
REGISTER_UI_NODE_FACTORY(packageName, uiNodesFactory)
for toolClass in package.GetToolClasses().values():
REGISTER_TOOL(packageName, toolClass)
def INITIALIZE(additionalPackageLocations=[]):
from PyFlow.UI.Tool import REGISTER_TOOL
from PyFlow.UI.Widgets.InputWidgets import REGISTER_UI_INPUT_WIDGET_PIN_FACTORY
from PyFlow.UI.Canvas.UINodeBase import REGISTER_UI_NODE_FACTORY
from PyFlow.UI.Canvas.UIPinBase import REGISTER_UI_PIN_FACTORY
from PyFlow import ConfigManager
packagePaths = Packages.__path__
# check for additional package locations
if "PYFLOW_PACKAGES_PATHS" in os.environ:
delim = ';'
pathsString = os.environ["PYFLOW_PACKAGES_PATHS"]
# remove delimeters from right
pathsString = pathsString.rstrip(delim)
for packagesRoot in pathsString.split(delim):
if os.path.exists(packagesRoot):
packagePaths.append(packagesRoot)
packagePaths.extend(additionalPackageLocations)
for importer, modname, ispkg in pkgutil.iter_modules(packagePaths):
if ispkg:
mod = importer.find_module(modname).load_module(modname)
package = getattr(mod, modname)()
__PACKAGES[modname] = package
registeredInternalPinDataTypes = set()
for name, package in __PACKAGES.items():
packageName = package.__class__.__name__
for node in package.GetNodeClasses().values():
node._packageName = packageName
for pin in package.GetPinClasses().values():
pin._packageName = packageName
if pin.IsValuePin():
internalType = pin.internalDataStructure()
if internalType in registeredInternalPinDataTypes:
raise Exception(
"Pin with {0} internal data type alredy been registered"
.format(internalType))
registeredInternalPinDataTypes.add(internalType)
uiPinsFactory = package.UIPinsFactory()
if uiPinsFactory is not None:
REGISTER_UI_PIN_FACTORY(packageName, uiPinsFactory)
uiPinInputWidgetsFactory = package.PinsInputWidgetFactory()
if uiPinInputWidgetsFactory is not None:
REGISTER_UI_INPUT_WIDGET_PIN_FACTORY(packageName,
uiPinInputWidgetsFactory)
uiNodesFactory = package.UINodesFactory()
if uiNodesFactory is not None:
REGISTER_UI_NODE_FACTORY(packageName, uiNodesFactory)
for toolClass in package.GetToolClasses().values():
REGISTER_TOOL(packageName, toolClass)
getHashableDataTypes()
def instance(parent=None):
if PyFlow.appInstance is not None:
return PyFlow.appInstance
settings = ConfigManager().getSettings("APP_STATE")
instance = PyFlow(parent)
REGISTER_TOOL("PyFlowBase", LoggerTool)
a = GET_TOOLS()["PyFlowBase"][0]()
a.setAppInstance(instance)
instance.registerToolInstance(a)
instance.addDockWidget(a.defaultDockArea(), a)
a.setAppInstance(instance)
a.onShow()
try:
extraPackagePaths = []
extraPathsString = ConfigManager().getPrefsValue(
"PREFS", "General/ExtraPackageDirs")
if extraPathsString is not None:
extraPathsString = extraPathsString.rstrip(";")
extraPathsRaw = extraPathsString.split(";")
for rawPath in extraPathsRaw:
if os.path.exists(rawPath):
extraPackagePaths.append(os.path.normpath(rawPath))
INITIALIZE(additionalPackageLocations=extraPackagePaths)
except Exception as e:
QMessageBox.critical(None, "Fatal error", str(e))
return
instance.startMainLoop()
# populate tools
canvas = instance.getCanvas()
toolbar = instance.getToolbar()
geo = settings.value('Editor/geometry')
if geo is not None:
instance.restoreGeometry(geo)
state = settings.value('Editor/state')
if state is not None:
instance.restoreState(state)
settings.beginGroup("Tools")
for packageName, registeredToolSet in GET_TOOLS().items():
for ToolClass in registeredToolSet:
if issubclass(ToolClass, ShelfTool):
ToolInstance = ToolClass()
# prevent to be garbage collected
instance.registerToolInstance(ToolInstance)
ToolInstance.setAppInstance(instance)
action = QAction(instance)
action.setIcon(ToolInstance.getIcon())
action.setText(ToolInstance.name())
action.setToolTip(ToolInstance.toolTip())
action.setObjectName(ToolInstance.name())
action.triggered.connect(ToolInstance.do)
# check if context menu data available
menuBuilder = ToolInstance.contextMenuBuilder()
if menuBuilder:
menuGenerator = ContextMenuGenerator(menuBuilder)
menu = menuGenerator.generate()
action.setMenu(menu)
toolbar.addAction(action)
# step to ShelfTools/ToolName group and pass settings inside
settings.beginGroup("ShelfTools")
settings.beginGroup(ToolClass.name())
ToolInstance.restoreState(settings)
settings.endGroup()
settings.endGroup()
if issubclass(ToolClass, DockTool):
menus = instance.menuBar.findChildren(QMenu)
pluginsMenuAction = [
m for m in menus if m.title() == "Plugins"
][0].menuAction()
toolsMenu = getOrCreateMenu(instance.menuBar, "Tools")
instance.menuBar.insertMenu(pluginsMenuAction, toolsMenu)
packageSubMenu = getOrCreateMenu(toolsMenu, packageName)
toolsMenu.addMenu(packageSubMenu)
showToolAction = packageSubMenu.addAction(ToolClass.name())
icon = ToolClass.getIcon()
if icon:
showToolAction.setIcon(icon)
showToolAction.triggered.connect(
lambda pkgName=packageName, toolName=ToolClass.name(
): instance.invokeDockToolByName(pkgName, toolName))
settings.beginGroup("DockTools")
childGroups = settings.childGroups()
for dockToolGroupName in childGroups:
# This dock tool data been saved on last shutdown
settings.beginGroup(dockToolGroupName)
if dockToolGroupName in [
t.uniqueName() for t in instance._tools
]:
continue
toolName = dockToolGroupName.split("::")[0]
instance.invokeDockToolByName(packageName, toolName,
settings)
settings.endGroup()
settings.endGroup()
PyFlow.appInstance = instance
EditorHistory().saveState("New file")
for name, package in GET_PACKAGES().items():
prefsWidgets = package.PrefsWidgets()
if prefsWidgets is not None:
for categoryName, widgetClass in prefsWidgets.items():
PreferencesWindow().addCategory(categoryName,
widgetClass())
PreferencesWindow().selectByName("General")
return instance
def INITIALIZE(additionalPackageLocations=[], software=""):
sys.path.append(
str((Path(__file__).parent / Path('Packages')).resolve().absolute()))
from PyFlow.UI.Tool import REGISTER_TOOL
from PyFlow.UI.Widgets.InputWidgets import REGISTER_UI_INPUT_WIDGET_PIN_FACTORY
from PyFlow.UI.Canvas.UINodeBase import REGISTER_UI_NODE_FACTORY
from PyFlow.UI.Canvas.UIPinBase import REGISTER_UI_PIN_FACTORY
from PyFlow import ConfigManager
from Qt.QtWidgets import QMessageBox
packagePaths = Packages.__path__
def ensurePackagePath(inPath):
for subFolder in os.listdir(inPath):
subFolderPath = os.path.join(inPath, subFolder)
if os.path.isdir(subFolderPath):
if "PyFlow" in os.listdir(subFolderPath):
subFolderPath = os.path.join(subFolderPath, "PyFlow",
"Packages")
if os.path.exists(subFolderPath):
return subFolderPath
return inPath
def recursePackagePaths(inPath):
paths = []
for subFolder in os.listdir(inPath):
subFolderPath = os.path.join(inPath, subFolder)
if os.path.isdir(subFolderPath):
if "PyFlow" in os.listdir(subFolderPath):
subFolderPath = os.path.join(subFolderPath, "PyFlow",
"Packages")
if os.path.exists(subFolderPath):
paths.append(subFolderPath)
return paths
# check for additional package locations
if "PYFLOW_PACKAGES_PATHS" in os.environ:
delim = ';'
pathsString = os.environ["PYFLOW_PACKAGES_PATHS"]
# remove delimeters from right
pathsString = pathsString.rstrip(delim)
for packagesRoot in pathsString.split(delim):
if os.path.exists(packagesRoot):
paths = recursePackagePaths(packagesRoot)
packagePaths.extend(paths)
for packagePathId in range(len(additionalPackageLocations)):
packagePath = additionalPackageLocations[packagePathId]
packagePath = ensurePackagePath(packagePath)
additionalPackageLocations[packagePathId] = packagePath
packagePaths.extend(additionalPackageLocations)
for importer, modname, ispkg in pkgutil.iter_modules(packagePaths):
try:
if ispkg:
mod = importer.find_module(modname).load_module(modname)
package = getattr(mod, modname)()
__PACKAGES[modname] = package
__PACKAGE_PATHS[modname] = os.path.normpath(mod.__path__[0])
except Exception as e:
QMessageBox.critical(
None, str("Fatal error"),
"Error On Module %s :\n%s" % (modname, str(e)))
continue
registeredInternalPinDataTypes = set()
for name, package in __PACKAGES.items():
packageName = package.__class__.__name__
for node in package.GetNodeClasses().values():
node._packageName = packageName
for pin in package.GetPinClasses().values():
pin._packageName = packageName
if pin.IsValuePin():
internalType = pin.internalDataStructure()
if internalType in registeredInternalPinDataTypes:
raise Exception(
"Pin with {0} internal data type already been registered"
.format(internalType))
registeredInternalPinDataTypes.add(internalType)
uiPinsFactory = package.UIPinsFactory()
if uiPinsFactory is not None:
REGISTER_UI_PIN_FACTORY(packageName, uiPinsFactory)
uiPinInputWidgetsFactory = package.PinsInputWidgetFactory()
if uiPinInputWidgetsFactory is not None:
REGISTER_UI_INPUT_WIDGET_PIN_FACTORY(packageName,
uiPinInputWidgetsFactory)
uiNodesFactory = package.UINodesFactory()
if uiNodesFactory is not None:
REGISTER_UI_NODE_FACTORY(packageName, uiNodesFactory)
for toolClass in package.GetToolClasses().values():
supportedSoftwares = toolClass.supportedSoftwares()
if "any" not in supportedSoftwares:
if software not in supportedSoftwares:
continue
REGISTER_TOOL(packageName, toolClass)
getHashableDataTypes()