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

regula/facesdk/webclient/gen/models/person_with_images_data.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 BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from regula.facesdk.webclient.gen.models.recognize_image import RecognizeImage
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class PersonWithImagesData(BaseModel):
+    """
+    PersonWithImagesData
+    """ # noqa: E501
+    images: SkipValidation[Optional[List[RecognizeImage]]] = Field(alias="images", default=None, description="Detected Persons.")
+    __properties: ClassVar[List[str]] = ["images"]
+
+    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 PersonWithImagesData 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 images (list)
+        _items = []
+        if self.images:
+            for _item_images in self.images:
+                if _item_images:
+                    _items.append(_item_images.to_dict())
+            _dict['images'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PersonWithImagesData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "images": [RecognizeImage.from_dict(_item) for _item in obj.get("images", []) if RecognizeImage.from_dict(_item) is not None]
+        })
+        return _obj
+
+

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

@@ -0,0 +1,94 @@
+# 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.facesdk.webclient.gen.models.person import Person
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class PersonsPage(BaseModel):
+    """
+    PersonsPage
+    """ # noqa: E501
+    items: SkipValidation[Optional[List[Person]]] = Field(alias="items", default=None)
+    page: SkipValidation[Optional[int]] = Field(alias="page", default=None, description="Current page number.")
+    total_pages: SkipValidation[Optional[int]] = Field(alias="totalPages", default=None, description="Total number of pages.")
+    __properties: ClassVar[List[str]] = ["items", "page", "totalPages"]
+
+    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 PersonsPage 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 items (list)
+        _items = []
+        if self.items:
+            for _item_items in self.items:
+                if _item_items:
+                    _items.append(_item_items.to_dict())
+            _dict['items'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PersonsPage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "items": [Person.from_dict(_item) for _item in obj.get("items", []) if Person.from_dict(_item) is not None],
+            "page": obj.get("page"),
+            "totalPages": obj.get("totalPages")
+        })
+        return _obj
+
+

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

@@ -0,0 +1,103 @@
+# 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, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from regula.facesdk.webclient.gen.models.face_quality_scenarios import FaceQualityScenarios
+from regula.facesdk.webclient.gen.models.output_image_params import OutputImageParams
+from regula.facesdk.webclient.gen.models.process_param_attributes import ProcessParamAttributes
+from regula.facesdk.webclient.gen.models.quality_request import QualityRequest
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class ProcessParam(BaseModel):
+    """
+    The processing parameters.
+    """ # noqa: E501
+    scenario: SkipValidation[Optional[FaceQualityScenarios]] = Field(alias="scenario", default=None)
+    only_central_face: SkipValidation[Optional[bool]] = Field(alias="onlyCentralFace", default=None, description="Whether to process only the central face in the image. If set to `false`, all the faces are processed.")
+    output_image_params: SkipValidation[Optional[OutputImageParams]] = Field(alias="outputImageParams", default=None)
+    quality: SkipValidation[Optional[QualityRequest]] = Field(alias="quality", default=None)
+    attributes: SkipValidation[Optional[ProcessParamAttributes]] = Field(alias="attributes", default=None)
+    __properties: ClassVar[List[str]] = ["scenario", "onlyCentralFace", "outputImageParams", "quality", "attributes"]
+
+    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 ProcessParam 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 output_image_params
+        if self.output_image_params:
+            _dict['outputImageParams'] = self.output_image_params.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of quality
+        if self.quality:
+            _dict['quality'] = self.quality.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of attributes
+        if self.attributes:
+            _dict['attributes'] = self.attributes.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProcessParam from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "scenario": obj.get("scenario"),
+            "onlyCentralFace": obj.get("onlyCentralFace"),
+            "outputImageParams": OutputImageParams.from_dict(obj["outputImageParams"]) if obj.get("outputImageParams") is not None else None,
+            "quality": QualityRequest.from_dict(obj["quality"]) if obj.get("quality") is not None else None,
+            "attributes": ProcessParamAttributes.from_dict(obj["attributes"]) if obj.get("attributes") is not None else None
+        })
+        return _obj
+
+

