src(population): Use attrs + cattrs

Author: gegnew

cellengine/resources/population.py

@@ -1,44 +1,55 @@
 from __future__ import annotations
-from dataclasses import field
-from typing import Optional
+from typing import Dict, Optional
+from attr import define, field
 
-from dataclasses_json.cfg import config
-from cellengine.utils.dataclass_mixin import DataClassMixin, ReadOnly
-
-from dataclasses import dataclass
 import cellengine as ce
+from cellengine.utils import converter
+from cellengine.utils.readonly import readonly
 
 
-@dataclass
-class Population(DataClassMixin):
+@define
+class Population:
+    _id: str = field(on_setattr=readonly)
+    experiment_id: str = field(on_setattr=readonly)
     name: str
     gates: str
+    unique_name: Optional[str] = field(default=None, on_setattr=readonly)
     parent_id: Optional[str] = None
     terminal_gate_gid: Optional[str] = None
-    _id: str = field(
-        metadata=config(field_name="_id"), default=ReadOnly()
-    )  # type: ignore
-    experiment_id: str = field(default=ReadOnly())  # type: ignore
-    unique_name: str = field(default=ReadOnly())  # type: ignore
 
     def __repr__(self):
         return f"Population(_id='{self._id}', name='{self.name}')"
 
+    @property
+    def path(self):
+        return f"experiments/{self.experiment_id}/populations/{self._id}".rstrip(
+            "/None"
+        )
+
     @classmethod
-    def get(cls, experiment_id: str, _id: str = None, name: str = None):
+    def get(cls, experiment_id: str, _id: str = None, name: str = None) -> Population:
+        """Get Population by name or ID for a specific experiment. Either
+        `name` or `_id` must be specified.
+
+        Args:
+            experiment_id: ID of the experiment this attachment is connected with.
+            _id (optional): ID of the attachment.
+            name (optional): Name of the experiment.
+        """
         kwargs = {"name": name} if name else {"_id": _id}
         return ce.APIClient().get_population(experiment_id, **kwargs)
 
     @classmethod
-    def create(cls, experiment_id: str, population: dict) -> Population:
-        return ce.APIClient().post_population(experiment_id, population)
+    def from_dict(cls, data: Dict):
+        return converter.structure(data, cls)
+
+    def to_dict(self) -> Dict:
+        return converter.unstructure(self)
 
     def update(self):
         """Save changes to this Population to CellEngine."""
-        res = ce.APIClient().update_entity(
-            self.experiment_id, self._id, "populations", self.to_dict()
-        )
-        self.__dict__.update(Population.from_dict(res).__dict__)
+        res = ce.APIClient().update(self)
+        self.__setstate__(res.__getstate__())  # type: ignore
 
     def delete(self):
         ce.APIClient().delete_entity(self.experiment_id, "populations", self._id)

cellengine/utils/api_client/APIClient.py

@@ -554,7 +554,7 @@ def get_populations(
 
     def get_population(
         self, experiment_id, _id=None, name=None, as_dict=False
-    ) -> Union[Population, Dict[str, Any]]:
+    ) -> Population:
         _id = _id or self._get_id_by_name(name, "populations", experiment_id)
         population = self._get(
             f"{self.base_url}/experiments/{experiment_id}/populations/{_id}"

tests/fixtures/api-populations.py

@@ -1,7 +1,7 @@
 import pytest
 
 
-@pytest.fixture(scope="session")
+@pytest.fixture(scope="function")
 def populations():
     populations = [
         {

tests/unit/resources/test_population.py

@@ -8,9 +8,12 @@
 EXP_ID = "5d38a6f79fae87499999a74b"
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture(scope="function")
 def population(client, populations):
-    return Population.from_dict(populations[0])
+    pop = populations[0]
+    if "uniqueName" in pop.keys():
+        pop.pop("uniqueName")
+    return Population.from_dict(pop)
 
 
 def population_tester(population):
@@ -28,7 +31,18 @@ def population_tester(population):
 
 
 @responses.activate
-def test_should_get_population(ENDPOINT_BASE, population, populations):
+def test_client_gets_population(client, ENDPOINT_BASE, population, populations):
+    responses.add(
+        responses.GET,
+        ENDPOINT_BASE + f"/experiments/{EXP_ID}/populations/{population._id}",
+        json=populations[0],
+    )
+    pop = client.get_population(EXP_ID, population._id)
+    population_tester(pop)
+
+
+@responses.activate
+def test_population_gets_population(client, ENDPOINT_BASE, population, populations):
     responses.add(
         responses.GET,
         ENDPOINT_BASE + f"/experiments/{EXP_ID}/populations/{population._id}",
@@ -39,14 +53,25 @@ def test_should_get_population(ENDPOINT_BASE, population, populations):
 
 
 @responses.activate
-def test_should_post_population(ENDPOINT_BASE, population, populations):
+def test_get_populations_returns_unique_name(client, ENDPOINT_BASE, populations):
+    responses.add(
+        responses.GET,
+        ENDPOINT_BASE + f"/experiments/{EXP_ID}/populations",
+        json=populations,
+    )
+    pops = client.get_populations(EXP_ID)
+    assert all([pop.unique_name for pop in pops])
+
+
+@responses.activate
+def test_should_post_population(client, ENDPOINT_BASE, population, populations):
     responses.add(
         responses.POST,
         ENDPOINT_BASE + f"/experiments/{EXP_ID}/populations",
         json=populations[0],
     )
     payload = populations[0].copy()
-    pop = Population.create(EXP_ID, payload)
+    pop = client.post_population(EXP_ID, payload)
     population_tester(pop)