Proxification

from specklepy.objects import Base

def build_applicationid_index(root):
    """
    Traverse the object graph and index all objects by applicationId.
    This is the foundation for resolving any proxy references.
    """
    index = {}

    def traverse(obj):
        # Index objects with applicationId
        if isinstance(obj, Base) and hasattr(obj, "applicationId"):
            if obj.applicationId:
                index[obj.applicationId] = obj

        # Traverse elements hierarchy
        if hasattr(obj, "elements") and isinstance(obj.elements, list):
            for element in obj.elements:
                traverse(element)

        # Traverse other properties
        if isinstance(obj, Base):
            for name in obj.get_member_names():
                if not name.startswith("_") and name != "elements":
                    value = getattr(obj, name, None)
                    if value is not None:
                        traverse(value)
        elif isinstance(obj, list):
            for item in obj:
                traverse(item)

    traverse(root)
    return index

# Build once, use many times
app_id_index = build_applicationid_index(root)
print(f"Indexed {len(app_id_index)} objects")

def resolve_level_proxies(root, app_id_index):
    """
    Resolve level proxies to get level -> objects mapping.
    """
    from specklepy.objects.proxies import LevelProxy

    levels = {}

    # Get level proxies from root
    if hasattr(root, "levelProxies"):
        level_proxies = getattr(root, "levelProxies")

        for proxy in level_proxies:
            if not isinstance(proxy, LevelProxy):
                continue

            level_name = proxy.value.name
            levels[level_name] = []

            # Resolve each applicationId
            for app_id in proxy.objects:
                if app_id in app_id_index:
                    obj = app_id_index[app_id]
                    levels[level_name].append(obj)

    return levels

# Use it
levels = resolve_level_proxies(root, app_id_index)

for level_name, objects in levels.items():
    print(f"{level_name}: {len(objects)} objects")

from specklepy.objects.proxies import (
    LevelProxy,
    ColorProxy,
    GroupProxy,
    RenderMaterialProxy
)

def resolve_proxies(root):
    """
    General proxy resolution for all proxy types.
    Returns a dictionary of resolved proxy collections.
    """
    # Step 1: Build applicationId index
    app_id_index = build_applicationid_index(root)

    # Step 2: Resolve each proxy type
    resolved = {
        "levels": {},
        "colors": {},
        "groups": {},
        "materials": {}
    }

    # Resolve level proxies
    if hasattr(root, "levelProxies"):
        for proxy in getattr(root, "levelProxies", []):
            if isinstance(proxy, LevelProxy):
                level_name = proxy.value.name
                resolved["levels"][level_name] = [
                    app_id_index[app_id]
                    for app_id in proxy.objects
                    if app_id in app_id_index
                ]

    # Resolve color proxies
    if hasattr(root, "colorProxies"):
        for proxy in getattr(root, "colorProxies", []):
            if isinstance(proxy, ColorProxy):
                color_name = proxy.name or f"Color_{proxy.value}"
                resolved["colors"][color_name] = [
                    app_id_index[app_id]
                    for app_id in proxy.objects
                    if app_id in app_id_index
                ]

    # Resolve group proxies
    if hasattr(root, "groupProxies"):
        for proxy in getattr(root, "groupProxies", []):
            if isinstance(proxy, GroupProxy):
                resolved["groups"][proxy.name] = [
                    app_id_index[app_id]
                    for app_id in proxy.objects
                    if app_id in app_id_index
                ]

    # Resolve render material proxies
    if hasattr(root, "renderMaterialProxies"):
        for proxy in getattr(root, "renderMaterialProxies", []):
            if isinstance(proxy, RenderMaterialProxy):
                mat_name = proxy.value.name if hasattr(proxy.value, "name") else "Unknown"
                resolved["materials"][mat_name] = [
                    app_id_index[app_id]
                    for app_id in proxy.objects
                    if app_id in app_id_index
                ]

    return resolved

# Resolve all proxies at once
# Use it
all_proxies = resolve_proxies(root)

print(f"Resolved {len(all_proxies['levels'])} levels")
print(f"Resolved {len(all_proxies['colors'])} colors")
print(f"Resolved {len(all_proxies['groups'])} groups")
print(f"Resolved {len(all_proxies['materials'])} materials")

from collections import defaultdict

