[F] Fix jsonable test differs on multiple platform

Author: kunkunlin1221

pyface/face_service.py

@@ -115,7 +115,7 @@ def _fill_results_to_faces_list(
                     dep_result = dep_results[i]
                     face.tddfa = TDDFA(
                         param=dep_result["param"],
-                        lmk68pt=dep_result["lmk3d68pt"],
+                        lmk3d68pt=dep_result["lmk3d68pt"],
                         depth_img=dep_result["depth_img"],
                         yaw=dep_result["pose_degree"][0],
                         roll=dep_result["pose_degree"][1],

pyface/object.py

@@ -29,19 +29,41 @@ class Eye(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
     is_open: Optional[bool] = field(default=None)
     score: Optional[float] = field(default=None)
 
+    @classmethod
+    def from_json(cls, data) -> "Eye":
+        return cls(
+            is_open=data.get("is_open"),
+            score=data.get("score"),
+        )
+
 
 @dataclass()
 class Mouth(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
     is_open: Optional[bool] = field(default=None)
     score: Optional[float] = field(default=None)
 
+    @classmethod
+    def from_json(cls, data) -> "Mouth":
+        return cls(
+            is_open=data.get("is_open"),
+            score=data.get("score"),
+        )
+
 
 @dataclass()
 class WhetherOrNot(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
     is_true: Optional[bool] = field(default=None)
     value: Optional[float] = field(default=None)
     threshold: Optional[float] = field(default=None)
 
+    @classmethod
+    def from_json(cls, data) -> "WhetherOrNot":
+        return cls(
+            is_true=data.get("is_true"),
+            value=data.get("value"),
+            threshold=data.get("threshold"),
+        )
+
 
 @dataclass()
 class Liveness(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
@@ -50,29 +72,64 @@ class Liveness(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
     threshold: Optional[Union[float, np.number]] = field(default=None)
     fake_type: Optional[FakeType] = field(default=None)
 
+    @classmethod
+    def from_json(cls, data):
+        return cls(
+            is_true=data.get("is_true"),
+            value=data.get("value"),
+            threshold=data.get("threshold"),
+            fake_type=FakeType(data["fake_type"]) if data.get("fake_type") is not None else None,
+        )
+
 
 @dataclass()
 class TDDFA(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
     param: Optional[np.ndarray] = field(default=None)
-    lmk68pt: Optional[np.ndarray] = field(default=None)
+    lmk3d68pt: Optional[np.ndarray] = field(default=None)
     depth_img: Optional[np.ndarray] = field(default=None)
     yaw: Optional[float] = field(default=None)
     roll: Optional[float] = field(default=None)
     pitch: Optional[float] = field(default=None)
 
+    @classmethod
+    def from_json(cls, data) -> "TDDFA":
+        return cls(
+            param=cb.b64str_to_npy(data["param"]) if data.get("param") is not None else None,
+            lmk3d68pt=np.array(data["lmk3d68pt"]) if data.get("lmk3d68pt") is not None else None,
+            depth_img=cb.b64str_to_img(data["depth_img"]) if data.get("depth_img") is not None else None,
+            yaw=data.get("yaw"),
+            roll=data.get("roll"),
+            pitch=data.get("pitch"),
+        )
+
 
 @dataclass()
 class Encode(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
     vector: Optional[np.ndarray] = field(default=None)
     version: Optional[str] = field(default=None)
 
+    @classmethod
+    def from_json(cls, data) -> "Encode":
+        return cls(
+            vector=cb.b64str_to_npy(data["vector"]) if data.get("vector") is not None else None,
+            version=data.get("version"),
+        )
+
 
 @dataclass()
 class Who(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
     name: Optional[str] = field(default="?")
     confidence: Optional[float] = field(default=None)
     recognized_level: Optional[int] = field(default=None)
 
+    @classmethod
+    def from_json(cls, data) -> "Who":
+        return cls(
+            name=data.get("name", "?"),
+            confidence=data.get("confidence"),
+            recognized_level=data.get("recognized_level"),
+        )
+
 
 @dataclass()
 class Attribute(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
@@ -84,6 +141,18 @@ class Attribute(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
     right_eye: Optional[Eye] = field(default=None)
     mouth: Optional[Mouth] = field(default=None)
 
+    @classmethod
+    def from_json(cls, data) -> "Attribute":
+        return cls(
+            age=data.get("age"),
+            gender=data.get("gender"),
+            race=data.get("race"),
+            pose=FacePose.obj_to_enum(data["pose"]) if data.get("pose") is not None else None,
+            left_eye=Eye.from_json(data["left_eye"]) if data.get("left_eye") is not None else None,
+            right_eye=Eye.from_json(data["right_eye"]) if data.get("right_eye") is not None else None,
+            mouth=Mouth.from_json(data["mouth"]) if data.get("mouth") is not None else None,
+        )
+
 
 @dataclass()
 class Face(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
@@ -107,9 +176,24 @@ class Face(cb.DataclassToJsonMixin, cb.DataclassCopyMixin):
     # pose: Optional[FacePose] = field(default=None)
     # blur: Optional[WhetherOrNot] = field(default=None)
     # occlusion: Optional[Occlusion] = field(default=None)
-    # lmk68pt: Optional[cb.Keypoints] = field(default=None)
+    # lmk3d68pt: Optional[cb.Keypoints] = field(default=None)
     # analysis_infos: Optional[dict] = field(default=None)
 
+    @classmethod
+    def from_json(cls, data: dict) -> "Face":
+        return cls(
+            box=cb.Box(data["box"]),
+            score=data["score"],
+            lmk5pt=cb.Keypoints(np.array(data["lmk5pt"])) if data.get("lmk5pt") is not None else None,
+            norm_img=cb.b64str_to_img(data["norm_img"]) if data.get("norm_img") is not None else None,
+            tddfa=TDDFA.from_json(data["tddfa"]) if data.get("tddfa") is not None else None,
+            encoding=Encode.from_json(data["encoding"]) if data.get("encoding") is not None else None,
+            who=Who.from_json(data["who"]) if data.get("who") is not None else None,
+            lmk106pt=cb.Keypoints(np.array(data["lmk106pt"])) if data.get("lmk106pt") is not None else None,
+            liveness=Liveness.from_json(data["liveness"]) if data.get("liveness") is not None else None,
+            attribute=Attribute.from_json(data["attribute"]) if data.get("attribute") is not None else None,
+        )
+
 
 ATTR_NAMES = [f.name for f in fields(Face)]
 
@@ -260,6 +344,13 @@ def be_jsonable(self):
             "faces": [x.be_jsonable() for x in self.faces],
         }
 
+    @classmethod
+    def from_json(cls, data: dict) -> "Faces":
+        return cls(
+            raw_image=cb.b64str_to_img(data["raw_image"]) if data.get("raw_image") is not None else None,
+            faces=[Face.from_json(x) for x in data.get("faces", [])],
+        )
+
 
 # def _remove_none_in_jsonized_face(jsonized_face: dict) -> dict:
 #     outs = {}

tests/resources/answer/EmmaWatson1_jsonable.json

@@ -1,9 +1,7 @@
 import capybara as cb
-import numpy as np
 import pytest
 
 import pyface as pf
-from tests.tools import assert_allclose
 
 RESOURCE_DIR = cb.get_curdir(__file__) / "resources"
 ANSWER_DIR = RESOURCE_DIR / "answer"
@@ -12,28 +10,20 @@
 TEST_DATA = [
     {
         "img_fpath": RESOURCE_DIR / "EmmaWatson1.jpg",
-        "expected": ANSWER_DIR / "EmmaWatson1_jsonable.json",
+        "json_fpath": ANSWER_DIR / "EmmaWatson1_jsonable.json",
     },
     {
         "img_fpath": RESOURCE_DIR / "JohnnyDepp1.jpg",
-        "expected": ANSWER_DIR / "JohnnyDepp1_jsonable.json",
+        "json_fpath": ANSWER_DIR / "JohnnyDepp1_jsonable.json",
     },
 ]
 
 
 @pytest.mark.parametrize("data", TEST_DATA)
 def test_jsonable(data):
-    face_service = pf.FaceService(
-        enable_depth=True,
-        enable_landmark=True,
-        enable_recognition=True,
-        enable_gender=True,
-        face_bank=RESOURCE_DIR / "face_bank",
-    )
-    img = cb.imread(data["img_fpath"])
-    faces = face_service([img], do_1n=True)[0]
+    expected = cb.load_json(data["json_fpath"])
+    faces = pf.Faces.from_json(expected)
     output = faces.be_jsonable()
-    expected = cb.load_json(data["expected"])
     assert output == expected