regula-documentreader-webclient 8.1.302.dev0__py3-none-any.whl → 8.1.340rc0__py3-none-any.whl

regula/documentreader/webclient/ext/__init__.py

@@ -6,6 +6,7 @@ from regula.documentreader.webclient.ext.models.authenticity.image_ident import
 from regula.documentreader.webclient.ext.models.authenticity.ocr_security_text import OCRSecurityTextChecks
 from regula.documentreader.webclient.ext.models.authenticity.security_feature import SecurityFeatureChecks
 from regula.documentreader.webclient.ext.models.images import Images, ImagesField
+from regula.documentreader.webclient.ext.models.raw_result_item import RawResultItem
 from regula.documentreader.webclient.ext.models.recognition_request import RecognitionRequest, RecognitionImage
 from regula.documentreader.webclient.ext.models.recognition_response import RecognitionResponse
 from regula.documentreader.webclient.ext.models.text import Text

regula/documentreader/webclient/ext/api/document_reader_api.py

@@ -25,8 +25,8 @@ class DocumentReaderApi(HealthcheckApi, ProcessApi):
     def __enter__(self):
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
-        pass
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.api_client.close()
 
     def set_configuration(self, configuration) -> None:
         self.api_client.configuration = configuration

regula/documentreader/webclient/ext/models/__init__.py

@@ -5,6 +5,8 @@ from regula.documentreader.webclient.ext.models.authenticity.image_ident import
 from regula.documentreader.webclient.ext.models.authenticity.ocr_security_text import OCRSecurityTextChecks
 from regula.documentreader.webclient.ext.models.authenticity.security_feature import SecurityFeatureChecks
 from regula.documentreader.webclient.ext.models.images import Images, ImagesField
+from regula.documentreader.webclient.ext.models.raw_authenticity_result_item import RawAuthenticityCheckResultItem
+from regula.documentreader.webclient.ext.models.raw_result_item import RawResultItem
 from regula.documentreader.webclient.ext.models.recognition_request import RecognitionImage
 from regula.documentreader.webclient.ext.models.recognition_request import RecognitionRequest
 from regula.documentreader.webclient.ext.models.recognition_response import RecognitionResponse

regula/documentreader/webclient/ext/models/authenticity/authenticity_check_list.py

@@ -1,7 +1,6 @@
 from typing import Optional
 
-from regula.documentreader.webclient.gen.models import AuthenticityCheckList as GenAuthenticityCheckList
-from regula.documentreader.webclient.gen.models import AuthenticityResultType, AuthenticityCheckResult
+from regula.documentreader.webclient import gen, AuthenticityResultType
 from regula.documentreader.webclient.ext.models.authenticity.fiber import FiberChecks
 from regula.documentreader.webclient.ext.models.authenticity.ident import IdentChecks
 from regula.documentreader.webclient.ext.models.authenticity.image_ident import ImageIdentChecks
@@ -9,85 +8,71 @@ from regula.documentreader.webclient.ext.models.authenticity.ocr_security_text i
 from regula.documentreader.webclient.ext.models.authenticity.security_feature import SecurityFeatureChecks
 
 
-class AuthenticityCheckList(GenAuthenticityCheckList):
+class AuthenticityCheckList(gen.AuthenticityCheckList):
 
     @property
     def uv_luminescence_checks(self) -> Optional[SecurityFeatureChecks]:
-        result = self.__result_by_type(AuthenticityResultType.UV_LUMINESCENCE)
-        return SecurityFeatureChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.UV_LUMINESCENCE, SecurityFeatureChecks)
 
     @property
     def ir_b900_checks(self) -> Optional[SecurityFeatureChecks]:
-        result = self.__result_by_type(AuthenticityResultType.IR_B900)
-        return SecurityFeatureChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.IR_B900, SecurityFeatureChecks)
 
     @property
     def image_pattern_checks(self) -> Optional[IdentChecks]:
-        result = self.__result_by_type(AuthenticityResultType.IMAGE_PATTERN)
-        return IdentChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.IMAGE_PATTERN, IdentChecks)
 
     @property
     def axial_protection_checks(self) -> Optional[SecurityFeatureChecks]:
