regula-documentreader-webclient 8.1.355rc0__py3-none-any.whl → 8.1.357.dev0__py3-none-any.whl

regula/documentreader/webclient/gen/models/face_api_search.py

@@ -4,174 +4,80 @@
     Generated by: https://openapi-generator.tech
 """
 
+from __future__ import annotations
 import pprint
 import re  # noqa: F401
+import json
 
-import six
-
-from regula.documentreader.webclient.gen.configuration import Configuration
-# this line was added to enable pycharm type hinting
-from regula.documentreader.webclient.gen.models import *
-
-
-"""
-A search filter that can be applied if the "match+search" mode is enabled. May include limit, threshold, group_ids. If the group_ids are specified, the search is performed only in these groups. Find more information in the <a href="https://dev.regulaforensics.com/FaceSDK-web-openapi/#tag/search/operation/search" target="_blank">OpenAPI documentation</a>.
-"""
-class FaceApiSearch(object):
-    """NOTE: This class is auto generated by OpenAPI Generator.
-    Ref: https://openapi-generator.tech
-
-    Do not edit the class manually.
-    """
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
 
+class FaceApiSearch(BaseModel):
     """
-    Attributes:
-      openapi_types (dict): The key is attribute name
-                            and the value is attribute type.
-      attribute_map (dict): The key is attribute name
-                            and the value is json key in definition.
-    """
-    openapi_types = {
-        'limit': 'int',
-        'threshold': 'float',
-        'group_ids': 'list[int]'
-    }
-
-    attribute_map = {
-        'limit': 'limit',
-        'threshold': 'threshold',
-        'group_ids': 'group_ids'
-    }
-
-    def __init__(self, limit=None, threshold=None, group_ids=None, local_vars_configuration=None):  # noqa: E501
-        """FaceApiSearch - a model defined in OpenAPI"""  # noqa: E501
-        if local_vars_configuration is None:
-            local_vars_configuration = Configuration()
-        self.local_vars_configuration = local_vars_configuration
-
-        self._limit = None
-        self._threshold = None
-        self._group_ids = None
-        self.discriminator = None
-
-        if limit is not None:
-            self.limit = limit
-        if threshold is not None:
-            self.threshold = threshold
-        if group_ids is not None:
-            self.group_ids = group_ids
-
-    @property
-    def limit(self):
-        """Gets the limit of this FaceApiSearch.  # noqa: E501
-
-        The maximum number of results to be returned.  # noqa: E501
-
-        :return: The limit of this FaceApiSearch.  # noqa: E501
-        :rtype: int
-        """
-        return self._limit
-
-    @limit.setter
-    def limit(self, limit):
-        """Sets the limit of this FaceApiSearch.
-
-        The maximum number of results to be returned.  # noqa: E501
-
-        :param limit: The limit of this FaceApiSearch.  # noqa: E501
-        :type limit: int
+    A search filter that can be applied if the \"match+search\" mode is enabled. May include limit, threshold, group_ids. If the group_ids are specified, the search is performed only in these groups. Find more information in the <a href=\"https://dev.regulaforensics.com/FaceSDK-web-openapi/#tag/search/operation/search\" target=\"_blank\">OpenAPI documentation</a>.
+    """ # noqa: E501
+    limit: Optional[StrictInt] = Field(default=None, description="The maximum number of results to be returned.")
+    threshold: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The similarity threshold.")
+    group_ids: Optional[List[StrictInt]] = Field(default=None, description=" The groups where to conduct the search.")
+    __properties: ClassVar[List[str]] = ["limit", "threshold", "group_ids"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of FaceApiSearch from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
         """
+        excluded_fields: Set[str] = set([
+        ])
 
-        self._limit = limit
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
 
-    @property
-    def threshold(self):
-        """Gets the threshold of this FaceApiSearch.  # noqa: E501
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FaceApiSearch from a dict"""
+        if obj is None:
+            return None
 
-        The similarity threshold.  # noqa: E501
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
 