def query_by_multiple_criteria(root, level=None, group=None, layer=None, material=None):
    """
    Find objects that match multiple organizational criteria simultaneously.
    Example: "exterior walls on Level 1 using concrete"
    """
    # Build applicationId index
    app_id_index = build_applicationid_index(root)

    # Get all proxy collections
    level_proxies = getattr(root, "levelProxies", [])
    group_proxies = getattr(root, "groupProxies", [])
    color_proxies = getattr(root, "colorProxies", [])
    material_proxies = getattr(root, "renderMaterialProxies", [])

    # Build sets of applicationIds for each criteria
    matching_sets = []

    # Level criteria
    if level:
        for proxy in level_proxies:
            if proxy.value.name == level:
                matching_sets.append(set(proxy.objects))
                break

    # Group criteria
    if group:
        for proxy in group_proxies:
            if proxy.name == group:
                matching_sets.append(set(proxy.objects))
                break

    # Layer/color criteria
    if layer:
        for proxy in color_proxies:
            if proxy.name == layer:
                matching_sets.append(set(proxy.objects))
                break

    # Material criteria
    if material:
        for proxy in material_proxies:
            mat_name = proxy.value.name if hasattr(proxy.value, "name") else ""
            if mat_name == material:
                matching_sets.append(set(proxy.objects))
                break

    # Find intersection of all criteria
    if not matching_sets:
        return []

    # Intersection = objects that match ALL criteria
    matching_app_ids = matching_sets[0]
    for app_id_set in matching_sets[1:]:
        matching_app_ids = matching_app_ids.intersection(app_id_set)

    # Resolve to actual objects
    results = [
        app_id_index[app_id]
        for app_id in matching_app_ids
        if app_id in app_id_index
    ]

    return results

# Use it - complex queries across multiple hierarchies
exterior_walls_level_1 = query_by_multiple_criteria(
    root,
    level="Level 1",
    group="Exterior Walls"
)
print(f"Found {len(exterior_walls_level_1)} exterior walls on Level 1")

# Even more specific
concrete_exterior_walls_level_1 = query_by_multiple_criteria(
    root,
    level="Level 1",
    group="Exterior Walls",
    material="Concrete"
)
print(f"Found {len(concrete_exterior_walls_level_1)} concrete exterior walls on Level 1")

# Layer + Group intersection
walls_on_a_wall_layer_in_group = query_by_multiple_criteria(
    root,
    layer="A-WALL",
    group="Exterior Walls"
)

def find_object_in_proxies(root, target_obj):
    """
    Find which proxy collections reference a given object.
    Returns dictionary of proxy types and names.
    """
    target_app_id = getattr(target_obj, "applicationId", None)
    if not target_app_id:
        return {}

    memberships = {
        "level": None,
        "colors": [],
        "groups": [],
        "materials": []
    }

    # Check level proxies
    if hasattr(root, "levelProxies"):
        for proxy in getattr(root, "levelProxies", []):
            if target_app_id in proxy.objects:
                memberships["level"] = proxy.value.name
                break

    # Check color proxies
    if hasattr(root, "colorProxies"):
        for proxy in getattr(root, "colorProxies", []):
            if target_app_id in proxy.objects:
                memberships["colors"].append(proxy.name or f"Color_{proxy.value}")

    # Check group proxies
    if hasattr(root, "groupProxies"):
        for proxy in getattr(root, "groupProxies", []):
            if target_app_id in proxy.objects:
                memberships["groups"].append(proxy.name)

    # Check material proxies
    if hasattr(root, "renderMaterialProxies"):
        for proxy in getattr(root, "renderMaterialProxies", []):
            if target_app_id in proxy.objects:
                mat_name = proxy.value.name if hasattr(proxy.value, "name") else "Unknown"
                memberships["materials"].append(mat_name)

    return memberships

# Use it
wall = walls[0]
memberships = find_object_in_proxies(root, wall)

print(f"Wall is on level: {memberships['level']}")
print(f"Wall is in colors: {memberships['colors']}")
print(f"Wall is in groups: {memberships['groups']}")
print(f"Wall has materials: {memberships['materials']}")

def resolve_display_value(obj, app_id_index):
    """
    Resolve display value if it contains proxy references.
    Returns list of actual geometry objects.
    """
    display_geometry = []

    # Check if displayValue exists
    if not hasattr(obj, "displayValue"):
        return display_geometry

    display_value = obj.displayValue

    # Case 1: displayValue is a list of objects (normal case)
    if isinstance(display_value, list):
        for item in display_value:
            # If item is a string, it's a proxy reference
            if isinstance(item, str):
                if item in app_id_index:
                    display_geometry.append(app_id_index[item])
            else:
                # Direct object (normal case)
                display_geometry.append(item)

    # Case 2: displayValue is a single object
    elif isinstance(display_value, str):
        # String means proxy reference
        if display_value in app_id_index:
            display_geometry.append(app_id_index[display_value])
    else:
        # Direct object
        display_geometry.append(display_value)

    return display_geometry

# Use it
app_id_index = build_applicationid_index(root)

for wall in walls:
    geometry = resolve_display_value(wall, app_id_index)
    print(f"{wall.name}: {len(geometry)} display meshes")