pipeline

def get_container_nodes():
    """Return a list of node names that are marked as loaded container."""
    container_nodes = []
    for node in rv.commands.nodes():
        prop = f"{node}.{AYON_ATTR_PREFIX}schema"
        if rv.commands.propertyExists(prop):
            container_nodes.append(node)
        else:
            # backward compatibility
            prop = f"{node}.openpype.schema"
            if rv.commands.propertyExists(prop):
                container_nodes.append(node)

    return container_nodes

def get_containers():
    """Yield container data for each container found in current workfile."""
    for node in get_container_nodes():
        container = parse_container(node)
        if container:
            yield container

def imprint(node, data, prefix=None):
    """Store attributes with value on a node.

    Args:
        node (object): The node to imprint data on.
        data (dict): Key value pairs of attributes to create.
        prefix (str): A prefix to add to all keys in the data.

    Returns:
        None

    """
    node_prefix = f"{node}.{prefix}" if prefix else f"{node}."
    for attr, value in data.items():
        # Create and set the attribute
        prop = f"{node_prefix}.{attr}"

        if isinstance(value, (dict, list, tuple)):
            value = f"{JSON_PREFIX}{json.dumps(value)}"

        if isinstance(value, (bool, int)):
            type_name = "Int"
        elif isinstance(value, float):
            type_name = "Float"
        elif isinstance(value, str):
            type_name = "String"
        else:
            raise TypeError("Unsupport data type to imprint: "
                            "{} (type: {})".format(value, type(value)))

        if not rv.commands.propertyExists(prop):
            type_ = getattr(rv.commands, f"{type_name}Type")
            rv.commands.newProperty(prop, type_, 1)
        set_property = getattr(rv.commands, f"set{type_name}Property")
        set_property(prop, [value], True)

def imprint_container(node, name, namespace, context, loader):
    """Imprint `node` with container metadata.

    Arguments:
        node (object): The node to containerise.
        name (str): Name of resulting assembly
        namespace (str): Namespace under which to host container
        context (dict): Asset information
        loader (str): Name of loader used to produce this container.

    Returns:
        None

    """

    data = {
        "schema": "ayon:container-2.0",
        "id": str(AYON_CONTAINER_ID),
        "name": str(name),
        "namespace": str(namespace),
        "loader": str(loader),
        "representation": str(context["representation"]["id"])
    }

    imprint(node, data, prefix=AYON_ATTR_PREFIX)

def parse_container(node):
    """Returns imprinted container data of a tool

    This reads the imprinted data from `imprint_container`.

    """
    # If not all required data return None
    required = ['id', 'schema', 'name',
                'namespace', 'loader', 'representation']

    data = {}
    for key in required:
        prop = f"{node}.{AYON_ATTR_PREFIX}{key}"
        if not rv.commands.propertyExists(prop):
            # backward compatibility
            prop = f"{node}.openpype.{key}"
            if not rv.commands.propertyExists(prop):
                return

        value = rv.commands.getStringProperty(prop)[0]
        data[key] = value

    # Store the node's name
    data["objectName"] = str(node)

    # Store reference to the node object
    data["node"] = node

    return data

def read(node, prefix=None):
    """Read properties from the given node with the values

    This function assumes all read values are of a single width and will
    return only the first entry. As such, arrays or multidimensional properties
    will not be returned correctly.

    Args:
        node (str): Name of node.
        prefix (str, optional): A prefix for the attributes to consider.
            This prefix will be stripped from the output key.

    Returns:
        dict: The key, value of the properties.

    """
    properties = rv.commands.properties(node)
    node_prefix = f"{node}.{prefix}" if prefix else f"{node}."
    type_getters = {
        1: rv.commands.getFloatProperty,
        2: rv.commands.getIntProperty,
        # Not sure why 3, 4 and 5 don't seem to be types
        5: rv.commands.getHalfProperty,
        6: rv.commands.getByteProperty,
        8: rv.commands.getStringProperty
    }

    data = {}
    for prop in properties:
        if prefix is not None and not prop.startswith(node_prefix):
            continue

        info = rv.commands.propertyInfo(prop)
        type_num = info["type"]
        value = type_getters[type_num](prop)
        if value:
            value = value[0]
        else:
            value = None

        if type_num == 8 and value and value.strip().startswith(JSON_PREFIX):
            # String
            value = json.loads(value.strip()[len(JSON_PREFIX):])

        key = prop[len(node_prefix):]
        data[key] = value

    return data