Merge pull request #11 from quadproduction/release/4.0.4

release/4.0.4

src/igniter/__init__.py

@@ -65,7 +65,7 @@ def ask_database_connection_string(log=None):
     return d.result()
 
 
-def open_zxp_update_window(quadpype_version, zxp_hosts=None):
+def open_zxp_update_window(running_version_str, running_version_fullpath, zxp_hosts=None):
     """Open ZXP update window."""
     if zxp_hosts is None:
         zxp_hosts = []
@@ -77,7 +77,11 @@ def open_zxp_update_window(quadpype_version, zxp_hosts=None):
 
     app, is_event_loop_running = _get_qt_app()
 
-    d = ZXPUpdateWindow(version=quadpype_version, zxp_hosts=zxp_hosts)
+    d = ZXPUpdateWindow(
+        version_str=running_version_str,
+        version_fullpath=running_version_fullpath,
+        zxp_hosts=zxp_hosts
+    )
     d.open()
 
     if not is_event_loop_running:

src/igniter/gui.py

@@ -466,9 +466,10 @@ class ZXPUpdateWindow(QtWidgets.QDialog):
     _width = 500
     _height = 100
 
-    def __init__(self, version: PackageVersion, zxp_hosts: [ZXPExtensionData], parent=None):
+    def __init__(self, version_str, version_fullpath: Path, zxp_hosts: [ZXPExtensionData], parent=None):
         super().__init__(parent)
-        self._quadpype_version = version
+        self._version_str = version_str
+        self._version_fullpath = version_fullpath
         self._zxp_hosts = zxp_hosts
         self._log = log.getLogger(str(__class__))
 
@@ -510,7 +511,7 @@ def _init_ui(self):
         # Main info
         # --------------------------------------------------------------------
         main_label = QtWidgets.QLabel(
-            f"<b>QuadPype</b> is updating to {self._quadpype_version}", self)
+            f"<b>QuadPype</b> is updating to {self._version_str}", self)
         main_label.setWordWrap(True)
         main_label.setObjectName("MainLabel")
 
@@ -552,7 +553,7 @@ def _run_update(self):
             return
         self._progress_bar.setRange(0, 0)
         update_thread = ZXPUpdateThread(self)
-        update_thread.set_version(self._quadpype_version)
+        update_thread.set_version_fullpath(self._version_fullpath)
         update_thread.set_zxp_hosts(self._zxp_hosts)
         update_thread.log_signal.connect(self._print)
         update_thread.step_text_signal.connect(self.update_step_text)

src/igniter/zxp_utils.py

