Fix: Parse nested targets within label_selector load balancer targets

When a load balancer has a label_selector type target, the API returns
a nested "targets" array containing the resolved individual server
targets with their health statuses. This data was previously discarded.

- Add `targets` parameter to `LoadBalancerTarget.__init__` in domain.py
- Parse nested targets in `BoundLoadBalancer.__init__` for label_selector
  targets, creating `LoadBalancerTarget` objects with server, health_status,
  type, and use_private_ip fields
- Add test fixture and test case for nested target parsing

https://claude.ai/code/session_018oDf81V2LsgKcFheq7KSRp

Author: claude

hcloud/load_balancers/client.py

@@ -108,6 +108,33 @@ def __init__(
                         selector=target["label_selector"]["selector"]
                     )
                     tmp_target.use_private_ip = target["use_private_ip"]
+                    nested_targets = target.get("targets", [])
+                    if nested_targets:
+                        tmp_nested = []
+                        for nested in nested_targets:
+                            nested_target = LoadBalancerTarget(type=nested["type"])
+                            if nested["type"] == "server":
+                                nested_target.server = BoundServer(
+                                    client._parent.servers,
+                                    data=nested["server"],
+                                    complete=False,
+                                )
+                            elif nested["type"] == "ip":
+                                nested_target.ip = LoadBalancerTargetIP(
+                                    ip=nested["ip"]["ip"]
+                                )
+                            nested_target.use_private_ip = nested.get("use_private_ip")
+                            nested_health_status = nested.get("health_status")
+                            if nested_health_status is not None:
+                                nested_target.health_status = [
+                                    LoadBalancerTargetHealthStatus(
+                                        listen_port=hs["listen_port"],
+                                        status=hs["status"],
+                                    )
+                                    for hs in nested_health_status
+                                ]
+                            tmp_nested.append(nested_target)
+                        tmp_target.targets = tmp_nested
                 elif target["type"] == "ip":
                     tmp_target.ip = LoadBalancerTargetIP(ip=target["ip"]["ip"])
 

hcloud/load_balancers/domain.py

@@ -420,6 +420,7 @@ class LoadBalancerTarget(BaseDomain):
         "ip",
         "use_private_ip",
         "health_status",
+        "targets",
     )
     __slots__ = __api_properties__
 
@@ -431,13 +432,15 @@ def __init__(
         ip: LoadBalancerTargetIP | None = None,
         use_private_ip: bool | None = None,
         health_status: list[LoadBalancerTargetHealthStatus] | None = None,
+        targets: list[LoadBalancerTarget] | None = None,
     ):
         self.type = type
         self.server = server
         self.label_selector = label_selector
         self.ip = ip
         self.use_private_ip = use_private_ip
         self.health_status = health_status
+        self.targets = targets
 
     def to_payload(self) -> dict[str, Any]:
         """

tests/unit/load_balancers/conftest.py

@@ -86,7 +86,23 @@ def response_load_balancer():
                     "health_status": [{"listen_port": 443, "status": "healthy"}],
                     "label_selector": None,
                     "use_private_ip": False,
-                }
+                },
+                {
+                    "type": "label_selector",
+                    "label_selector": {"selector": "eu"},
+                    "use_private_ip": True,
+                    "targets": [
+                        {
+                            "type": "server",
+                            "server": {"id": 105054278},
+                            "use_private_ip": True,
+                            "health_status": [
+                                {"listen_port": 443, "status": "healthy"},
+                                {"listen_port": 3000, "status": "healthy"},
+                            ],
+                        }
+                    ],
+                },
             ],
             "algorithm": {"type": "round_robin"},
         }

tests/unit/load_balancers/test_client.py

@@ -60,6 +60,29 @@ def test_init(self, response_load_balancer):
         assert bound_load_balancer.id == 4711
         assert bound_load_balancer.name == "Web Frontend"
 
+    def test_init_label_selector_nested_targets(self, response_load_balancer):
+        bound_load_balancer = BoundLoadBalancer(
+            client=mock.MagicMock(), data=response_load_balancer["load_balancer"]
+        )
+
+        label_selector_target = bound_load_balancer.targets[1]
+        assert label_selector_target.type == "label_selector"
+        assert label_selector_target.label_selector.selector == "eu"
+        assert label_selector_target.use_private_ip is True
+        assert label_selector_target.targets is not None
+        assert len(label_selector_target.targets) == 1
+
+        nested = label_selector_target.targets[0]
+        assert nested.type == "server"
+        assert nested.server.id == 105054278
+        assert nested.use_private_ip is True
+        assert nested.health_status is not None
+        assert len(nested.health_status) == 2
+        assert nested.health_status[0].listen_port == 443
+        assert nested.health_status[0].status == "healthy"
+        assert nested.health_status[1].listen_port == 3000
+        assert nested.health_status[1].status == "healthy"
+
 
 class TestLoadBalancerslient:
     @pytest.fixture()