✨ add list field typed accessors

mindee/parsing/v2/field/__init__.py

@@ -1,6 +1,7 @@
 from mindee.parsing.v2.field.base_field import BaseField
 from mindee.parsing.v2.field.field_confidence import FieldConfidence
 from mindee.parsing.v2.field.field_location import FieldLocation
+from mindee.parsing.v2.field.inference_fields import InferenceFields
 from mindee.parsing.v2.field.list_field import ListField
 from mindee.parsing.v2.field.object_field import ObjectField
 from mindee.parsing.v2.field.simple_field import SimpleField
@@ -12,4 +13,5 @@
     "ListField",
     "ObjectField",
     "SimpleField",
+    "InferenceFields",
 ]

mindee/parsing/v2/field/inference_result_fields.py → mindee/parsing/v2/field/inference_fields.py

@@ -8,7 +8,7 @@
 )
 
 
-class InferenceResultFields(Dict[str, DynamicField]):
+class InferenceFields(Dict[str, DynamicField]):
     """Inference fields dict."""
 
     def __init__(self, raw_response: StringDict, indent_level: int = 0) -> None:

mindee/parsing/v2/field/list_field.py

@@ -7,6 +7,8 @@
     FieldType,
     get_field_type,
 )
+from mindee.parsing.v2.field.object_field import ObjectField
+from mindee.parsing.v2.field.simple_field import SimpleField
 
 
 class ListField(BaseField):
@@ -22,6 +24,28 @@ def __init__(self, raw_response: StringDict, indent_level: int = 0):
         for item in raw_response["items"]:
             self.items.append(get_field_type(item))
 
+    @property
+    def simple_items(self) -> List[SimpleField]:
+        """List of items as ``SimpleField``."""
+        simple_items = []
+        for item in self.items:
+            if isinstance(item, SimpleField):
+                simple_items.append(item)
+            else:
+                raise ValueError("List item is not a simple field.")
+        return simple_items
+
+    @property
+    def object_items(self) -> List[ObjectField]:
+        """List of items as ``ObjectField``."""
+        object_items = []
+        for item in self.items:
+            if isinstance(item, ObjectField):
+                object_items.append(item)
+            else:
+                raise ValueError("List item is not an object field.")
+        return object_items
+
     def __str__(self) -> str:
         out_str = ""
         indent = " " * self._indent_level

mindee/parsing/v2/field/object_field.py

@@ -1,20 +1,20 @@
 from mindee.parsing.common.string_dict import StringDict
 from mindee.parsing.v2.field.base_field import BaseField
 from mindee.parsing.v2.field.dynamic_field import FieldType
-from mindee.parsing.v2.field.inference_result_fields import InferenceResultFields
+from mindee.parsing.v2.field.inference_fields import InferenceFields
 
 
 class ObjectField(BaseField):
     """Object field containing multiple fields."""
 
-    fields: InferenceResultFields
+    fields: InferenceFields
     """Fields contained in the object."""
 
     def __init__(self, raw_response: StringDict, indent_level: int = 0):
         super().__init__(FieldType.OBJECT, raw_response, indent_level)
         inner_fields = raw_response.get("fields", raw_response)
 
-        self.fields = InferenceResultFields(inner_fields, self._indent_level + 1)
+        self.fields = InferenceFields(inner_fields, self._indent_level + 1)
 
     def single_str(self) -> str:
         """String representation of a single object field."""

mindee/parsing/v2/field/simple_field.py

@@ -13,7 +13,7 @@ class SimpleField(BaseField):
     def __init__(self, raw_response: StringDict, indent_level: int = 0):
         super().__init__(FieldType.SIMPLE, raw_response, indent_level)
         value = raw_response.get("value", None)
-        if isinstance(value, int) and not isinstance(raw_response.get("value"), bool):
+        if isinstance(value, int) and not isinstance(value, bool):
             self.value = float(value)
         else:
             self.value = value

mindee/parsing/v2/inference_result.py

@@ -1,20 +1,20 @@
 from typing import Optional
 
 from mindee.parsing.common.string_dict import StringDict
-from mindee.parsing.v2.field.inference_result_fields import InferenceResultFields
+from mindee.parsing.v2.field.inference_fields import InferenceFields
 from mindee.parsing.v2.raw_text import RawText
 
 
 class InferenceResult:
     """Inference result info."""
 
-    fields: InferenceResultFields
+    fields: InferenceFields
     """Fields contained in the inference."""
     raw_text: Optional[RawText] = None
     """Potential options retrieved alongside the inference."""
 
     def __init__(self, raw_response: StringDict) -> None:
-        self.fields = InferenceResultFields(raw_response["fields"])
+        self.fields = InferenceFields(raw_response["fields"])
         if raw_response.get("raw_text"):
             self.raw_text = RawText(raw_response["raw_text"])
 