@@ -22,43 +22,49 @@ def __init__(self, host_id: str, ext_id: str, installed_version: semver.VersionI
 
 
 def extract_zxp_info_from_manifest(path_manifest: Path):
-    pattern_regex_extension_id = r"ExtensionBundleId=\"(?P<extension_id>[\w.]+)\""
-    pattern_regex_extension_version = r"ExtensionBundleVersion=\"(?P<extension_version>[\d.]+)\""
-
     extension_id = ""
     extension_version = ""
-    with open(path_manifest, mode="r") as f:
-        content = f.read()
-        match_extension_id = re.search(pattern_regex_extension_id, content)
-        match_extension_version = re.search(pattern_regex_extension_version, content)
-        if match_extension_id:
-            extension_id = match_extension_id.group("extension_id")
-        if match_extension_version:
-            extension_version = semver.VersionInfo.parse(match_extension_version.group("extension_version"))
+
+    if not path_manifest.exists():
+        return extension_id, extension_version
+
+    pattern_regex_extension_id = r"ExtensionBundleId=\"(?P<extension_id>[\w.]+)\""
+    pattern_regex_extension_version = r"ExtensionBundleVersion=\"(?P<extension_version>[\d.]+)\""
+    try:
+        with open(path_manifest, mode="r") as f:
+            content = f.read()
+            match_extension_id = re.search(pattern_regex_extension_id, content)
+            match_extension_version = re.search(pattern_regex_extension_version, content)
+            if match_extension_id:
+                extension_id = match_extension_id.group("extension_id")
+            if match_extension_version:
+                extension_version = semver.VersionInfo.parse(match_extension_version.group("extension_version"))
+    except Exception:  # noqa
+        return extension_id, extension_version
 
     return extension_id, extension_version
 
 
-def update_zxp_extensions(quadpype_version: PackageVersion, extensions: [ZXPExtensionData]):
+def update_zxp_extensions(running_version_fullpath: Path, extensions: [ZXPExtensionData]):
     # Determine the user-specific Adobe extensions directory
     user_extensions_dir = Path(os.getenv('APPDATA'), 'Adobe', 'CEP', 'extensions')
 
     # Create the user extensions directory if it doesn't exist
     os.makedirs(user_extensions_dir, exist_ok=True)
 
-    version_path = quadpype_version.path
-
     for extension in extensions:
         # Remove installed ZXP extension
         if user_extensions_dir.joinpath(extension.host_id).exists():
             shutil.rmtree(user_extensions_dir.joinpath(extension.host_id))
 
         # Install ZXP shipped in the current version folder
-        fullpath_curr_zxp_extension = version_path.joinpath("quadpype",
-                                                            "hosts",
-                                                            extension.host_id,
-                                                            "api",
-                                                            "extension.zxp")
+        fullpath_curr_zxp_extension = running_version_fullpath.joinpath(
+            "quadpype",
+            "hosts",
+            extension.host_id,
+            "api",
+            "extension.zxp"
+        )
         if not fullpath_curr_zxp_extension.exists():
             continue
 
@@ -75,7 +81,7 @@ def update_zxp_extensions(quadpype_version: PackageVersion, extensions: [ZXPExte
         os.remove(zip_path)
 
 
-def get_zxp_extensions_to_update(quadpype_version, global_settings, force=False) -> List[ZXPExtensionData]:
+def get_zxp_extensions_to_update(running_version_fullpath, global_settings, force=False) -> List[ZXPExtensionData]:
     # List of all Adobe software ids (named hosts) handled by QuadPype
     # TODO: where and how to store the list of Adobe software ids
     zxp_host_ids = ["photoshop", "aftereffects"]
@@ -85,17 +91,16 @@ def get_zxp_extensions_to_update(quadpype_version, global_settings, force=False)
 
     zxp_hosts_to_update = []
     for zxp_host_id in zxp_host_ids:
-        version_path = quadpype_version.path
-        path_manifest = version_path.joinpath("quadpype", "hosts", zxp_host_id, "api", "extension", "CSXS",
-                                              "manifest.xml")
-        extension_new_id, extension_new_version = extract_zxp_info_from_manifest(path_manifest)
-        if not extension_new_id or not extension_new_version:
+        path_manifest = running_version_fullpath.joinpath(
+            "quadpype", "hosts", zxp_host_id, "api", "extension", "CSXS", "manifest.xml")
+        running_extension_id, running_extension_version = extract_zxp_info_from_manifest(path_manifest)
+        if not running_extension_id or not running_extension_version:
             # ZXP extension seems invalid or doesn't exists for this software, skipping
             continue
 
-        cur_manifest = user_extensions_dir.joinpath(extension_new_id, "CSXS", "manifest.xml")
+        cur_manifest = user_extensions_dir.joinpath(running_extension_id, "CSXS", "manifest.xml")
         # Get the installed version
-        extension_cur_id, extension_curr_version = extract_zxp_info_from_manifest(cur_manifest)
+        installed_extension_id, installed_extension_version = extract_zxp_info_from_manifest(cur_manifest)
 
         if not force:
             # Is the update required?
@@ -106,14 +111,14 @@ def get_zxp_extensions_to_update(quadpype_version, global_settings, force=False)
                 continue
 
             # Compare the installed version with the new version
-            if extension_curr_version and extension_curr_version == extension_new_version:
+            if installed_extension_version and installed_extension_version == running_extension_version:
                 # The two extensions have the same version number, skipping
                 continue
 
         zxp_hosts_to_update.append(ZXPExtensionData(zxp_host_id,
-                                                    extension_new_id,
-                                                    extension_curr_version,
-                                                    extension_new_version))
+                                                    running_extension_id,
+                                                    installed_extension_version,
+                                                    running_extension_version))
 
     return zxp_hosts_to_update
 
@@ -125,12 +130,12 @@ class ZXPUpdateThread(QtCore.QThread):
 
     def __init__(self, parent=None):
         self._result = None
-        self._quadpype_version = None
+        self._version_fullpath = None
         self._zxp_hosts = []
         super().__init__(parent)
 
-    def set_version(self, quadpype_version: PackageVersion):
-        self._quadpype_version = quadpype_version
+    def set_version_fullpath(self, version_fullpath):
+        self._version_fullpath = version_fullpath
 
     def set_zxp_hosts(self, zxp_hosts: List[ZXPExtensionData]):
         self._zxp_hosts = zxp_hosts
@@ -144,6 +149,5 @@ def _set_result(self, value):
 
     def run(self):
         """Thread entry point."""
-        version_path = self._quadpype_version.path
-        update_zxp_extensions(self._quadpype_version, self._zxp_hosts)
-        self._set_result(version_path)
+        update_zxp_extensions(self._version_fullpath, self._zxp_hosts)
+        self._set_result(self._version_fullpath)

src/quadpype/hosts/standalonepublisher/plugins/publish/help/validate_texture_name.xml

@@ -9,7 +9,7 @@ Unable to parse asset name from '{file_name}'. File name doesn't match configure
 
 ### How to repair?
 
-Check Settings: project_settings/standalonepublisher/publish/CollectTextures for naming convention.
+Check Settings: project_settings/standalone_publisher/publish/CollectTextures for naming convention.
 </description>
 <detail>
 ### __Detailed Info__ (optional)

src/quadpype/modules/update_zxp_extensions_action.py

@@ -34,5 +34,5 @@ def on_action_trigger(self):
         quadpype_version = get_package("quadpype").running_version
 
         global_settings = get_global_settings()
-        zxp_hosts_to_update = get_zxp_extensions_to_update(quadpype_version, global_settings, force=True)
-        igniter.open_zxp_update_window(quadpype_version, zxp_hosts_to_update)
+        zxp_hosts_to_update = get_zxp_extensions_to_update(quadpype_version.path, global_settings, force=True)
+        igniter.open_zxp_update_window(str(quadpype_version), quadpype_version.path, zxp_hosts_to_update)

src/quadpype/tools/attribute_defs/widgets.py

@@ -28,11 +28,8 @@
 
 def create_widget_for_attr_def(attr_def, parent=None):
     widget = _create_widget_for_attr_def(attr_def, parent)
-    if attr_def.hidden:
-        widget.setVisible(False)
-
-    if attr_def.disabled:
-        widget.setEnabled(False)
+    widget.setVisible(attr_def.visible)
+    widget.setEnabled(attr_def.enabled)
     return widget
 
 
@@ -135,7 +132,7 @@ def add_attr_defs(self, attr_defs):
             widget = create_widget_for_attr_def(attr_def, self)
             self._widgets.append(widget)
 
-            if attr_def.hidden:
+            if not attr_def.visible:
                 continue
 
             expand_cols = 2

src/quadpype/tools/publisher/widgets/widgets.py

@@ -1411,7 +1411,7 @@ def set_current_instances(self, instances):
             self._attr_def_id_to_instances[attr_def.id] = attr_instances
             self._attr_def_id_to_attr_def[attr_def.id] = attr_def
 
-            if attr_def.hidden:
+            if not attr_def.visible:
                 continue
 
             expand_cols = 2
@@ -1548,7 +1548,7 @@ def set_current_instances(self, instances, context_selected):
                 widget = create_widget_for_attr_def(
                     attr_def, content_widget
                 )
-                hidden_widget = attr_def.hidden
+                hidden_widget = not attr_def.visible
                 # Hide unknown values of publish plugins
                 # - The keys in most of cases does not represent what would
                 #   label represent

src/quadpype/tools/standalonepublish/app.py

@@ -240,7 +240,7 @@ def signal_handler(sig, frame):
     signal.signal(signal.SIGTERM, signal_handler)
 
     modules_manager = ModulesManager()
-    module = modules_manager.modules_by_name["standalonepublisher"]
+    module = modules_manager.modules_by_name["standalone_publisher"]
 
     window = Window(module.publish_paths)
     window.show()

src/quadpype/version.py

@@ -1,3 +1,3 @@
 # -*- coding: utf-8 -*-
 """File declaring QuadPype version."""
-__version__ = "4.0.3"
+__version__ = "4.0.4"

src/start.py

@@ -442,16 +442,16 @@ def set_avalon_environments():
     })
 
 
