Spaces:

Leon4gr45
/

agent-0

Running

agent-0 / resolve_path.py

Upload folder using huggingface_hub

1499d83 verified 10 days ago

2.84 kB

def resolve_path(path_string, aliases, depth=0, max_depth=5):
    """Resolve a path string using defined aliases, handling nested aliases recursively."""
    if not path_string:
        return path_string
    if depth > max_depth:
        print(
            f"Warning: Max alias resolution depth ({max_depth}) exceeded for initial '{path_string}'. Returning unresolved."
        )
        # Return original string that caused the depth issue, not intermediate one
        return path_string

    resolved = path_string  # Start with the original string for this level

    # 1. Check for exact match alias (full path replacement)
    if resolved in aliases:
        # Recursively resolve the alias's value. Pass the ORIGINAL path_string for error reporting.
        resolved = resolve_path(aliases[resolved], aliases, depth + 1, max_depth)
        # If recursion hit max depth, return the result from that level
        if depth + 1 > max_depth and resolved == aliases[resolved]:
            return resolved  # Return the unresolved alias value causing the issue
        # Continue resolution in case the resolved value itself contains a prefix alias

    # 2. Check for prefix alias on the potentially updated 'resolved' string
    if ":" in resolved:
        alias_key, rest_of_path = resolved.split(":", 1)
        if alias_key in aliases:
            # Recursively resolve the base path alias first. Pass the ORIGINAL path_string.
            base_path_alias_value = aliases[alias_key]
            base_path = resolve_path(
                base_path_alias_value, aliases, depth + 1, max_depth
            )
            # If recursion hit max depth, return the result from that level
            if depth + 1 > max_depth and base_path == base_path_alias_value:
                return resolved  # Return the string with the unresolved prefix alias causing the issue

            # Concatenate carefully
            if base_path and rest_of_path:
                # Avoid double slash if base_path ends with / or rest_of_path starts with /
                if base_path.endswith("/") and rest_of_path.startswith("/"):
                    resolved = base_path + rest_of_path[1:]
                elif not base_path.endswith("/") and not rest_of_path.startswith("/"):
                    resolved = f"{base_path}/{rest_of_path}"
                else:  # One ends with / or the other starts with /
                    resolved = base_path + rest_of_path
            elif base_path:
                resolved = base_path  # Only base path resolved
            # If prefix resolution happened, we assume it's the final form for this level
            # We don't try to re-resolve the combined path in the same call
            return resolved

    # Return the final resolved path after potentially multiple steps at this level
    return resolved

	def resolve_path(path_string, aliases, depth=0, max_depth=5):
	"""Resolve a path string using defined aliases, handling nested aliases recursively."""
	if not path_string:
	return path_string
	if depth > max_depth:
	print(
	f"Warning: Max alias resolution depth ({max_depth}) exceeded for initial '{path_string}'. Returning unresolved."
	)
	# Return original string that caused the depth issue, not intermediate one
	return path_string

	resolved = path_string # Start with the original string for this level

	# 1. Check for exact match alias (full path replacement)
	if resolved in aliases:
	# Recursively resolve the alias's value. Pass the ORIGINAL path_string for error reporting.
	resolved = resolve_path(aliases[resolved], aliases, depth + 1, max_depth)
	# If recursion hit max depth, return the result from that level
	if depth + 1 > max_depth and resolved == aliases[resolved]:
	return resolved # Return the unresolved alias value causing the issue
	# Continue resolution in case the resolved value itself contains a prefix alias

	# 2. Check for prefix alias on the potentially updated 'resolved' string
	if ":" in resolved:
	alias_key, rest_of_path = resolved.split(":", 1)
	if alias_key in aliases:
	# Recursively resolve the base path alias first. Pass the ORIGINAL path_string.
	base_path_alias_value = aliases[alias_key]
	base_path = resolve_path(
	base_path_alias_value, aliases, depth + 1, max_depth
	)
	# If recursion hit max depth, return the result from that level
	if depth + 1 > max_depth and base_path == base_path_alias_value:
	return resolved # Return the string with the unresolved prefix alias causing the issue

	# Concatenate carefully
	if base_path and rest_of_path:
	# Avoid double slash if base_path ends with / or rest_of_path starts with /
	if base_path.endswith("/") and rest_of_path.startswith("/"):
	resolved = base_path + rest_of_path[1:]
	elif not base_path.endswith("/") and not rest_of_path.startswith("/"):
	resolved = f"{base_path}/{rest_of_path}"
	else: # One ends with / or the other starts with /
	resolved = base_path + rest_of_path
	elif base_path:
	resolved = base_path # Only base path resolved
	# If prefix resolution happened, we assume it's the final form for this level
	# We don't try to re-resolve the combined path in the same call
	return resolved

	# Return the final resolved path after potentially multiple steps at this level
	return resolved