src(population): Use attrs + cattrs

Author: gegnew

cellengine/resources/population.py

@@ -1,44 +1,46 @@
 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}')"
 
-    @classmethod
-    def get(cls, experiment_id: str, _id: str = None, name: str = None):
-        kwargs = {"name": name} if name else {"_id": _id}
-        return ce.APIClient().get_population(experiment_id, **kwargs)
+    @property
+    def client(self):
+        return ce.APIClient()
+
+    @property
+    def path(self):
+        return f"experiments/{self.experiment_id}/populations/{self._id}".rstrip(
+            "/None"
+        )
 
     @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 = self.client.update(self)
+        self.__setstate__(res.__getstate__())  # type: ignore
 
     def delete(self):
-        ce.APIClient().delete_entity(self.experiment_id, "populations", self._id)
+        self.client.delete_entity(self.experiment_id, "populations", self._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,25 +31,37 @@ def population_tester(population):
 
 
 @responses.activate
-def test_should_get_population(ENDPOINT_BASE, population, populations):
+def test_should_get_population(client, ENDPOINT_BASE, population, populations):
     responses.add(
         responses.GET,
         ENDPOINT_BASE + f"/experiments/{EXP_ID}/populations/{population._id}",
         json=populations[0],
     )
-    pop = Population.get(EXP_ID, population._id)
+    pop = client.get_population(EXP_ID, population._id)
+    assert pop.unique_name is None
     population_tester(pop)
 
 
 @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)