regula/facesdk/webclient/gen/models/process_param_attributes.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 BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from regula.facesdk.webclient.gen.models.attribute_config import AttributeConfig
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class ProcessParamAttributes(BaseModel):
+    """
+    If set, the selected attributes, such as age or emotions, are evaluated. To check all the available attributes, you can set the `AttributesAll` scenario in `processParam.scenario`.
+    """ # noqa: E501
+    config: SkipValidation[Optional[List[AttributeConfig]]] = Field(alias="config", default=None, description="The list of attributes for evaluation.")
+    __properties: ClassVar[List[str]] = ["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 ProcessParamAttributes 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 ProcessParamAttributes from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "config": [AttributeConfig.from_dict(_item) for _item in obj.get("config", []) if AttributeConfig.from_dict(_item) is not None]
+        })
+        return _obj
+
+

regula/facesdk/webclient/gen/models/quality_config.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, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from regula.facesdk.webclient.gen.models.face_quality_config_name import FaceQualityConfigName
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class QualityConfig(BaseModel):
+    """
+    The configuration that defines the list of returned quality check characteristics.
+    """ # noqa: E501
+    name: SkipValidation[Optional[FaceQualityConfigName]] = Field(alias="name", default=None)
+    range: SkipValidation[Optional[List[float]]] = Field(alias="range", default=None, description="The range of applicable values for this characteristic. If the returned in the response value fits this range, the characteristic is identified as compliant with the requirements. For recommended ranges, see [Face Image Quality Assessment](https://docs.regulaforensics.com/develop/face-sdk/web-service/development/usage/face-detection/face-image-quality-check/).")
+    __properties: ClassVar[List[str]] = ["name", "range"]
+
+    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 QualityConfig 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 QualityConfig from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "range": obj.get("range")
+        })
+        return _obj
+
+

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

@@ -0,0 +1,94 @@
+# 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_extensions import Annotated
+from regula.facesdk.webclient.gen.models.face_image_quality_groups import FaceImageQualityGroups
+from regula.facesdk.webclient.gen.models.face_image_quality_status import FaceImageQualityStatus
+from regula.facesdk.webclient.gen.models.face_quality_config_name import FaceQualityConfigName
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class QualityDetail(BaseModel):
+    """
+    QualityDetail
+    """ # noqa: E501
+    group_id: SkipValidation[Optional[FaceImageQualityGroups]] = Field(alias="groupId", default=None)
+    name: SkipValidation[Optional[FaceQualityConfigName]] = Field(alias="name", default=None)
+    range: SkipValidation[Optional[List[float]]] = Field(alias="range", default=None, description="The range of set values for this characteristic, see the [Recommended range column](https://docs.regulaforensics.com/develop/face-sdk/web-service/development/usage/face-detection/face-image-quality-check/).")
+    status: SkipValidation[Optional[FaceImageQualityStatus]] = Field(alias="status", default=None)
+    value: SkipValidation[Optional[float]] = Field(alias="value", default=None, description="The result value for the characteristic, returned in set units.")
+    __properties: ClassVar[List[str]] = ["groupId", "name", "range", "status", "value"]
+
+    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 QualityDetail 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 QualityDetail from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "groupId": obj.get("groupId"),
+            "name": obj.get("name"),
+            "range": obj.get("range"),
+            "status": obj.get("status"),
+            "value": obj.get("value")
+        })
+        return _obj
+
+

regula/facesdk/webclient/gen/models/quality_details_groups.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 BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from regula.facesdk.webclient.gen.models.face_image_quality_groups import FaceImageQualityGroups
+from regula.facesdk.webclient.gen.models.face_image_quality_groups_strings import FaceImageQualityGroupsStrings
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class QualityDetailsGroups(BaseModel):
+    """
+    QualityDetailsGroups
+    """ # noqa: E501
+    group_id: SkipValidation[Optional[FaceImageQualityGroups]] = Field(alias="groupId", default=None)
+    name: SkipValidation[Optional[FaceImageQualityGroupsStrings]] = Field(alias="name", default=None)
+    total_count: SkipValidation[Optional[int]] = Field(alias="totalCount", default=None, description="The total number of characteristics in the group.")
+    compliant_count: SkipValidation[Optional[int]] = Field(alias="compliantCount", default=None, description="The number of compliant characteristics in the group.")
+    __properties: ClassVar[List[str]] = ["groupId", "name", "totalCount", "compliantCount"]
+
+    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 QualityDetailsGroups 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 QualityDetailsGroups from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "groupId": obj.get("groupId"),
+            "name": obj.get("name"),
+            "totalCount": obj.get("totalCount"),
+            "compliantCount": obj.get("compliantCount")
+        })
+        return _obj
+
+