-def _update_zxp_extensions(quadpype_version, global_settings):
-    zxp_hosts_to_update = get_zxp_extensions_to_update(quadpype_version, global_settings)
+def _update_zxp_extensions(running_version_str, running_version_fullpath, global_settings):
+    zxp_hosts_to_update = get_zxp_extensions_to_update(running_version_fullpath, global_settings)
     if not zxp_hosts_to_update:
         return
 
     in_headless_mode = os.getenv("QUADPYPE_HEADLESS_MODE") == "1"
     if in_headless_mode:
-        update_zxp_extensions(quadpype_version, zxp_hosts_to_update)
+        update_zxp_extensions(running_version_fullpath, zxp_hosts_to_update)
     else:
-        igniter.open_zxp_update_window(quadpype_version, zxp_hosts_to_update)
+        igniter.open_zxp_update_window(running_version_str, running_version_fullpath, zxp_hosts_to_update)
 
 
 def set_addons_environments():
@@ -969,18 +969,19 @@ def boot():
     _print("  - for addons ...")
     set_addons_environments()
 
+    running_version = package_manager["quadpype"].running_version
+    running_version_fullpath = running_version.path.resolve()
     if not os.getenv("QUADPYPE_IGNORE_ZXP_UPDATE"):
         _print(">>> Check ZXP extensions ...")
-        _update_zxp_extensions(package_manager["quadpype"].running_version, global_settings)
+        _update_zxp_extensions(str(running_version), running_version_fullpath, global_settings)
 
     # print info when not running scripts defined in 'silent commands'
     if all(arg not in silent_commands for arg in sys.argv):
         from quadpype.lib import terminal as t
         from quadpype.version import __version__
 
         info = get_info(use_staging)
-        running_version_fullpath = str(package_manager["quadpype"].running_version.path.resolve())
-        info.insert(0, f">>> Using QuadPype from [ {running_version_fullpath} ]")
+        info.insert(0, f">>> Using QuadPype from [ {str(running_version_fullpath)} ]")
 
         t_width = 20
         try: