PublisherController can be imported without import of Qt

openpype/tools/publisher/__init__.py

@@ -1,7 +0,0 @@
-from .app import show
-from .window import PublisherWindow
-
-__all__ = (
-    "show",
-    "PublisherWindow"
-)

openpype/tools/publisher/control.py

@@ -14,14 +14,13 @@ from openpype.pipeline import (
 )
 from openpype.pipeline.create import CreateContext
 
-from Qt import QtCore
-
 # Define constant for plugin orders offset
 PLUGIN_ORDER_OFFSET = 0.5
 
 
 class MainThreadItem:
     """Callback with args and kwargs."""
+
     def __init__(self, callback, *args, **kwargs):
         self.callback = callback
         self.args = args
@@ -31,64 +30,9 @@ class MainThreadItem:
         self.callback(*self.args, **self.kwargs)
 
 
-class MainThreadProcess(QtCore.QObject):
-    """Qt based main thread process executor.
-
-    Has timer which controls each 50ms if there is new item to process.
-
-    This approach gives ability to update UI meanwhile plugin is in progress.
-    """
-
-    count_timeout = 2
-
-    def __init__(self):
-        super(MainThreadProcess, self).__init__()
-        self._items_to_process = collections.deque()
-
-        timer = QtCore.QTimer()
-        timer.setInterval(0)
-
-        timer.timeout.connect(self._execute)
-
-        self._timer = timer
-        self._switch_counter = self.count_timeout
-
-    def process(self, func, *args, **kwargs):
-        item = MainThreadItem(func, *args, **kwargs)
-        self.add_item(item)
-
-    def add_item(self, item):
-        self._items_to_process.append(item)
-
-    def _execute(self):
-        if not self._items_to_process:
-            return
-
-        if self._switch_counter > 0:
-            self._switch_counter -= 1
-            return
-
-        self._switch_counter = self.count_timeout
-
-        item = self._items_to_process.popleft()
-        item.process()
-
-    def start(self):
-        if not self._timer.isActive():
-            self._timer.start()
-
-    def stop(self):
-        if self._timer.isActive():
-            self._timer.stop()
-
-    def clear(self):
-        if self._timer.isActive():
-            self._timer.stop()
-        self._items_to_process = collections.deque()
-
-
 class AssetDocsCache:
     """Cache asset documents for creation part."""
+
     projection = {
         "_id": True,
         "name": True,
@@ -133,6 +77,7 @@ class PublishReport:
 
     Report keeps current state of publishing and currently processed plugin.
     """
+
     def __init__(self, controller):
         self.controller = controller
         self._publish_discover_result = None
@@ -341,7 +286,7 @@ class PublishReport:
         return output
 
 
-class PublisherController:
+class PublisherController(object):
     """Middleware between UI, CreateContext and publish Context.
 
     Handle both creation and publishing parts.
@@ -394,8 +339,6 @@ class PublisherController:
             pyblish.api.ValidatorOrder + PLUGIN_ORDER_OFFSET
         )
 
-        # Qt based main thread processor
-        self._main_thread_processor = MainThreadProcess()
         # Plugin iterator
         self._main_thread_iter = None
 
@@ -744,7 +687,7 @@ class PublisherController:
         self._publish_up_validation = False
         self._publish_finished = False
         self._publish_comment_is_set = False
-        self._main_thread_processor.clear()
+
         self._main_thread_iter = self._publish_iterator()
         self._publish_context = pyblish.api.Context()
         # Make sure "comment" is set on publish context
@@ -792,13 +735,12 @@ class PublisherController:
         self._publish_is_running = True
 
         self._emit_event("publish.process.started")
-        self._main_thread_processor.start()
+
         self._publish_next_process()
 
     def _stop_publish(self):
         """Stop or pause publishing."""
         self._publish_is_running = False
-        self._main_thread_processor.stop()
 
         self._emit_event("publish.process.stopped")
 
@@ -837,7 +779,10 @@ class PublisherController:
         else:
             item = next(self._main_thread_iter)
 
-        self._main_thread_processor.add_item(item)
+        self._process_main_thread_item(item)
+
+    def _process_main_thread_item(self, item):
+        item()
 
     def _publish_iterator(self):
         """Main logic center of publishing.

openpype/tools/publisher/control_qt.py

@@ -0,0 +1,88 @@
+import collections
+
+from Qt import QtCore
+
+from .control import MainThreadItem, PublisherController
+
+
+class MainThreadProcess(QtCore.QObject):
+    """Qt based main thread process executor.
+
+    Has timer which controls each 50ms if there is new item to process.
+
+    This approach gives ability to update UI meanwhile plugin is in progress.
+    """
+
+    count_timeout = 2
+
+    def __init__(self):
+        super(MainThreadProcess, self).__init__()
+        self._items_to_process = collections.deque()
+
+        timer = QtCore.QTimer()
+        timer.setInterval(0)
+
+        timer.timeout.connect(self._execute)
+
+        self._timer = timer
+        self._switch_counter = self.count_timeout
+
+    def process(self, func, *args, **kwargs):
+        item = MainThreadItem(func, *args, **kwargs)
+        self.add_item(item)
+
+    def add_item(self, item):
+        self._items_to_process.append(item)
+
+    def _execute(self):
+        if not self._items_to_process:
+            return
+
+        if self._switch_counter > 0:
+            self._switch_counter -= 1
+            return
+
+        self._switch_counter = self.count_timeout
+
+        item = self._items_to_process.popleft()
+        item.process()
+
+    def start(self):
+        if not self._timer.isActive():
+            self._timer.start()
+
+    def stop(self):
+        if self._timer.isActive():
+            self._timer.stop()
+
+    def clear(self):
+        if self._timer.isActive():
+            self._timer.stop()
+        self._items_to_process = collections.deque()
+
+
+class QtPublisherController(PublisherController):
+    def __init__(self, *args, **kwargs):
+        self._main_thread_processor = MainThreadProcess()
+
+        super(QtPublisherController, self).__init__(*args, **kwargs)
+
+        self._event_system.add_callback(
+            "publish.process.started", self._qt_on_publish_start
+        )
+        self._event_system.add_callback(
+            "publish.process.stopped", self._qt_on_publish_stop
+        )
+
+    def _reset_publish(self):
+        super(QtPublisherController, self)._reset_publish()
+        self._main_thread_processor.clear()
+
+    def _process_main_thread_item(self, item):
+        self._main_thread_processor.add_item(item)
+
+    def _qt_on_publish_start(self):
+        self._main_thread_processor.start()
+
+    def _qt_on_publish_stop(self):
+        self._main_thread_processor.stop()

openpype/tools/publisher/window.py

@@ -11,7 +11,7 @@ from openpype.tools.utils import (
 )
 
 from .publish_report_viewer import PublishReportViewerWidget
-from .control import PublisherController
+from .control_qt import QtPublisherController
 from .widgets import (
     OverviewWidget,
     ValidationsWidget,
@@ -34,7 +34,7 @@ class PublisherWindow(QtWidgets.QDialog):
     default_width = 1300
     default_height = 800
 
-    def __init__(self, parent=None, reset_on_show=None):
+    def __init__(self, parent=None, controller=None, reset_on_show=None):
         super(PublisherWindow, self).__init__(parent)
 
         self.setWindowTitle("OpenPype publisher")
@@ -59,7 +59,8 @@ class PublisherWindow(QtWidgets.QDialog):
             | on_top_flag
         )
 
-        controller = PublisherController()
+        if controller is None:
+            controller = QtPublisherController()
 
         help_dialog = HelpDialog(controller, self)