Rename some "api" to "client" or "api_client"

API is too generic, a more specific name makes the code more clear.

Signed-off-by: Leandro Lucarella <[email protected]>

Author: llucax

src/frequenz/sdk/microgrid/_power_distributing/_component_managers/_battery_manager.py

@@ -309,18 +309,18 @@ async def _distribute_power(
 
     async def _create_channels(self) -> None:
         """Create channels to get data of components in microgrid."""
-        api = connection_manager.get().api_client
+        client = connection_manager.get().api_client
         manager_id = f"{type(self).__name__}«{hex(id(self))}»"
         for battery_id, inverter_ids in self._bat_invs_map.items():
-            bat_recv: Receiver[BatteryData] = BatteryData.subscribe(api, battery_id)
+            bat_recv: Receiver[BatteryData] = BatteryData.subscribe(client, battery_id)
             self._battery_caches[battery_id] = LatestValueCache(
                 bat_recv,
                 unique_id=f"{manager_id}:battery«{battery_id}»",
             )
 
             for inverter_id in inverter_ids:
                 inv_recv: Receiver[InverterData] = InverterData.subscribe(
-                    api, inverter_id
+                    client, inverter_id
                 )
                 self._inverter_caches[inverter_id] = LatestValueCache(
                     inv_recv, unique_id=f"{manager_id}:inverter«{inverter_id}»"
@@ -635,11 +635,11 @@ async def _set_distributed_power(
             Tuple where first element is total failed power, and the second element
             set of batteries that failed.
         """
-        api = connection_manager.get().api_client
+        client = connection_manager.get().api_client
 
         tasks = {
             inverter_id: asyncio.create_task(
-                api.set_component_power_active(inverter_id, power.as_watts())
+                client.set_component_power_active(inverter_id, power.as_watts())
             )
             for inverter_id, power in distribution.distribution.items()
             if power != Power.zero()

src/frequenz/sdk/microgrid/component_graph.py

@@ -544,22 +544,22 @@ def refresh_from(
         self._graph = new_graph
         old_graph.clear()  # just in case any references remain, but should not
 
-    async def refresh_from_api(
+    async def refresh_from_client(
         self,
-        api: MicrogridApiClient,
+        client: MicrogridApiClient,
         correct_errors: Callable[["_MicrogridComponentGraph"], None] | None = None,
     ) -> None:
         """Refresh the contents of a component graph from the remote API.
 
         Args:
-            api: The API client from which to fetch graph data.
+            client: The API client from which to fetch graph data
             correct_errors: The callback that, if set, will be invoked if the
                 provided graph data is in any way invalid (it will attempt to
                 correct the errors by inferring what the correct data should be).
         """
         components, connections = await asyncio.gather(
-            api.list_components(),
-            api.list_connections(),
+            client.list_components(),
+            client.list_connections(),
         )
 
         self.refresh_from(set(components), set(connections), correct_errors)

src/frequenz/sdk/microgrid/connection_manager.py

@@ -76,7 +76,7 @@ def location(self) -> Location | None:
             the location of the microgrid if available, None otherwise.
         """
 
-    async def _update_api(self, server_url: str) -> None:
+    async def _update_client(self, server_url: str) -> None:
         self._server_url = server_url
 
     @abstractmethod
@@ -98,8 +98,8 @@ def __init__(self, server_url: str) -> None:
                 `grpc://localhost:1090?ssl=true`.
         """
         super().__init__(server_url)
-        self._api = MicrogridApiClient(server_url)
-        # To create graph from the api we need await.
+        self._client = MicrogridApiClient(server_url)
+        # To create graph from the API client we need await.
         # So create empty graph here, and update it in `run` method.
         self._graph = _MicrogridComponentGraph()
 
@@ -108,12 +108,8 @@ def __init__(self, server_url: str) -> None:
 
     @property
     def api_client(self) -> MicrogridApiClient:
-        """Get the MicrogridApiClient.
-
-        Returns:
-            api client
-        """
-        return self._api
+        """The microgrid API client used by this connection manager."""
+        return self._client
 
     @property
     def microgrid_id(self) -> MicrogridId | None:
@@ -142,8 +138,8 @@ def component_graph(self) -> ComponentGraph:
         """
         return self._graph
 
-    async def _update_api(self, server_url: str) -> None:
-        """Update api with new host and port.
+    async def _update_client(self, server_url: str) -> None:
+        """Update the API client with a new server URL.
 
         Args:
             server_url: The new location of the microgrid API server in the form of a
@@ -153,14 +149,14 @@ async def _update_api(self, server_url: str) -> None:
                 a boolean (defaulting to false). For example:
                 `grpc://localhost:1090?ssl=true`.
         """
-        await super()._update_api(server_url)  # pylint: disable=protected-access
+        await super()._update_client(server_url)  # pylint: disable=protected-access
 
-        self._api = MicrogridApiClient(server_url)
+        self._client = MicrogridApiClient(server_url)
         await self._initialize()
 
     async def _initialize(self) -> None:
-        self._metadata = await self._api.get_microgrid_info()
-        await self._graph.refresh_from_api(self._api)
+        self._metadata = await self._client.get_microgrid_info()
+        await self._graph.refresh_from_client(self._client)
 
 
 _CONNECTION_MANAGER: ConnectionManager | None = None

tests/microgrid/test_graph.py

@@ -950,8 +950,8 @@ def pretend_to_correct_errors(_g: gr._MicrogridComponentGraph) -> None:
         assert graph.connections() == {Connection(ComponentId(10), ComponentId(11))}
         graph.validate()
 
-    async def test_refresh_from_api(self) -> None:
-        """Test the refresh_from_api method."""
+    async def test_refresh_from_client(self) -> None:
+        """Test the refresh_from_client method."""
         graph = gr._MicrogridComponentGraph()
         assert graph.components() == set()
         assert graph.connections() == set()
@@ -968,7 +968,7 @@ async def test_refresh_from_api(self) -> None:
 
         # both components and connections must be non-empty
         with pytest.raises(gr.InvalidGraphError):
-            await graph.refresh_from_api(client)
+            await graph.refresh_from_client(client)
         assert graph.components() == set()
         assert graph.connections() == set()
         with pytest.raises(gr.InvalidGraphError):
@@ -978,7 +978,7 @@ async def test_refresh_from_api(self) -> None:
             Component(ComponentId(1), ComponentCategory.GRID)
         ]
         with pytest.raises(gr.InvalidGraphError):
-            await graph.refresh_from_api(client)
+            await graph.refresh_from_client(client)
         assert graph.components() == set()
         assert graph.connections() == set()
         with pytest.raises(gr.InvalidGraphError):
@@ -987,7 +987,7 @@ async def test_refresh_from_api(self) -> None:
         client.list_components.return_value = []
         client.list_connections.return_value = [Connection(ComponentId(1), ComponentId(2))]
         with pytest.raises(gr.InvalidGraphError):
-            await graph.refresh_from_api(client)
+            await graph.refresh_from_client(client)
         assert graph.components() == set()
         assert graph.connections() == set()
         with pytest.raises(gr.InvalidGraphError):
@@ -1009,7 +1009,7 @@ async def test_refresh_from_api(self) -> None:
             Connection(ComponentId(101), ComponentId(111)),
             Connection(ComponentId(111), ComponentId(131)),
         ]
-        await graph.refresh_from_api(client)
+        await graph.refresh_from_client(client)
 
         # Note: we need to add GriMetadata as a dict here, because that's what
         # the ComponentGraph does too, and we need to be able to compare the
@@ -1053,7 +1053,7 @@ async def test_refresh_from_api(self) -> None:
             Connection(ComponentId(727), ComponentId(737)),
             Connection(ComponentId(717), ComponentId(747)),
         ]
-        await graph.refresh_from_api(client)
+        await graph.refresh_from_client(client)
 
         expected = {
             Component(