Merge branch 'release/3.15.x' into feature/OP-3426_Add-support-for-De…

…adline-for-automatic-tests

igniter/tools.py

@@ -185,11 +185,7 @@ def get_openpype_path_from_settings(settings: dict) -> Union[str, None]:
     if paths and isinstance(paths, str):
         paths = [paths]
 
-    # Loop over paths and return only existing
-    for path in paths:
-        if os.path.exists(path):
-            return path
-    return None
+    return next((path for path in paths if os.path.exists(path)), None)
 
 
 def get_expected_studio_version_str(
@@ -207,10 +203,7 @@ def get_expected_studio_version_str(
     mongo_url = os.environ.get("OPENPYPE_MONGO")
     if global_settings is None:
         global_settings = get_openpype_global_settings(mongo_url)
-    if staging:
-        key = "staging_version"
-    else:
-        key = "production_version"
+    key = "staging_version" if staging else "production_version"
     return global_settings.get(key) or ""
 
 

openpype/cli.py

@@ -16,12 +16,11 @@
 @click.option("--use-staging", is_flag=True,
               expose_value=False, help="use staging variants")
 @click.option("--list-versions", is_flag=True, expose_value=False,
-              help=("list all detected versions. Use With `--use-staging "
-                    "to list staging versions."))
+              help="list all detected versions.")
 @click.option("--validate-version", expose_value=False,
               help="validate given version integrity")
 @click.option("--debug", is_flag=True, expose_value=False,
-              help=("Enable debug"))
+              help="Enable debug")
 @click.option("--verbose", expose_value=False,
               help=("Change OpenPype log level (debug - critical or 0-50)"))
 @click.option("--automatic-tests", is_flag=True, expose_value=False,
@@ -425,20 +424,18 @@ def unpack_project(zipfile, root):
 
 @main.command()
 def interactive():
-    """Interative (Python like) console.
+    """Interactive (Python like) console.
 
-    Helpfull command not only for development to directly work with python
+    Helpful command not only for development to directly work with python
     interpreter.
 
     Warning:
-        Executable 'openpype_gui' on windows won't work.
+        Executable 'openpype_gui' on Windows won't work.
     """
 
     from openpype.version import __version__
 
-    banner = "OpenPype {}\nPython {} on {}".format(
-        __version__, sys.version, sys.platform
-    )
+    banner = f"OpenPype {__version__}\nPython {sys.version} on {sys.platform}"
     code.interact(banner)
 
 

openpype/hosts/standalonepublisher/addon.py

@@ -10,7 +10,7 @@
 
 
 class StandAlonePublishAddon(OpenPypeModule, ITrayAction, IHostAddon):
-    label = "Publish"
+    label = "Publisher (legacy)"
     name = "standalonepublisher"
     host_name = "standalonepublisher"
 

openpype/hosts/traypublisher/addon.py

@@ -10,7 +10,7 @@
 
 
 class TrayPublishAddon(OpenPypeModule, IHostAddon, ITrayAction):
-    label = "New Publish (beta)"
+    label = "Publisher"
     name = "traypublisher"
     host_name = "traypublisher"
 
@@ -19,20 +19,9 @@ def initialize(self, modules_settings):
         self.publish_paths = [
             os.path.join(TRAYPUBLISH_ROOT_DIR, "plugins", "publish")
         ]
-        self._experimental_tools = None
 
     def tray_init(self):
-        from openpype.tools.experimental_tools import ExperimentalTools
-
-        self._experimental_tools = ExperimentalTools()
-
-    def tray_menu(self, *args, **kwargs):
-        super(TrayPublishAddon, self).tray_menu(*args, **kwargs)
-        traypublisher = self._experimental_tools.get("traypublisher")
-        visible = False
-        if traypublisher and traypublisher.enabled:
-            visible = True
-        self._action_item.setVisible(visible)
+        return
 
     def on_action_trigger(self):
         self.run_traypublisher()

openpype/lib/applications.py

@@ -1368,6 +1368,7 @@ def get_app_environments_for_context(
 
     from openpype.modules import ModulesManager
     from openpype.pipeline import AvalonMongoDB, Anatomy
+    from openpype.lib.openpype_version import is_running_staging
 
     # Avalon database connection
     dbcon = AvalonMongoDB()
@@ -1404,6 +1405,8 @@ def get_app_environments_for_context(
         "env": env
     })
     data["env"].update(anatomy.root_environments())
+    if is_running_staging():
+        data["env"]["OPENPYPE_IS_STAGING"] = "1"
 
     prepare_app_environments(data, env_group, modules_manager)
     prepare_context_environments(data, env_group, modules_manager)

openpype/lib/openpype_version.py

@@ -57,15 +57,66 @@ def is_running_from_build():
     return True
 
 
+def is_staging_enabled():
+    return os.environ.get("OPENPYPE_USE_STAGING") == "1"
+
+
 def is_running_staging():
     """Currently used OpenPype is staging version.
 
+    This function is not 100% proper check of staging version. It is possible
+    to have enabled to use staging version but be in different one.
+
+    The function is based on 4 factors:
+    - env 'OPENPYPE_IS_STAGING' is set
+    - current production version
+    - current staging version
+    - use staging is enabled
+
+    First checks for 'OPENPYPE_IS_STAGING' environment which can be set to '1'.
+    The value should be set only when a process without access to
+    OpenPypeVersion is launched (e.g. in DCCs). If current version is same
+    as production version it is expected that it is not staging, and it
+    doesn't matter what would 'is_staging_enabled' return. If current version
+    is same as staging version it is expected we're in staging. In all other
+    cases 'is_staging_enabled' is used as source of outpu value.
+
+    The function is used to decide which icon is used. To check e.g. updates
+    the output should be combined with other functions from this file.
+
     Returns:
-        bool: True if openpype version containt 'staging'.
+        bool: Using staging version or not.
     """
-    if "staging" in get_openpype_version():
+
+    if os.environ.get("OPENPYPE_IS_STAGING") == "1":
+        return True
+
+    if not op_version_control_available():
+        return False
+
+    from openpype.settings import get_global_settings
+
+    global_settings = get_global_settings()
+    production_version = global_settings["production_version"]
+    latest_version = None
+    if not production_version or production_version == "latest":
+        latest_version = get_latest_version(local=False, remote=True)
+        production_version = latest_version
+
+    current_version = get_openpype_version()
+    if current_version == production_version:
+        return False
+
+    staging_version = global_settings["staging_version"]
+    if not staging_version or staging_version == "latest":
+        if latest_version is None:
+            latest_version = get_latest_version(local=False, remote=True)
+        staging_version = latest_version
+
+    if current_version == production_version:
         return True
-    return False
+
+    return is_staging_enabled()
 
 
 # ----------------------------------------
@@ -131,13 +182,11 @@ def get_remote_versions(*args, **kwargs):
     return None
 
 
-def get_latest_version(staging=None, local=None, remote=None):
+def get_latest_version(local=None, remote=None):
     """Get latest version from repository path."""
-    if staging is None:
-        staging = is_running_staging()
+
     if op_version_control_available():
         return get_OpenPypeVersion().get_latest_version(
-            staging=staging,
             local=local,
             remote=remote
         )
@@ -146,9 +195,9 @@ def get_latest_version(staging=None, local=None, remote=None):
 
 def get_expected_studio_version(staging=None):
     """Expected production or staging version in studio."""
-    if staging is None:
-        staging = is_running_staging()
     if op_version_control_available():
+        if staging is None:
+            staging = is_staging_enabled()
         return get_OpenPypeVersion().get_expected_studio_version(staging)
     return None
 
@@ -158,7 +207,7 @@ def get_expected_version(staging=None):
     if expected_version is None:
         # Look for latest if expected version is not set in settings
         expected_version = get_latest_version(
-            staging=staging,
+            local=False,
             remote=True
         )
     return expected_version

openpype/resources/__init__.py

@@ -39,15 +39,21 @@ def get_liberation_font_path(bold=False, italic=False):
     return font_path
 
 
+def get_openpype_production_icon_filepath():
+    return get_resource("icons", "openpype_icon.png")
+
+
+def get_openpype_staging_icon_filepath():
+    return get_resource("icons", "openpype_icon_staging.png")
+
+
 def get_openpype_icon_filepath(staging=None):
     if staging is None:
         staging = is_running_staging()
 
     if staging:
-        icon_file_name = "openpype_icon_staging.png"
-    else:
-        icon_file_name = "openpype_icon.png"
-    return get_resource("icons", icon_file_name)
+        return get_openpype_staging_icon_filepath()
+    return get_openpype_production_icon_filepath()
 
 
 def get_openpype_splash_filepath(staging=None):

openpype/settings/__init__.py

@@ -18,11 +18,12 @@
 )
 from .lib import (
     get_general_environments,
+    get_global_settings,
     get_system_settings,
     get_project_settings,
     get_current_project_settings,
     get_anatomy_settings,
-    get_local_settings
+    get_local_settings,
 )
 from .entities import (
     SystemSettings,
@@ -49,6 +50,7 @@
     "SaveWarningExc",
 
     "get_general_environments",
+    "get_global_settings",
     "get_system_settings",
     "get_project_settings",
     "get_current_project_settings",

openpype/settings/defaults/system_settings/modules.json

@@ -195,7 +195,7 @@
         "enabled": true
     },
     "standalonepublish_tool": {
-        "enabled": true
+        "enabled": false
     },
     "project_manager": {
         "enabled": true

openpype/settings/entities/__init__.py

@@ -123,10 +123,7 @@
 )
 
 from .anatomy_entities import AnatomyEntity
-from .op_version_entity import (
-    ProductionVersionsInputEntity,
-    StagingVersionsInputEntity
-)
+from .op_version_entity import VersionsInputEntity
 
 __all__ = (
     "DefaultsNotDefined",
@@ -188,6 +185,5 @@
 
     "AnatomyEntity",
 
-    "ProductionVersionsInputEntity",
-    "StagingVersionsInputEntity"
+    "VersionsInputEntity",
 )

openpype/settings/entities/op_version_entity.py

@@ -66,24 +66,13 @@ def convert_to_valid_type(self, value):
         return super(OpenPypeVersionInput, self).convert_to_valid_type(value)
 
 
-class ProductionVersionsInputEntity(OpenPypeVersionInput):
+class VersionsInputEntity(OpenPypeVersionInput):
     """Entity meant only for global settings to define production version."""
-    schema_types = ["production-versions-text"]
+    schema_types = ["versions-text"]
 
     def _get_openpype_versions(self):
-        versions = get_remote_versions(staging=False, production=True)
+        versions = get_remote_versions()
         if versions is None:
             return []
         versions.append(get_installed_version())
         return sorted(versions)
-
-
-class StagingVersionsInputEntity(OpenPypeVersionInput):
-    """Entity meant only for global settings to define staging version."""
-    schema_types = ["staging-versions-text"]
-
-    def _get_openpype_versions(self):
-        versions = get_remote_versions(staging=True, production=False)
-        if versions is None:
-            return []
-        return sorted(versions)

openpype/settings/entities/schemas/system_schema/schema_general.json

@@ -146,12 +146,12 @@
                     "label": "Define explicit OpenPype version that should be used. Keep empty to use latest available version."
                 },
                 {
-                    "type": "production-versions-text",
+                    "type": "versions-text",
                     "key": "production_version",
                     "label": "Production version"
                 },
                 {
-                    "type": "staging-versions-text",
+                    "type": "versions-text",
                     "key": "staging_version",
                     "label": "Staging version"
                 },