lib

def fill_placeholder(placeholder, workfile_path, context):
    """Replaces placeholder with actual path to representation

    Args:
        placeholder (str): in format PLACEHOLDER_VALUE_PATTERN
        workfile_path (str): absolute path to opened workfile
        context (dict): contains context data from launch context
    Returns:
        (dict, str) path to resolved representation file which should be used
            instead of placeholder
    Raises
        (PlaceholderFillException) if path cannot be resolved (cannot find
        product, version etc.)

    """
    token_and_values = get_token_and_values(placeholder)

    project_name = context["project_name"]

    folder_token = token_and_values["folder_token"]
    folder_entity = _get_folder_entity(project_name, folder_token, context)
    folder_id = folder_entity["id"]

    product_name = token_and_values["product_name"]
    product_id = _get_product_id(
        project_name,
        folder_id,
        product_name,
        folder_entity["path"]
    )

    version_val = token_and_values["version"]
    version_id = _get_version(
        project_name,
        product_name,
        product_id,
        version_val,
        workfile_path
    )

    ext = token_and_values["ext"]
    repre, repre_path = _get_repre_and_path(
        project_name, product_name, ext, version_id)

    return repre, repre_path

def find_variant_key(application_manager, host):
    """Searches for latest installed variant for 'host'

        Args:
            application_manager (ApplicationManager)
            host (str)
        Returns
            (string) (optional)
        Raises:
            (ValueError) if no variant found
    """
    app_group = application_manager.app_groups.get(host)
    if not app_group or not app_group.enabled:
        raise ValueError("No application '{}' configured".format(host))

    found_variant_key = None
    # finds most up-to-date variant if any installed
    sorted_variants = collections.OrderedDict(
        sorted(app_group.variants.items()))
    for variant_key, variant in sorted_variants.items():
        for executable in variant.executables:
            if executable.exists():
                found_variant_key = variant_key

    if not found_variant_key:
        raise ValueError("No executable for '{}' found".format(host))

    return found_variant_key

def get_multiple_templates_profile(
        project_settings, task_name, task_type, log=None):
    """Returns configured profile for current context"""
    wrap_settings = project_settings["wrap"]
    multiple_templates_profiles = (
        wrap_settings)["multiple_templates_per_tasks"]["profiles"]
    if not multiple_templates_profiles:
        return

    found_profile = filter_profiles(
        multiple_templates_profiles,
        {
            "task_names": task_name,
            "task_types": task_type,
        },
        logger=log
    )

    return found_profile