-        :return: The threshold of this FaceApiSearch.  # noqa: E501
-        :rtype: float
-        """
-        return self._threshold
+        _obj = cls.model_validate({
+            "limit": obj.get("limit"),
+            "threshold": obj.get("threshold"),
+            "group_ids": obj.get("group_ids")
+        })
+        return _obj
 
-    @threshold.setter
-    def threshold(self, threshold):
-        """Sets the threshold of this FaceApiSearch.
-
-        The similarity threshold.  # noqa: E501
-
-        :param threshold: The threshold of this FaceApiSearch.  # noqa: E501
-        :type threshold: float
-        """
-
-        self._threshold = threshold
-
-    @property
-    def group_ids(self):
-        """Gets the group_ids of this FaceApiSearch.  # noqa: E501
-
-         The groups where to conduct the search.  # noqa: E501
-
-        :return: The group_ids of this FaceApiSearch.  # noqa: E501
-        :rtype: list[int]
-        """
-        return self._group_ids
-
-    @group_ids.setter
-    def group_ids(self, group_ids):
-        """Sets the group_ids of this FaceApiSearch.
-
-         The groups where to conduct the search.  # noqa: E501
-
-        :param group_ids: The group_ids of this FaceApiSearch.  # noqa: E501
-        :type group_ids: list[int]
-        """
 
-        self._group_ids = group_ids
-
-    def to_dict(self):
-        """Returns the model properties as a dict"""
-        result = {}
-
-        for attr, _ in six.iteritems(self.openapi_types):
-            value = getattr(self, attr)
-            if isinstance(value, list):
-                result[attr] = list(map(
-                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
-                    value
-                ))
-            elif hasattr(value, "to_dict"):
-                result[attr] = value.to_dict()
-            elif isinstance(value, dict):
-                result[attr] = dict(map(
-                    lambda item: (item[0], item[1].to_dict())
-                    if hasattr(item[1], "to_dict") else item,
-                    value.items()
-                ))
-            else:
-                result[attr] = value
-
-        return result
-
-    def to_str(self):
-        """Returns the string representation of the model"""
-        return pprint.pformat(self.to_dict())
-
-    def __repr__(self):
-        """For `print` and `pprint`"""
-        return self.to_str()
-
-    def __eq__(self, other):
-        """Returns true if both objects are equal"""
-        if not isinstance(other, FaceApiSearch):
-            return False
-
-        return self.to_dict() == other.to_dict()
-
-    def __ne__(self, other):
-        """Returns true if both objects are not equal"""
-        if not isinstance(other, FaceApiSearch):
-            return True
-
-        return self.to_dict() != other.to_dict()

regula/documentreader/webclient/gen/models/face_detection.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    Generated by: https://openapi-generator.tech
+"""
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from regula.documentreader.webclient.gen.models.face_item import FaceItem
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FaceDetection(BaseModel):
+    """
+    FaceDetection
+    """ # noqa: E501
+    count: StrictInt = Field(alias="Count")
+    count_false_detection: StrictInt = Field(alias="CountFalseDetection")
+    res: List[FaceItem] = Field(alias="Res")
+    reserved1: Optional[StrictInt] = Field(default=None, alias="Reserved1")
+    reserved2: Optional[StrictInt] = Field(default=None, alias="Reserved2")
+    __properties: ClassVar[List[str]] = ["Count", "CountFalseDetection", "Res", "Reserved1", "Reserved2"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of FaceDetection from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in res (list)
+        _items = []
+        if self.res:
+            for _item_res in self.res:
+                if _item_res:
+                    _items.append(_item_res.to_dict())
+            _dict['Res'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FaceDetection from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "Count": obj.get("Count"),
+            "CountFalseDetection": obj.get("CountFalseDetection"),
+            "Res": [FaceItem.from_dict(_item) for _item in obj["Res"]] if obj.get("Res") is not None else None,
+            "Reserved1": obj.get("Reserved1"),
+            "Reserved2": obj.get("Reserved2")
+        })
+        return _obj
+
+

regula/documentreader/webclient/gen/models/face_detection_item.py

