Merge pull request #295 from BigRoy/enhancement/usd_workflow

Houdini: Implement USD workflow with global asset/shot contributions plug-in

client/ayon_core/pipeline/entity_uri.py

@@ -0,0 +1,91 @@
+from typing import Optional, Union
+from urllib.parse import urlparse, parse_qs
+
+
+def parse_ayon_entity_uri(uri: str) -> Optional[dict]:
+    """Parse AYON entity URI into individual components.
+
+    URI specification:
+        ayon+entity://{project}/{folder}?product={product}
+            &version={version}
+            &representation={representation}
+    URI example:
+        ayon+entity://test/hero?product=modelMain&version=2&representation=usd
+
+    However - if the netloc is `ayon://` it will by default also resolve as
+    `ayon+entity://` on AYON server, thus we need to support both. The shorter
+    `ayon://` is preferred for user readability.
+
+    Example:
+    >>> parse_ayon_entity_uri(
+    >>>     "ayon://test/char/villain?product=modelMain&version=2&representation=usd"  # noqa: E501
+    >>> )
+    {'project': 'test', 'folderPath': '/char/villain',
+     'product': 'modelMain', 'version': 1,
+     'representation': 'usd'}
+    >>> parse_ayon_entity_uri(
+    >>>     "ayon+entity://project/folder?product=renderMain&version=3&representation=exr"  # noqa: E501
+    >>> )
+    {'project': 'project', 'folderPath': '/folder',
+     'product': 'renderMain', 'version': 3,
+     'representation': 'exr'}
+
+    Returns:
+        dict[str, Union[str, int]]: The individual key with their values as
+            found in the ayon entity URI.
+
+    """
+
+    if not (uri.startswith("ayon+entity://") or uri.startswith("ayon://")):
+        return {}
+
+    parsed = urlparse(uri)
+    if parsed.scheme not in {"ayon+entity", "ayon"}:
+        return {}
+
+    result = {
+        "project": parsed.netloc,
+        "folderPath": "/" + parsed.path.strip("/")
+    }
+    query = parse_qs(parsed.query)
+    for key in ["product", "version", "representation"]:
+        if key in query:
+            result[key] = query[key][0]
+
+    # Convert version to integer if it is a digit
+    version = result.get("version")
+    if version is not None and version.isdigit():
+        result["version"] = int(version)
+
+    return result
+
+
+def construct_ayon_entity_uri(
+        project_name: str,
+        folder_path: str,
+        product: str,
+        version: Union[int, str],
+        representation_name: str
+) -> str:
+    """Construct AYON entity URI from its components
+
+    Returns:
+        str: AYON Entity URI to query entity path.
+    """
+    if isinstance(version, int) and version < 0:
+        version = "hero"
+    if not (isinstance(version, int) or version in {"latest", "hero"}):
+        raise ValueError(
+            "Version must either be integer, 'latest' or 'hero'. "
+            "Got: {}".format(version)
+        )
+    return (
+        "ayon://{project}/{folder_path}?product={product}&version={version}"
+        "&representation={representation}".format(
+            project=project_name,
+            folder_path=folder_path,
+            product=product,
+            version=version,
+            representation=representation_name
+        )
+    )

client/ayon_core/pipeline/load/utils.py

@@ -5,7 +5,7 @@
 import inspect
 import collections
 import numbers
-from typing import Any
+from typing import Optional, Union, Any
 
 import ayon_api
 
@@ -739,6 +739,91 @@ def path_from_data():
     )
 
 
