Shotgrid: Add production beta of shotgrid integration

.gitignore

@@ -102,3 +102,6 @@ website/.docusaurus
 
 .poetry/
 .python-version
+.editorconfig
+.pre-commit-config.yaml
+mypy.ini

openpype/modules/deadline/plugins/publish/submit_maya_deadline.py

@@ -519,6 +519,7 @@ def process(self, instance):
             "FTRACK_API_KEY",
             "FTRACK_API_USER",
             "FTRACK_SERVER",
+            "OPENPYPE_SG_USER",
             "AVALON_PROJECT",
             "AVALON_ASSET",
             "AVALON_TASK",

openpype/modules/shotgrid/README.md

@@ -0,0 +1,19 @@
+## Shotgrid Module
+
+### Pre-requisites
+
+Install and launch a [shotgrid leecher](https://github.com/Ellipsanime/shotgrid-leecher) server
+
+### Quickstart
+
+The goal of this tutorial is to synchronize an already existing shotgrid project with OpenPype.
+
+- Activate the shotgrid module in the **system settings** and inform the shotgrid leecher server API url
+
+- Create a new OpenPype project with the **project manager**
+
+- Inform the shotgrid authentication infos (url, script name, api key) and the shotgrid project ID related to this OpenPype project in the **project settings**
+
+- Use the batch interface (Tray > shotgrid > Launch batch), select your project and click "batch"
+
+- You can now access your shotgrid entities within the **avalon launcher** and publish informations to shotgrid with **pyblish**

openpype/modules/shotgrid/__init__.py

@@ -0,0 +1,5 @@
+from .shotgrid_module import (
+    ShotgridModule,
+)
+
+__all__ = ("ShotgridModule",)

openpype/modules/shotgrid/lib/const.py

@@ -0,0 +1 @@
+MODULE_NAME = "shotgrid"

openpype/modules/shotgrid/lib/credentials.py

@@ -0,0 +1,125 @@
+
+from urllib.parse import urlparse
+
+import shotgun_api3
+from shotgun_api3.shotgun import AuthenticationFault
+
+from openpype.lib import OpenPypeSecureRegistry, OpenPypeSettingsRegistry
+from openpype.modules.shotgrid.lib.record import Credentials
+
+
+def _get_shotgrid_secure_key(hostname, key):
+    """Secure item key for entered hostname."""
+    return f"shotgrid/{hostname}/{key}"
+
+
+def _get_secure_value_and_registry(
+    hostname,
+    name,
+):
+    key = _get_shotgrid_secure_key(hostname, name)
+    registry = OpenPypeSecureRegistry(key)
+    return registry.get_item(name, None), registry
+
+
+def get_shotgrid_hostname(shotgrid_url):
+
+    if not shotgrid_url:
+        raise Exception("Shotgrid url cannot be a null")
+    valid_shotgrid_url = (
+        f"//{shotgrid_url}" if "//" not in shotgrid_url else shotgrid_url
+    )
+    return urlparse(valid_shotgrid_url).hostname
+
+
+# Credentials storing function (using keyring)
+
+
+def get_credentials(shotgrid_url):
+    hostname = get_shotgrid_hostname(shotgrid_url)
+    if not hostname:
+        return None
+    login_value, _ = _get_secure_value_and_registry(
+        hostname,
+        Credentials.login_key_prefix(),
+    )
+    password_value, _ = _get_secure_value_and_registry(
+        hostname,
+        Credentials.password_key_prefix(),
+    )
+    return Credentials(login_value, password_value)
+
+
+def save_credentials(login, password, shotgrid_url):
+    hostname = get_shotgrid_hostname(shotgrid_url)
+    _, login_registry = _get_secure_value_and_registry(
+        hostname,
+        Credentials.login_key_prefix(),
+    )
+    _, password_registry = _get_secure_value_and_registry(
+        hostname,
+        Credentials.password_key_prefix(),
+    )
+    clear_credentials(shotgrid_url)
+    login_registry.set_item(Credentials.login_key_prefix(), login)
+    password_registry.set_item(Credentials.password_key_prefix(), password)
+
+
+def clear_credentials(shotgrid_url):
+    hostname = get_shotgrid_hostname(shotgrid_url)
+    login_value, login_registry = _get_secure_value_and_registry(
+        hostname,
+        Credentials.login_key_prefix(),
+    )
+    password_value, password_registry = _get_secure_value_and_registry(
+        hostname,
+        Credentials.password_key_prefix(),
+    )
+
+    if login_value is not None:
+        login_registry.delete_item(Credentials.login_key_prefix())
+
+    if password_value is not None:
+        password_registry.delete_item(Credentials.password_key_prefix())
+
+
+# Login storing function (using json)
+
+
+def get_local_login():
+    reg = OpenPypeSettingsRegistry()
+    try:
+        return str(reg.get_item("shotgrid_login"))
+    except Exception:
+        return None
+
+
+def save_local_login(login):
+    reg = OpenPypeSettingsRegistry()
+    reg.set_item("shotgrid_login", login)
+
+
+def clear_local_login():
+    reg = OpenPypeSettingsRegistry()
+    reg.delete_item("shotgrid_login")
+
+
+def check_credentials(
+    login,
+    password,
+    shotgrid_url,
+):
+
+    if not shotgrid_url or not login or not password:
+        return False
+    try:
+        session = shotgun_api3.Shotgun(
+            shotgrid_url,
+            login=login,
+            password=password,
+        )
+        session.preferences_read()
+        session.close()
+    except AuthenticationFault:
+        return False
+    return True

openpype/modules/shotgrid/lib/record.py

@@ -0,0 +1,20 @@
+
+class Credentials:
+    login = None
+    password = None
+
+    def __init__(self, login, password) -> None:
+        super().__init__()
+        self.login = login
+        self.password = password
+
+    def is_empty(self):
+        return not (self.login and self.password)
+
+    @staticmethod
+    def login_key_prefix():
+        return "login"
+
+    @staticmethod
+    def password_key_prefix():
+        return "password"

openpype/modules/shotgrid/lib/settings.py

@@ -0,0 +1,18 @@
+from openpype.api import get_system_settings, get_project_settings
+from openpype.modules.shotgrid.lib.const import MODULE_NAME
+
+
+def get_shotgrid_project_settings(project):
+    return get_project_settings(project).get(MODULE_NAME, {})
+
+
+def get_shotgrid_settings():
+    return get_system_settings().get("modules", {}).get(MODULE_NAME, {})
+
+
+def get_shotgrid_servers():
+    return get_shotgrid_settings().get("shotgrid_settings", {})
+
+
+def get_leecher_backend_url():
+    return get_shotgrid_settings().get("leecher_backend_url")

openpype/modules/shotgrid/plugins/publish/collect_shotgrid_entities.py

@@ -0,0 +1,100 @@
+import os
+
+import pyblish.api
+from openpype.lib.mongo import OpenPypeMongoConnection
+
+
+class CollectShotgridEntities(pyblish.api.ContextPlugin):
+    """Collect shotgrid entities according to the current context"""
+
+    order = pyblish.api.CollectorOrder + 0.499
+    label = "Shotgrid entities"
+
+    def process(self, context):
+
+        avalon_project = context.data.get("projectEntity")
+        avalon_asset = context.data.get("assetEntity")
+        avalon_task_name = os.getenv("AVALON_TASK")
+
+        self.log.info(avalon_project)
+        self.log.info(avalon_asset)
+
+        sg_project = _get_shotgrid_project(context)
+        sg_task = _get_shotgrid_task(
+            avalon_project,
+            avalon_asset,
+            avalon_task_name
+        )
+        sg_entity = _get_shotgrid_entity(avalon_project, avalon_asset)
+
+        if sg_project:
+            context.data["shotgridProject"] = sg_project
+            self.log.info(
+                "Collected correspondig shotgrid project : {}".format(
+                    sg_project
+                )
+            )
+
+        if sg_task:
+            context.data["shotgridTask"] = sg_task
+            self.log.info(
+                "Collected correspondig shotgrid task : {}".format(sg_task)
+            )
+
+        if sg_entity:
+            context.data["shotgridEntity"] = sg_entity
+            self.log.info(
+                "Collected correspondig shotgrid entity : {}".format(sg_entity)
+            )
+
+    def _find_existing_version(self, code, context):
+
+        filters = [
+            ["project", "is", context.data.get("shotgridProject")],
+            ["sg_task", "is", context.data.get("shotgridTask")],
+            ["entity", "is", context.data.get("shotgridEntity")],
+            ["code", "is", code],
+        ]
+
+        sg = context.data.get("shotgridSession")
+        return sg.find_one("Version", filters, [])
+
+
+def _get_shotgrid_collection(project):
+    client = OpenPypeMongoConnection.get_mongo_client()
+    return client.get_database("shotgrid_openpype").get_collection(project)
+
+
+def _get_shotgrid_project(context):
+    shotgrid_project_id = context.data["project_settings"].get(
+        "shotgrid_project_id")
+    if shotgrid_project_id:
+        return {"type": "Project", "id": shotgrid_project_id}
+    return {}
+
+
+def _get_shotgrid_task(avalon_project, avalon_asset, avalon_task):
+    sg_col = _get_shotgrid_collection(avalon_project["name"])
+    shotgrid_task_hierarchy_row = sg_col.find_one(
+        {
+            "type": "Task",
+            "_id": {"$regex": "^" + avalon_task + "_[0-9]*"},
+            "parent": {"$regex": ".*," + avalon_asset["name"] + ","},
+        }
+    )
+    if shotgrid_task_hierarchy_row:
+        return {"type": "Task", "id": shotgrid_task_hierarchy_row["src_id"]}
+    return {}
+
+
+def _get_shotgrid_entity(avalon_project, avalon_asset):
+    sg_col = _get_shotgrid_collection(avalon_project["name"])
+    shotgrid_entity_hierarchy_row = sg_col.find_one(
+        {"_id": avalon_asset["name"]}
+    )
+    if shotgrid_entity_hierarchy_row:
+        return {
+            "type": shotgrid_entity_hierarchy_row["type"],
+            "id": shotgrid_entity_hierarchy_row["src_id"],
+        }
+    return {}