regula-facesdk-webclient 7.2.388.dev0__py3-none-any.whl → 8.1.433.dev0__py3-none-any.whl

regula/facesdk/webclient/gen/models/quality_request.py

@@ -0,0 +1,93 @@
+# 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 typing_extensions import Annotated
+from regula.facesdk.webclient.gen.models.quality_config import QualityConfig
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class QualityRequest(BaseModel):
+    """
+    If set, the face image quality check is performed according to the given list of [characteristics](https://docs.regulaforensics.com/develop/face-sdk/web-service/development/usage/face-detection/face-image-quality-check/) in `quality.config`.
+    """ # noqa: E501
+    background_match_color: SkipValidation[Optional[List[int]]] = Field(alias="backgroundMatchColor", default=None, description="The RGB value of a color for filling background behind a person's silhouette and for aligning the image.")
+    config: SkipValidation[Optional[List[QualityConfig]]] = Field(alias="config", default=None, description="The list of quality check characteristics.")
+    __properties: ClassVar[List[str]] = ["backgroundMatchColor", "config"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+        arbitrary_types_allowed=True,
+        use_enum_values=True
+    )
+
+
+    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 QualityRequest 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 config (list)
+        _items = []
+        if self.config:
+            for _item_config in self.config:
+                if _item_config:
+                    _items.append(_item_config.to_dict())
+            _dict['config'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QualityRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "backgroundMatchColor": obj.get("backgroundMatchColor"),
+            "config": [QualityConfig.from_dict(_item) for _item in obj.get("config", []) if QualityConfig.from_dict(_item) is not None]
+        })
+        return _obj
+
+

regula/facesdk/webclient/gen/models/recognize_image.py

@@ -0,0 +1,100 @@
+# 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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class RecognizeImage(BaseModel):
+    """
+    RecognizeImage
+    """ # noqa: E501
+    id: SkipValidation[Optional[str]] = Field(alias="id", default=None, description="Response image ID. The list is sorted by decreasing ID value.")
+    content: SkipValidation[Optional[str]] = Field(alias="content", default=None, description="Base64-encoded image. Returned only if `withImages` is set to true in the request.")
+    content_type: SkipValidation[Optional[str]] = Field(alias="contentType", default=None, description="Original media type of the returned image.")
+    created_at: SkipValidation[Optional[str]] = Field(alias="createdAt", default=None, description="Returned image creation date.")
+    updated_at: SkipValidation[Optional[str]] = Field(alias="updatedAt", default=None, description="Returned image update date.")
+    path: SkipValidation[Optional[str]] = Field(alias="path", default=None, description="Returned image path.")
+    url: SkipValidation[Optional[str]] = Field(alias="url", default=None, description="Returned image URL.")
+    metadata: SkipValidation[Optional[Dict[str, object]]] = Field(alias="metadata", default=None, description="A free-form object containing person's extended attributes.")
+    similarity: SkipValidation[Optional[float]] = Field(alias="similarity", default=None, description="Similarity score.")
+    distance: SkipValidation[Optional[float]] = Field(alias="distance", default=None, description="Similarity distance score: the lower the distance, the higher the face's similarity.")
+    __properties: ClassVar[List[str]] = ["id", "content", "contentType", "createdAt", "updatedAt", "path", "url", "metadata", "similarity", "distance"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+        arbitrary_types_allowed=True,
+        use_enum_values=True
+    )
+
+
+    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 RecognizeImage 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RecognizeImage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "content": obj.get("content"),
+            "contentType": obj.get("contentType"),
+            "createdAt": obj.get("createdAt"),
+            "updatedAt": obj.get("updatedAt"),
+            "path": obj.get("path"),
+            "url": obj.get("url"),
+            "metadata": obj.get("metadata"),
+            "similarity": obj.get("similarity"),
+            "distance": obj.get("distance")
+        })
+        return _obj
+
+

regula/facesdk/webclient/gen/models/recognize_image_data.py

@@ -0,0 +1,84 @@
+# 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, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class RecognizeImageData(BaseModel):
+    """
+    RecognizeImageData
+    """ # noqa: E501
+    similarity: SkipValidation[Optional[float]] = Field(alias="similarity", default=None, description="Similarity score.")
+    distance: SkipValidation[Optional[float]] = Field(alias="distance", default=None, description="Similarity distance score: the lower the distance, the higher the face's similarity.")
+    __properties: ClassVar[List[str]] = ["similarity", "distance"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+        arbitrary_types_allowed=True,
+        use_enum_values=True
+    )
+
+
+    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 RecognizeImageData 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RecognizeImageData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "similarity": obj.get("similarity"),
+            "distance": obj.get("distance")
+        })
+        return _obj
+
+

regula/facesdk/webclient/gen/models/resize_options.py

@@ -0,0 +1,86 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class ResizeOptions(BaseModel):
+    """
+    Set to resize the original image.
+    """ # noqa: E501
+    width: SkipValidation[Optional[int]] = Field(alias="width", default=None, description="Resized image width, px.")
+    height: SkipValidation[Optional[int]] = Field(alias="height", default=None, description="Resized image height, px.")
+    quality: SkipValidation[Optional[int]] = Field(alias="quality", default=None, description="Resized image quality, percent.")
+    __properties: ClassVar[List[str]] = ["width", "height", "quality"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+        arbitrary_types_allowed=True,
+        use_enum_values=True
+    )
+
+
+    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 ResizeOptions 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ResizeOptions from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "width": obj.get("width"),
+            "height": obj.get("height"),
+            "quality": obj.get("quality") if obj.get("quality") is not None else 100
+        })
+        return _obj
+
+