-        result = self.__result_by_type(AuthenticityResultType.AXIAL_PROTECTION)
-        return SecurityFeatureChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.AXIAL_PROTECTION, SecurityFeatureChecks)
 
     @property
     def uv_fiber_checks(self) -> Optional[FiberChecks]:
-        result = self.__result_by_type(AuthenticityResultType.UV_FIBERS)
-        return FiberChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.UV_FIBERS, FiberChecks)
 
     @property
     def ir_visibility_checks(self) -> Optional[IdentChecks]:
-        result = self.__result_by_type(AuthenticityResultType.IR_VISIBILITY)
-        return IdentChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.IR_VISIBILITY, IdentChecks)
 
     @property
     def ocr_security_text_checks(self) -> Optional[OCRSecurityTextChecks]:
-        result = self.__result_by_type(AuthenticityResultType.OCR_SECURITY_TEXT)
-        return OCRSecurityTextChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.OCR_SECURITY_TEXT, OCRSecurityTextChecks)
 
     @property
     def ipi_checks(self) -> Optional[ImageIdentChecks]:
-        result = self.__result_by_type(AuthenticityResultType.IPI)
-        return ImageIdentChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.IPI, ImageIdentChecks)
 
     @property
     def embed_image_checks(self) -> Optional[SecurityFeatureChecks]:
-        result = self.__result_by_type(AuthenticityResultType.PHOTO_EMBED_TYPE)
-        return SecurityFeatureChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.PHOTO_EMBED_TYPE, SecurityFeatureChecks)
 
     @property
     def holograms_checks(self) -> Optional[SecurityFeatureChecks]:
-        result = self.__result_by_type(AuthenticityResultType.HOLOGRAMS)
-        return SecurityFeatureChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.HOLOGRAMS, SecurityFeatureChecks)
 
     @property
     def photo_area_checks(self) -> Optional[SecurityFeatureChecks]:
-        result = self.__result_by_type(AuthenticityResultType.PHOTO_AREA)
-        return SecurityFeatureChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.PHOTO_AREA, SecurityFeatureChecks)
 
     @property
     def portrait_comparison_checks(self) -> Optional[IdentChecks]:
-        result = self.__result_by_type(AuthenticityResultType.PORTRAIT_COMPARISON)
-        return IdentChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.PORTRAIT_COMPARISON, IdentChecks)
 
     @property
     def barcode_format_checks(self) -> Optional[SecurityFeatureChecks]:
-        result = self.__result_by_type(AuthenticityResultType.BARCODE_FORMAT_CHECK)
-        return SecurityFeatureChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.BARCODE_FORMAT_CHECK, SecurityFeatureChecks)
 
     @property
     def kinegram_checks(self) -> Optional[IdentChecks]:
-        result = self.__result_by_type(AuthenticityResultType.KINEGRAM)
-        return IdentChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.KINEGRAM, IdentChecks)
 
     @property
     def letter_screen_checks(self) -> Optional[IdentChecks]:
-        result = self.__result_by_type(AuthenticityResultType.LETTER_SCREEN)
-        return IdentChecks.from_dict(result.to_dict())
+        return self.__result_by_type(AuthenticityResultType.LETTER_SCREEN, IdentChecks)
 
-    def __result_by_type(self, authenticity_type: int) -> Optional[AuthenticityCheckResult]:
+    def __result_by_type(self, authenticity_type: int, parent_class: type) -> Optional[gen.AuthenticityCheckResult]:
         for result in self.list:
             if result.type == authenticity_type:
+                result.__class__ = parent_class
                 return result
         return None

regula/documentreader/webclient/ext/models/authenticity/fiber.py

@@ -1,11 +1,11 @@
 from typing import List
 
-from regula.documentreader.webclient.gen.models import FiberResult, AuthenticityCheckResult
+from regula.documentreader.webclient import gen
 
 
-class FiberChecks(AuthenticityCheckResult):
+class FiberChecks(gen.AuthenticityCheckResult):
 
