Example #1
0
def get_project_assetbuild():
    assetbuildtype = utils.mock_entity(("name", "Character"),
                                       entity_type="Type")
    project = tpt.get_project()
    return utils.mock_entity(("parent", project), ("project", project),
                             ("name", "lizard"), ("type", assetbuildtype),
                             entity_type="AssetBuild")
def get_project_sequence_shot_task_imagefiles():
    entities = []

    # project/sq001/sh0010/compositing imagefiles
    for ext in lib.get_imagefile_extensions():
        assettype = utils.mock_entity(("short", "img"),
                                      entity_type="AssetType")
        asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                                  ("type", assettype),
                                  entity_type="Asset")
        assetversion = utils.mock_entity(
            ("asset", asset), ("task", get_project_sequence_shot_task()),
            ("version", 1), ("metadata", {
                "instance_name": "Write1"
            }),
            entity_type="AssetVersion")
        sequence_component = utils.mock_entity(
            ("version", assetversion), ("name", "main"), ("file_type", ext),
            ("padding", 4),
            entity_type="SequenceComponent")
        entities.append(sequence_component)

        file_component = utils.mock_entity(
            ("version", None), ("container", sequence_component),
            ("file_type", ext), ("name", "1001"),
            entity_type="FileComponent")
        entities.append(file_component)

    return entities
Example #3
0
    def process(self, instance):
        instance.data["component_overwrite"] = True
        families = instance.data.get("families", [])
        families += [instance.data["family"]]

        # Only commiting first and last frame to optimize calls to Ftrack.
        # Need first and last for later importing with Ftrack Importer.
        if "collection" in instance.data.keys():
            indexes = instance.data["collection"].indexes
            ranges = "[{0},{1}]".format(min(indexes), max(indexes))
            instance.data["pattern"] = "{head}{padding}{tail} " + ranges

        if len(list(set(self.families) & set(families))) == 1:
            data = instance.data.get("assetversion_data", {})
            metadata = data.get("metadata", {})
            metadata.update({"instance_name": instance.data["name"]})
            data["metadata"] = metadata
            instance.data["assetversion_data"] = data

        if "geometry" in families:
            instance.data["assettype_data"] = {"short": "model"}

        if "camera" in families:
            instance.data["assettype_data"] = {"short": "camera"}

        if "camera" in families or "geometry" in families:
            # Ensure never to overwrite
            instance.data["component_overwrite"] = False
            # Version starts from context version
            version = instance.context.data["version"]
            # Check for next available version on disk
            assettype = utils.mock_entity(
                ("short", instance.data["assettype_data"]["short"]),
                entity_type="Asset")
            asset = utils.mock_entity(
                ("parent", instance.context.data["ftrackTask"]["parent"]),
                ("type", assettype),
                entity_type="Asset")
            assetversion = utils.mock_entity(
                ("asset", asset),
                ("task", instance.context.data["ftrackTask"]),
                ("version", version), ("metadata", {
                    "instance_name": instance.data["name"]
                }),
                entity_type="AssetVersion")
            component = utils.mock_entity(
                ("version", assetversion),
                ("file_type", os.path.splitext(
                    instance.data["output_path"])[1]),
                entity_type="FileComponent")

            location = instance.context.data["ftrackSession"].pick_location()
            instance.data["version"] = self.recursive_available_version(
                component, location)
def get_project_folder_assetbuild():
    project = tpt.get_project()

    # project/assets/castle/lookdev
    folder = utils.mock_entity(("parent", project), ("name", "Assets"),
                               entity_type="Folder")
    assetbuildtype = utils.mock_entity(("name", "Environment"),
                                       entity_type="Type")
    return utils.mock_entity(
        ("parent", folder), ("project", tpt.get_project()), ("name", "castle"),
        ("type", assetbuildtype),
        entity_type="AssetBuild")
def get_project_sequence_task_workfiles():
    entities = []
    for ext in lib.get_workfile_extensions():
        entity = utils.mock_entity(
            ("parent", get_project_sequence()), ("project", tpt.get_project()),
            ("version", 1), ("file_type", ext), ("name", "compositing"),
            entity_type="Task")
        entities.append(entity)
    return entities
