File size: 2,840 Bytes
1499d83 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | 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
|