-    @property
-    def list(self) -> List[FiberResult]:
+    @gen.AuthenticityCheckResult.list.getter
+    def list(self) -> List[gen.FiberResult]:
         # noinspection PyTypeChecker
         return super().list

regula/documentreader/webclient/ext/models/authenticity/ident.py

@@ -1,15 +1,14 @@
-from typing import List
+from typing import List, Optional
 
-from regula.documentreader.webclient.gen.models import AuthenticityCheckResult, IdentResult
+from regula.documentreader.webclient import gen
 
 
-class IdentChecks(AuthenticityCheckResult):
-
-    @property
-    def list(self) -> List[IdentResult]:
+class IdentChecks(gen.AuthenticityCheckResult):
+    @gen.AuthenticityCheckResult.list.getter
+    def list(self) -> List[gen.IdentResult]:
         # noinspection PyTypeChecker
-        return self.list
+        return super().list
 
     # element_type is SecurityFeatureType
-    def checks_by_element(self, element_type: int) -> List[IdentResult]:
+    def checks_by_element(self, element_type: int) -> List[gen.IdentResult]:
         return [check for check in self.list if check.element_type == element_type]

regula/documentreader/webclient/ext/models/authenticity/image_ident.py

@@ -1,11 +1,10 @@
 from typing import List
 
-from regula.documentreader.webclient.gen.models import AuthenticityCheckResult, PhotoIdentResult
+from regula.documentreader.webclient import gen
 
 
-class ImageIdentChecks(AuthenticityCheckResult):
-
-    @property
-    def list(self) -> List[PhotoIdentResult]:
+class ImageIdentChecks(gen.AuthenticityCheckResult):
+    @gen.AuthenticityCheckResult.list.getter
+    def list(self) -> List[gen.PhotoIdentResult]:
         # noinspection PyTypeChecker
-        return self.list
+        return super().list

regula/documentreader/webclient/ext/models/authenticity/ocr_security_text.py

@@ -1,11 +1,11 @@
 from typing import List
 
-from regula.documentreader.webclient.gen.models import AuthenticityCheckResult, OCRSecurityTextResult
+from regula.documentreader.webclient import gen
 
 
-class OCRSecurityTextChecks(AuthenticityCheckResult):
+class OCRSecurityTextChecks(gen.AuthenticityCheckResult):
 
-    @property
-    def list(self) -> List[OCRSecurityTextResult]:
+    @gen.AuthenticityCheckResult.list.getter
+    def list(self) -> List[gen.OCRSecurityTextResult]:
         # noinspection PyTypeChecker
-        return self.list
+        return super().list

regula/documentreader/webclient/ext/models/authenticity/security_feature.py

@@ -1,15 +1,13 @@
 from typing import List, Optional
 
-from regula.documentreader.webclient.gen.models import AuthenticityCheckResult, SecurityFeatureResult
+from regula.documentreader.webclient import gen
 
 
-class SecurityFeatureChecks(AuthenticityCheckResult):
-
-    @property
-    def list(self) -> List[SecurityFeatureResult]:
-        # noinspection PyTypeChecker
-        return self.list
+class SecurityFeatureChecks(gen.AuthenticityCheckResult):
+    @gen.AuthenticityCheckResult.list.getter
+    def list(self) -> List[gen.SecurityFeatureResult]:
+        return super().list
 
     # element_type is SecurityFeatureType
-    def checks_by_element(self, element_type: int) -> List[SecurityFeatureResult]:
+    def checks_by_element(self, element_type: int) -> List[gen.SecurityFeatureResult]:
         return [check for check in self.list if check.element_type == element_type]

regula/documentreader/webclient/ext/models/images.py

@@ -1,10 +1,10 @@
 import base64
 from typing import Optional, List
 
-from regula.documentreader.webclient.gen.models import Images as GenImages, ImagesField as GenImagesField, Source
+from regula.documentreader.webclient.gen.models import Images as GenImages, ImagesField as GetImagesField, Source
 
 
-class ImagesField(GenImagesField):
+class ImagesField(GetImagesField):
 
     def get_value(self, source: str = None, original=False) -> Optional[bytes]:
 