@@ -0,0 +1,83 @@
+# coding: utf-8
+
+"""
+    Generated by: https://openapi-generator.tech
+"""
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from regula.documentreader.webclient.gen.models.face_detection import FaceDetection
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FaceDetectionItem(BaseModel):
+    """
+    FaceDetectionItem
+    """ # noqa: E501
+    face_detection: Optional[FaceDetection] = Field(default=None, alias="FaceDetection")
+    __properties: ClassVar[List[str]] = ["FaceDetection"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of FaceDetectionItem from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of face_detection
+        if self.face_detection:
+            _dict['FaceDetection'] = self.face_detection.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FaceDetectionItem from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "FaceDetection": FaceDetection.from_dict(obj["FaceDetection"]) if obj.get("FaceDetection") is not None else None
+        })
+        return _obj
+
+

regula/documentreader/webclient/gen/models/face_detection_result.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+    Generated by: https://openapi-generator.tech
+"""
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from regula.documentreader.webclient.gen.models.face_detection import FaceDetection
+from regula.documentreader.webclient.gen.models.result import Result
+from regula.documentreader.webclient.gen.models.result_item import ResultItem
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FaceDetectionResult(ResultItem):
+    """
+    FaceDetectionResult
+    """ # noqa: E501
+    face_detection: Optional[FaceDetection] = Field(default=None, alias="FaceDetection")
+    __properties: ClassVar[List[str]] = ["buf_length", "light", "list_idx", "page_idx", "result_type", "FaceDetection"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of FaceDetectionResult from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of face_detection
+        if self.face_detection:
+            _dict['FaceDetection'] = self.face_detection.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FaceDetectionResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "buf_length": obj.get("buf_length"),
+            "light": obj.get("light"),
+            "list_idx": obj.get("list_idx"),
+            "page_idx": obj.get("page_idx"),
+            "result_type": obj.get("result_type"),
+            "FaceDetection": FaceDetection.from_dict(obj["FaceDetection"]) if obj.get("FaceDetection") is not None else None
+        })
+        return _obj
+
+

regula/documentreader/webclient/gen/models/face_item.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+    Generated by: https://openapi-generator.tech
+"""
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from regula.documentreader.webclient.gen.models.light import Light
+from regula.documentreader.webclient.gen.models.point import Point
+from regula.documentreader.webclient.gen.models.rectangle_coordinates import RectangleCoordinates
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FaceItem(BaseModel):
+    """
+    FaceItem
+    """ # noqa: E501
+    coincidence_to_photo_area: StrictInt = Field(alias="CoincidenceToPhotoArea")
+    face_rect: RectangleCoordinates = Field(alias="FaceRect")
+    field_rect: RectangleCoordinates = Field(alias="FieldRect")
+    graph_field_number: StrictInt = Field(alias="GraphFieldNumber")
+    landmarks: List[Point] = Field(alias="Landmarks")
+    light_type: Light = Field(alias="LightType")
+    orientation: StrictInt = Field(alias="Orientation")
+    probability: StrictInt = Field(alias="Probability")
+    __properties: ClassVar[List[str]] = ["CoincidenceToPhotoArea", "FaceRect", "FieldRect", "GraphFieldNumber", "Landmarks", "LightType", "Orientation", "Probability"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of FaceItem from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of face_rect
+        if self.face_rect:
+            _dict['FaceRect'] = self.face_rect.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of field_rect
+        if self.field_rect:
+            _dict['FieldRect'] = self.field_rect.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in landmarks (list)
+        _items = []
+        if self.landmarks:
+            for _item_landmarks in self.landmarks:
+                if _item_landmarks:
+                    _items.append(_item_landmarks.to_dict())
+            _dict['Landmarks'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FaceItem from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "CoincidenceToPhotoArea": obj.get("CoincidenceToPhotoArea"),
+            "FaceRect": RectangleCoordinates.from_dict(obj["FaceRect"]) if obj.get("FaceRect") is not None else None,
+            "FieldRect": RectangleCoordinates.from_dict(obj["FieldRect"]) if obj.get("FieldRect") is not None else None,
+            "GraphFieldNumber": obj.get("GraphFieldNumber"),
+            "Landmarks": [Point.from_dict(_item) for _item in obj["Landmarks"]] if obj.get("Landmarks") is not None else None,
+            "LightType": obj.get("LightType"),
+            "Orientation": obj.get("Orientation"),
+            "Probability": obj.get("Probability")
+        })
+        return _obj
+
+