tests/v2/test_inference_response.py

@@ -6,6 +6,7 @@
 
 from mindee import InferenceResponse
 from mindee.parsing.v2.field import FieldConfidence, ListField, ObjectField, SimpleField
+from mindee.parsing.v2.field.inference_fields import InferenceFields
 from mindee.parsing.v2.inference import Inference
 from mindee.parsing.v2.inference_file import InferenceFile
 from mindee.parsing.v2.inference_model import InferenceModel
@@ -116,6 +117,14 @@ def test_standard_field_types():
     assert field_simple_string.confidence == FieldConfidence.CERTAIN
     assert str(field_simple_string) == "field_simple_string-value"
 
+    field_simple_int = inference_result.inference.result.fields["field_simple_int"]
+    assert isinstance(field_simple_int, SimpleField)
+    assert isinstance(field_simple_int.value, float)
+
+    field_simple_float = inference_result.inference.result.fields["field_simple_float"]
+    assert isinstance(field_simple_float, SimpleField)
+    assert isinstance(field_simple_float.value, float)
+
     field_simple_bool = inference_result.inference.result.fields["field_simple_bool"]
     assert isinstance(field_simple_bool, SimpleField)
     assert field_simple_bool.value is True
@@ -126,18 +135,55 @@ def test_standard_field_types():
     assert field_simple_null.value is None
     assert str(field_simple_null) == ""
 
-    assert isinstance(
-        inference_result.inference.result.fields["field_object"], ObjectField
-    )
-    assert isinstance(
-        inference_result.inference.result.fields["field_simple_list"], ListField
-    )
-    assert isinstance(
-        inference_result.inference.result.fields["field_object_list"], ListField
-    )
     assert rst_sample == str(inference_result)
 
 
+@pytest.mark.v2
+def test_standard_field_object():
+    json_sample, _ = _get_inference_samples("standard_field_types")
+    inference_result = InferenceResponse(json_sample)
+
+    object_field = inference_result.inference.result.fields["field_object"]
+    assert isinstance(object_field, ObjectField)
+
+    sub_fields = object_field.fields
+    assert isinstance(sub_fields, InferenceFields)
+    assert len(sub_fields) == 2
+
+    subfield_1 = sub_fields["subfield_1"]
+    assert isinstance(subfield_1, SimpleField)
+
+    for field_name, sub_field in sub_fields.items():
+        assert field_name.startswith("subfield_")
+        assert isinstance(sub_field, SimpleField)
+
+
+@pytest.mark.v2
+def test_standard_field_object_list():
+    json_sample, _ = _get_inference_samples("standard_field_types")
+    inference_result = InferenceResponse(json_sample)
+    assert isinstance(inference_result.inference, Inference)
+
+    field_object_list = inference_result.inference.result.fields["field_object_list"]
+    assert isinstance(field_object_list, ListField)
+    assert len(field_object_list.items) == 2
+    for object_field in field_object_list.object_items:
+        assert isinstance(object_field, ObjectField)
+
+
+@pytest.mark.v2
+def test_standard_field_simple_list():
+    json_sample, _ = _get_inference_samples("standard_field_types")
+    inference_result = InferenceResponse(json_sample)
+    assert isinstance(inference_result.inference, Inference)
+
+    field_simple_list = inference_result.inference.result.fields["field_simple_list"]
+    assert isinstance(field_simple_list, ListField)
+    assert len(field_simple_list.simple_items) == 2
+    for object_field in field_simple_list.simple_items:
+        assert isinstance(object_field, SimpleField)
+
+
 @pytest.mark.v2
 def test_raw_texts():
     json_sample, rst_sample = _get_inference_samples("raw_texts")
@@ -159,18 +205,20 @@ def test_full_inference_response():
 
     assert isinstance(inference_result.inference, Inference)
     assert inference_result.inference.id == "12345678-1234-1234-1234-123456789abc"
-    assert isinstance(inference_result.inference.result.fields.date, SimpleField)
+    assert isinstance(inference_result.inference.result.fields["date"], SimpleField)
     assert inference_result.inference.result.fields["date"].value == "2019-11-02"
-    assert isinstance(inference_result.inference.result.fields.taxes, ListField)
+    assert isinstance(inference_result.inference.result.fields["taxes"], ListField)
     assert isinstance(
         inference_result.inference.result.fields["taxes"].items[0], ObjectField
     )
     assert (
-        inference_result.inference.result.fields["customer_address"].fields.city.value
+        inference_result.inference.result.fields["customer_address"]
+        .fields["city"]
+        .value
         == "New York"
     )
     assert (
-        inference_result.inference.result.fields.taxes.items[0].fields["base"].value
+        inference_result.inference.result.fields["taxes"].items[0].fields["base"].value
         == 31.5
     )