+def get_representation_path_by_names(
+        project_name: str,
+        folder_path: str,
+        product_name: str,
+        version_name: str,
+        representation_name: str,
+        anatomy: Optional[Anatomy] = None) -> Optional[str]:
+    """Get (latest) filepath for representation for folder and product.
+
+    See `get_representation_by_names` for more details.
+
+    Returns:
+        str: The representation path if the representation exists.
+
+    """
+    representation = get_representation_by_names(
+        project_name,
+        folder_path,
+        product_name,
+        version_name,
+        representation_name
+    )
+    if not representation:
+        return
+
+    if not anatomy:
+        anatomy = Anatomy(project_name)
+
+    if representation:
+        path = get_representation_path_with_anatomy(representation, anatomy)
+        return str(path).replace("\\", "/")
+
+
+def get_representation_by_names(
+        project_name: str,
+        folder_path: str,
+        product_name: str,
+        version_name: Union[int, str],
+        representation_name: str,
+) -> Optional[dict]:
+    """Get representation entity for asset and subset.
+
+    If version_name is "hero" then return the hero version
+    If version_name is "latest" then return the latest version
+    Otherwise use version_name as the exact integer version name.
+
+    """
+
+    if isinstance(folder_path, dict) and "name" in folder_path:
+        # Allow explicitly passing asset document
+        folder_entity = folder_path
+    else:
+        folder_entity = ayon_api.get_folder_by_path(
+            project_name, folder_path, fields=["id"])
+    if not folder_entity:
+        return
+
+    if isinstance(product_name, dict) and "name" in product_name:
+        # Allow explicitly passing subset document
+        product_entity = product_name
+    else:
+        product_entity = ayon_api.get_product_by_name(
+            project_name,
+            product_name,
+            folder_id=folder_entity["id"],
+            fields=["id"])
+    if not product_entity:
+        return
+
+    if version_name == "hero":
+        version_entity = ayon_api.get_hero_version_by_product_id(
+            project_name, product_id=product_entity["id"])
+    elif version_name == "latest":
+        version_entity = ayon_api.get_last_version_by_product_id(
+            project_name, product_id=product_entity["id"])
+    else:
+        version_entity = ayon_api.get_version_by_name(
+            project_name, version_name, product_id=product_entity["id"])
+    if not version_entity:
+        return
+
+    return ayon_api.get_representation_by_name(
+        project_name, representation_name, version_id=version_entity["id"])
+
+
 def is_compatible_loader(Loader, context):
     """Return whether a loader is compatible with a context.
 

client/ayon_core/pipeline/publish/lib.py

@@ -4,6 +4,7 @@
 import copy
 import tempfile
 import xml.etree.ElementTree
+from typing import Optional, Union
 
 import pyblish.util
 import pyblish.plugin
@@ -20,7 +21,6 @@
     Anatomy
 )
 from ayon_core.pipeline.plugin_discover import DiscoverResult
-
 from .constants import (
     DEFAULT_PUBLISH_TEMPLATE,
     DEFAULT_HERO_PUBLISH_TEMPLATE,
@@ -933,3 +933,48 @@ def get_publish_instance_families(instance):
         families.discard(family)
     output.extend(families)
     return output
+
+
+def get_instance_expected_output_path(
+        instance: pyblish.api.Instance,
+        representation_name: str,
+        ext: Union[str, None],
+        version: Optional[str] = None
+):
+    """Return expected publish filepath for representation in instance
+
+    This does not validate whether the instance has any representation by the
+    given name, extension and/or version.
+
+    Arguments:
+        instance (pyblish.api.Instance): Publish instance
+        representation_name (str): Representation name
+        ext (Union[str, None]): Extension for the file.
+            When None, the `ext` will be set to the representation name.
+        version (Optional[int]): If provided, force it to format to this
+            particular version.
+
+    Returns:
+        str: Resolved path
+
+    """
+
+    if ext is None:
+        ext = representation_name
+    if version is None:
+        version = instance.data["version"]
+
+    context = instance.context
+    anatomy = context.data["anatomy"]
+
+    template_data = copy.deepcopy(instance.data["anatomyData"])
+    template_data.update({
+        "ext": ext,
+        "representation": representation_name,
+        "variant": instance.data.get("variant"),
+        "version": version
+    })
+
+    path_template_obj = anatomy.get_template_item("publish", "default")["path"]
+    template_filled = path_template_obj.format_strict(template_data)
+    return os.path.normpath(template_filled)