@@ -33,8 +33,8 @@ class Images(GenImages):
     def get_field(self, field_type: int) -> Optional[ImagesField]:
         for field in self.field_list:
             if field.field_type == field_type:
-                return ImagesField.from_dict(field.to_dict())
+                return field
         return None
 
     def get_fields(self, field_type: int) -> List[ImagesField]:
-        return [ImagesField.from_dict(field.to_dict()) for field in self.field_list if field.field_type == field_type]
+        return [field for field in self.field_list if field.field_type == field_type]

regula/documentreader/webclient/ext/models/raw_authenticity_result_item.py

@@ -0,0 +1,27 @@
+from copy import copy
+
+from regula.documentreader.webclient.gen.models.authenticity_check_result_item import AuthenticityCheckResultItem
+
+
+class RawAuthenticityCheckResultItem(AuthenticityCheckResultItem):
+    openapi_types = copy(AuthenticityCheckResultItem.openapi_types)
+    openapi_types["raw"] = "dict"
+
+    attribute_map = copy(AuthenticityCheckResultItem.attribute_map)
+    attribute_map["raw"] = "raw"
+
+    def __init__(self, type=0, element_result=None, element_diagnose=None, raw=None, percent_value=None, local_vars_configuration=None):
+        super().__init__(type, element_result, element_diagnose, percent_value, local_vars_configuration)
+        self.__raw = raw
+
+    @property
+    def raw(self):
+        return self.__raw
+
+    def to_dict(self):
+        result = super(RawAuthenticityCheckResultItem, self).to_dict()
+        result["raw"] = self.__raw
+        return result
+
+    def get_real_child_model(self, data):
+        return None

regula/documentreader/webclient/ext/models/raw_result_item.py

@@ -0,0 +1,26 @@
+from copy import copy
+
+from regula.documentreader.webclient.gen.models.result_item import ResultItem
+
+
+class RawResultItem(ResultItem):
+    openapi_types = copy(ResultItem.openapi_types)
+    openapi_types["raw"] = "dict"
+
+    attribute_map = copy(ResultItem.attribute_map)
+    attribute_map["raw"] = "raw"
+
+    def __init__(self, buf_length=None, light=None, list_idx=None, page_idx=None, result_type=None, raw=None,
+                 local_vars_configuration=None):
+        super().__init__(buf_length, light, list_idx, page_idx, result_type, local_vars_configuration)
+        self.__raw = raw
+
+    @property
+    def raw(self):
+        return self.__raw
+
+    def to_dict(self):
+        return self.__raw
+
+    def get_real_child_model(self, data):
+        return None

regula/documentreader/webclient/ext/models/recognition_request.py

@@ -1,3 +1,4 @@
+import json
 import base64
 from typing import List, Union
 
@@ -14,11 +15,7 @@ class RecognitionImage(ProcessRequestImage):
     def __init__(self, image: Union[bytes, Base64String], light_index=None, page_index=None):
         if isinstance(image, bytes):
             image = base64.b64encode(image).decode("utf-8")
-        super().__init__(
-            ImageData = ImageData(image = image),
-            light = light_index,
-            page_index = page_index,
-        )
+        super().__init__(ImageData(image), light_index, page_index)
 
 
 class LicenseRequest(LicenseResult):
@@ -32,12 +29,12 @@ class LicenseRequest(LicenseResult):
         _buf_length = len(_license)
         _result_type = Result.LICENSE
         super().__init__(
-            License = __license,
-            buf_length = _buf_length,
-            light = _light,
-            list_idx = _list_idx,
-            page_idx = _page_idx,
-            result_type = _result_type
+            __license,
+            _buf_length,
+            _light,
+            _list_idx,
+            _page_idx,
+            _result_type
         )
 
 
@@ -53,12 +50,12 @@ class EncryptedRCLRequest(EncryptedRCLResult):
         _buf_length = len(_encrypted_rcl)
         _result_type = Result.ENCRYPTED_RCL
         super().__init__(
-            EncryptedRCL = __encrypted_rcl,
-            buf_length = _buf_length,
-            light = _light,
-            list_idx = _list_idx,
-            page_idx = _page_idx,
-            result_type = _result_type
+            __encrypted_rcl,
+            _buf_length,
+            _light,
+            _list_idx,
+            _page_idx,
+            _result_type
         )
 
 