def get_project_task_files():
    entities = []

    # project/sq001/sh0010/compositing/.gizmo
    assettype = utils.mock_entity(("short", "lut"), entity_type="AssetType")
    asset = utils.mock_entity(("parent", get_project()), ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_task()), ("version", 1),
        ("metadata", {
            "instance_name": "Group1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".gizmo"),
                                  entity_type="FileComponent")
    entities.append(component)

    return entities
def get_project_task_workfiles():
    entities = []
    task = get_project_task()
    for ext in lib.get_workfile_extensions():
        task = utils.mock_entity(("project", task["project"]),
                                 ("parent", task["parent"]), ("version", 1),
                                 ("file_type", ext), ("name", "editing"),
                                 entity_type="Task")
        entities.append(task)
    return entities
Example #8
0
def get_project_assetbuild_task_workfiles():
    entities = []
    for ext in lib.get_workfile_extensions():
        entity = utils.mock_entity(("parent", get_project_assetbuild()),
                                   ("project", tpt.get_project()),
                                   ("version", 1), ("file_type", ext),
                                   ("name", "lookdev"),
                                   entity_type="Task")
        entities.append(entity)
    return entities
Example #9
0
    def process(self, instance):
        import os
        import lucidity
        from tgbvfx_environment import utils

        # Ignore source instance
        if "source" == instance.data["family"]:
            return

        # Ignore review instance
        if "review" == instance.data["family"]:
            return

        # Ignore NukeStudio for now
        if pyblish.api.current_host() == "nukestudio":
            return

        templates = lucidity.discover_templates()

        families = [
            "img", "gizmo", "lut", "scene", "cache", "mov", "camera",
            "geometry"
        ]
        assettype_short = list(
            set(instance.data["families"]) & set(families)
        )[0]
        if assettype_short in ["gizmo", "lut"]:
            assettype_short = "nuke_gizmo"
        if assettype_short in ["geometry"]:
            assettype_short = "model"

        assettype = utils.mock_entity(
            ("short", assettype_short),
            entity_type="AssetType"
        )
        asset = utils.mock_entity(
            ("parent", instance.context.data["ftrackTask"]["parent"]),
            ("type", assettype),
            entity_type="Asset"
        )
        assetversion = utils.mock_entity(
            ("asset", asset),
            ("task", instance.context.data["ftrackTask"]),
            ("version", 1),
            ("metadata", {"instance_name": instance.data["name"]}),
            entity_type="AssetVersion"
        )

        entity = None
        if "collection" in instance.data.keys():
            path = instance.data["collection"].format("{head}{padding}{tail}")
            entity = utils.mock_entity(
                ("version", assetversion),
                ("name", "main"),
                ("file_type", os.path.splitext(path)[1]),
                entity_type="SequenceComponent"
            )
        if "output_path" in instance.data.keys():
            path = instance.data["output_path"]
            entity = utils.mock_entity(
                ("version", assetversion),
                ("name", "main"),
                ("file_type", os.path.splitext(path)[1]),
                entity_type="FileComponent"
            )

        file_template_exists = False
        template_name = templates[0].get_template_name(entity)
        for template in templates:
            if template_name == template.name:
                file_template_exists = True

        msg = "Could not find any file templates for \"{0}\""
        assert file_template_exists, msg.format(template_name)
def get_project():
    return utils.mock_entity(("disk", {
        "windows": "//10.10.200.11",
        "unix": "//10.10.200.11"
    }), ("root", "171001_ftrack"), ("name", "pipeline_test"),
                             entity_type="Project")
def get_project_task():
    project = get_project()

    return utils.mock_entity(("parent", project), ("project", project),
                             ("name", "editing"),
                             entity_type="Task")
def get_project_sequence_shot_task():
    return utils.mock_entity(("parent", get_project_sequence_shot()),
                             ("project", tpt.get_project()), ("version", 1),
                             ("name", "compositing"),
                             entity_type="Task")
def get_project_sequence_shot():
    return utils.mock_entity(("parent", get_project_sequence()),
                             ("project", tpt.get_project()),
                             ("name", "sh0010"),
                             entity_type="Shot")
def get_project_sequence():
    return utils.mock_entity(("parent", tpt.get_project()),
                             ("project", tpt.get_project()), ("name", "sq001"),
                             entity_type="Sequence")
Example #15
0
def get_project_assetbuild_task():
    return utils.mock_entity(("parent", get_project_assetbuild()),
                             ("project", tpt.get_project()), ("version", 1),
                             ("name", "lookdev"),
                             entity_type="Task")
def get_project_sequence_shot_task_files():
    entities = []

    # project/sq001/sh0010/compositing/.gizmo
    assettype = utils.mock_entity(("short", "nuke_gizmo"),
                                  entity_type="AssetType")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1), ("metadata", {
            "instance_name": "Group1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".gizmo"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/sq001/sh0010/compositing/lut
    assettype = utils.mock_entity(("short", "lut"), entity_type="AssetType")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1), ("metadata", {
            "instance_name": "Group1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".gizmo"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/sq001/sh0010/compositing/.nk file
    assettype = utils.mock_entity(("short", "scene"), entity_type="Asset")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1), ("metadata", {
            "instance_name": "BackdropNode1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".nk"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/sq001/sh0010/compositing/.mov file
    assettype = utils.mock_entity(("short", "mov"), entity_type="Asset")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1), ("metadata", {
            "instance_name": "write1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion),
                                  ("file_type", ".mov"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/sq001/sh0010/compositing/.mov file
    assettype = utils.mock_entity(("short", "mov"), entity_type="Asset")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1), ("metadata", {
            "instance_name": "write1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion),
                                  ("file_type", ".R3D"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/sq001/sh0010/compositing/.psd file
    assettype = utils.mock_entity(("short", "scene"), entity_type="Asset")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1), ("metadata", {
            "instance_name": "write1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion),
                                  ("file_type", ".psd"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/sq001/sh0010/compositing/.abc file
    assettype = utils.mock_entity(("short", "cache"), entity_type="Asset")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1), ("metadata", {
            "instance_name": "writegeo1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion),
                                  ("file_type", ".abc"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/sq001/sh0010/compositing/.fbx file
    assettype = utils.mock_entity(("short", "cache"), entity_type="Asset")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1), ("metadata", {
            "instance_name": "writegeo1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion),
                                  ("file_type", ".fbx"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/sq001/sh0010/compositing/.abc camera file
    assettype = utils.mock_entity(("short", "camera"), entity_type="Asset")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion),
                                  ("file_type", ".abc"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/sq001/sh0010/compositing/.abc model file
    assettype = utils.mock_entity(("short", "model"), entity_type="Asset")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1), ("metadata", {
            "instance_name": "writegeo1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion),
                                  ("file_type", ".abc"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/sq001/sh0010/compositing/.mb file
    assettype = utils.mock_entity(("short", "scene"), entity_type="Asset")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1), ("metadata", {
            "instance_name": "set1_mayaBinary"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".mb"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/sq001/sh0010/compositing/.ma file
    assettype = utils.mock_entity(("short", "scene"), entity_type="Asset")
    asset = utils.mock_entity(("parent", get_project_sequence_shot()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_sequence_shot_task()),
        ("version", 1), ("metadata", {
            "instance_name": "set1_mayaAscii"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".ma"),
                                  entity_type="FileComponent")
    entities.append(component)

    return entities
Example #17
0
def get_project_assetbuild_task_files():
    entities = []

    # project/lizard/lookdev/.gizmo
    assettype = utils.mock_entity(("short", "nuke_gizmo"),
                                  entity_type="AssetType")
    asset = utils.mock_entity(("parent", get_project_assetbuild()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(("asset", asset),
                                     ("task", get_project_assetbuild_task()),
                                     ("version", 1), ("metadata", {
                                         "instance_name": "Group1"
                                     }),
                                     entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".gizmo"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/lizard/lookdev/lut
    assettype = utils.mock_entity(("short", "lut"), entity_type="AssetType")
    asset = utils.mock_entity(("parent", get_project_assetbuild()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(("asset", asset),
                                     ("task", get_project_assetbuild_task()),
                                     ("version", 1), ("metadata", {
                                         "instance_name": "Group1"
                                     }),
                                     entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".gizmo"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/lizard/lookdev/.nk
    assettype = utils.mock_entity(("short", "scene"), entity_type="Type")
    asset = utils.mock_entity(("parent", get_project_assetbuild()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_assetbuild_task()),
        ("version", 1), ("metadata", {
            "instance_name": "BackdropNode1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion),
                                  ("file_type", ".nk"), ("name", "main"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/lizard/lookdev/.abc
    assettype = utils.mock_entity(("short", "cache"), entity_type="AssetType")
    asset = utils.mock_entity(("parent", get_project_assetbuild()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_assetbuild_task()),
        ("version", 1), ("metadata", {
            "instance_name": "WriteGeo1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".abc"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/lizard/lookdev/.fbx
    assettype = utils.mock_entity(("short", "cache"), entity_type="AssetType")
    asset = utils.mock_entity(("parent", get_project_assetbuild()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_assetbuild_task()),
        ("version", 1), ("metadata", {
            "instance_name": "WriteGeo1"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".fbx"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/lizard/lookdev/.mb
    assettype = utils.mock_entity(("short", "scene"), entity_type="AssetType")
    asset = utils.mock_entity(("parent", get_project_assetbuild()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_assetbuild_task()),
        ("version", 1), ("metadata", {
            "instance_name": "set1_mayaBinary"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".mb"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/lizard/lookdev/.ma
    assettype = utils.mock_entity(("short", "scene"), entity_type="AssetType")
    asset = utils.mock_entity(("parent", get_project_assetbuild()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(
        ("asset", asset), ("task", get_project_assetbuild_task()),
        ("version", 1), ("metadata", {
            "instance_name": "set1_mayaAscii"
        }),
        entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".ma"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/lizard/lookdev/.mov
    assettype = utils.mock_entity(("short", "mov"), entity_type="AssetType")
    asset = utils.mock_entity(("parent", get_project_assetbuild()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(("asset", asset),
                                     ("task", get_project_assetbuild_task()),
                                     ("version", 1), ("metadata", {
                                         "instance_name": "Write1"
                                     }),
                                     entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".mov"),
                                  entity_type="FileComponent")
    entities.append(component)

    # project/lizard/lookdev/.psd
    assettype = utils.mock_entity(("short", "scene"), entity_type="AssetType")
    asset = utils.mock_entity(("parent", get_project_assetbuild()),
                              ("type", assettype),
                              entity_type="Asset")
    assetversion = utils.mock_entity(("asset", asset),
                                     ("task", get_project_assetbuild_task()),
                                     ("version", 1), ("metadata", {
                                         "instance_name": "Write1"
                                     }),
                                     entity_type="AssetVersion")
    component = utils.mock_entity(("version", assetversion), ("name", "main"),
                                  ("file_type", ".psd"),
                                  entity_type="FileComponent")
    entities.append(component)

    return entities