regula/facesdk/webclient/gen/models/search_bad_params.py

@@ -0,0 +1,86 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class SearchBadParams(BaseModel):
+    """
+    SearchBadParams
+    """ # noqa: E501
+    msg: SkipValidation[Optional[str]] = Field(alias="msg", default=None)
+    status_code: SkipValidation[Optional[int]] = Field(alias="statusCode", default=None)
+    type: SkipValidation[Optional[str]] = Field(alias="type", default=None)
+    __properties: ClassVar[List[str]] = ["msg", "statusCode", "type"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+        arbitrary_types_allowed=True,
+        use_enum_values=True
+    )
+
+
+    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 SearchBadParams 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SearchBadParams from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "msg": obj.get("msg") if obj.get("msg") is not None else 'Descriptor already calculated',
+            "statusCode": obj.get("statusCode") if obj.get("statusCode") is not None else 400,
+            "type": obj.get("type") if obj.get("type") is not None else 'BadParamsException'
+        })
+        return _obj
+
+

regula/facesdk/webclient/gen/models/search_detection.py

@@ -0,0 +1,102 @@
+# 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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class SearchDetection(BaseModel):
+    """
+    The array of identified persons.
+    """ # noqa: E501
+    code: SkipValidation[Optional[int]] = Field(alias="code", default=None, description="Internal.")
+    crop: SkipValidation[Optional[str]] = Field(alias="crop", default=None, description="Base64 of the aligned and cropped portrait.")
+    detector_type: SkipValidation[Optional[int]] = Field(alias="detectorType", default=None, description="Internal.")
+    hash: SkipValidation[Optional[str]] = Field(alias="hash", default=None, description="Internal.")
+    idx: SkipValidation[Optional[int]] = Field(alias="idx", default=None, description="Internal.")
+    image: SkipValidation[Optional[str]] = Field(alias="image", default=None, description="Internal.")
+    landmarks: SkipValidation[Optional[List[List[int]]]] = Field(alias="landmarks", default=None, description="Absolute coordinates (x,y) of five points of each detected face: left eye, right eye, nose, left point of lips, right point of lips.")
+    landmarks_type: SkipValidation[Optional[int]] = Field(alias="landmarksType", default=None, description="Internal.")
+    msg: SkipValidation[Optional[str]] = Field(alias="msg", default=None, description="Internal.")
+    roi: SkipValidation[Optional[List[float]]] = Field(alias="roi", default=None, description="The rectangular area of a detected face that is represented by a set of four elements: the X and Y coordinates of the top-left point, and the width and height dimensions of the rectangle.")
+    version_sdk: SkipValidation[Optional[str]] = Field(alias="versionSDK", default=None)
+    __properties: ClassVar[List[str]] = ["code", "crop", "detectorType", "hash", "idx", "image", "landmarks", "landmarksType", "msg", "roi", "versionSDK"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+        arbitrary_types_allowed=True,
+        use_enum_values=True
+    )
+
+
+    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 SearchDetection 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SearchDetection from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "code": obj.get("code"),
+            "crop": obj.get("crop"),
+            "detectorType": obj.get("detectorType"),
+            "hash": obj.get("hash"),
+            "idx": obj.get("idx"),
+            "image": obj.get("image"),
+            "landmarks": obj.get("landmarks"),
+            "landmarksType": obj.get("landmarksType"),
+            "msg": obj.get("msg"),
+            "roi": obj.get("roi"),
+            "versionSDK": obj.get("versionSDK")
+        })
+        return _obj
+
+

regula/facesdk/webclient/gen/models/search_parameters.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
+from typing import Any, ClassVar, Dict, List, Optional
+from uuid import UUID
+from regula.facesdk.webclient.gen.models.filter_search_request import FilterSearchRequest
+from regula.facesdk.webclient.gen.models.search_parameters_create_person import SearchParametersCreatePerson
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class SearchParameters(BaseModel):
+    """
+    Request search data.
+    """ # noqa: E501
+    create_person: SkipValidation[Optional[SearchParametersCreatePerson]] = Field(alias="createPerson", default=None)
+    group_ids: SkipValidation[Optional[List[str]]] = Field(alias="groupIds", default=None, description="IDs of the groups in which the search is performed.")
+    filter: SkipValidation[Optional[FilterSearchRequest]] = Field(alias="filter", default=None)
+    __properties: ClassVar[List[str]] = ["createPerson", "groupIds", "filter"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+        arbitrary_types_allowed=True,
+        use_enum_values=True
+    )
+
+
+    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 SearchParameters 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 create_person
+        if self.create_person:
+            _dict['createPerson'] = self.create_person.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of filter
+        if self.filter:
+            _dict['filter'] = self.filter.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SearchParameters from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "createPerson": SearchParametersCreatePerson.from_dict(obj["createPerson"]) if obj.get("createPerson") is not None else None,
+            "groupIds": obj.get("groupIds"),
+            "filter": FilterSearchRequest.from_dict(obj["filter"]) if obj.get("filter") is not None else None
+        })
+        return _obj
+
+