@@ -78,15 +75,19 @@ class RecognitionRequest(ProcessRequest):
                 else:
                     input_images.append(image)
             super().__init__(
-                processParam=process_params,
-                List=input_images,
-                systemInfo=system_info,
+                process_param=process_params,
+                list=input_images,
+                system_info=system_info,
                 tag=tag
             )
         if container_list:
             super().__init__(
-                processParam=process_params,
-                ContainerList=container_list,
-                systemInfo=system_info,
+                process_param=process_params,
+                container_list=container_list,
+                system_info=system_info,
                 tag=tag
             )
+
+    @property
+    def json(self) -> str:
+        return json.dumps(self.to_dict())

regula/documentreader/webclient/ext/models/recognition_response.py

@@ -1,4 +1,5 @@
 import base64
+import json
 import zlib
 from typing import Optional, List
 from regula.documentreader.webclient import ImageQualityCheckList, OneCandidate
@@ -20,9 +21,13 @@ class RecognitionResponse:
     def text(self) -> Optional[Text]:
         result = self.result_by_type(Result.TEXT)
         if result:
-            return Text.from_dict(result.text.to_dict())
+            return result.text
         return None
 
+    @property
+    def json(self) -> str:
+        return json.dumps(self.low_lvl_response.to_dict())
+
     @property
     def status(self) -> Optional[Status]:
         result = self.result_by_type(Result.STATUS)
@@ -34,13 +39,13 @@ class RecognitionResponse:
     def images(self) -> Optional[Images]:
         result = self.result_by_type(Result.IMAGES)
         if result:
-            return Images.from_dict(result.images.to_dict())
+            return result.images
         return None
 
     def authenticity(self, page_idx=0) -> Optional[AuthenticityCheckList]:
         result = self.pageable_result_by_type(Result.AUTHENTICITY, page_idx)
         if result:
-            return AuthenticityCheckList.from_dict(result.authenticity_check_list.to_dict())
+            return result.authenticity_check_list
         return None
 
     def image_quality_checks(self, page_idx=0) -> Optional[ImageQualityCheckList]:
@@ -80,6 +85,3 @@ class RecognitionResponse:
         if not isinstance(other, RecognitionResponse):
             return False
         return self.low_lvl_response == other.low_lvl_response
-
-    def to_json(self) -> str:
-        return self.low_lvl_response.to_json()

regula/documentreader/webclient/ext/models/text.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, List
 
 from regula.documentreader.webclient.ext.models.text_field import TextField
 from regula.documentreader.webclient.gen.models import LCID, Text as GenText
@@ -11,12 +11,12 @@ class Text(GenText):
         for field in self.field_list:
             if field.field_type == field_type:
                 if lcid is not None and field.lcid == lcid:
-                    return TextField.from_dict(field.to_dict())
+                    return field
                 elif lcid is None and field.lcid == LCID.LATIN:
-                    return TextField.from_dict(field.to_dict())
+                    return field
                 elif lcid is None and result is None:
                     result = field
-        return TextField.from_dict(result.to_dict())
+        return result
 
     def get_field_value(self, field_type: int, lcid: int = None) -> Optional[str]:
         field = self.get_field(field_type, lcid)
@@ -27,13 +27,18 @@ class Text(GenText):
         for field in self.field_list:
             if field.field_name == field_name:
                 if lcid is not None and field.lcid == lcid:
-                    return TextField.from_dict(field.to_dict())
+                    return field
                 elif lcid is None and field.lcid == LCID.LATIN:
-                    return TextField.from_dict(field.to_dict())
+                    return field
                 elif lcid is None and result is None:
                     result = field
-        return TextField.from_dict(result.to_dict())
+        return result
 
     def get_field_value_by_name(self, field_name: str, lcid: int = None) -> Optional[str]:
         field = self.get_field_by_name(field_name, lcid)
         return field.value if field else None
+
+    @GenText.field_list.getter
+    def field_list(self) -> List[TextField]:
+        # fix type hinting
+        return super().field_list