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

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

@@ -1,87 +0,0 @@
-# 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, StrictStr
-from typing import Any, ClassVar, Dict, List
-from regula.documentreader.webclient.gen.models.rfid_access_control_procedure_type import RfidAccessControlProcedureType
-from regula.documentreader.webclient.gen.models.rfid_password_type import RfidPasswordType
-from typing import Optional, Set
-from typing_extensions import Self
-
-class RfidAccessKey(BaseModel):
-    """
-    Structure is used to describe the contents of secure data access key within the context of the communication session with electronic document
-    """ # noqa: E501
-    access_key: StrictStr = Field(description="Key contents", alias="AccessKey")
-    key_type: RfidPasswordType = Field(alias="KeyType")
-    access_type: RfidAccessControlProcedureType = Field(alias="AccessType")
-    check_full_key_matching: StrictBool = Field(description="Logical sign of the need for a full comparison of AccessKey contents with the contents of DG1 (MRZ) data group", alias="CheckFullKeyMatching")
-    __properties: ClassVar[List[str]] = ["AccessKey", "KeyType", "AccessType", "CheckFullKeyMatching"]
-
-    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 RfidAccessKey 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 RfidAccessKey from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "AccessKey": obj.get("AccessKey"),
-            "KeyType": obj.get("KeyType"),
-            "AccessType": obj.get("AccessType"),
-            "CheckFullKeyMatching": obj.get("CheckFullKeyMatching")
-        })
-        return _obj
-
-

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

@@ -1,101 +0,0 @@
-# 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, StrictStr
-from typing import Any, ClassVar, Dict, List
-from regula.documentreader.webclient.gen.models.rfid_application_type import RfidApplicationType
-from regula.documentreader.webclient.gen.models.rfid_data_file import RfidDataFile
-from regula.documentreader.webclient.gen.models.rfid_error_codes import RFIDErrorCodes
-from typing import Optional, Set
-from typing_extensions import Self
-
-class RfidApplication(BaseModel):
-    """
-    Structure is used to describe the contents of a single LDS application and their analysis within the context of the communication session with electronic document
-    """ # noqa: E501
-    type: RfidApplicationType = Field(alias="Type")
-    status: RFIDErrorCodes = Field(alias="Status")
-    application_id: StrictStr = Field(description="Application identifier", alias="ApplicationID")
-    version: StrictStr = Field(description="Version of the application", alias="Version")
-    unicode_version: StrictStr = Field(description="Unicode version for application", alias="UnicodeVersion")
-    data_hash_algorithm: StrictStr = Field(description="Algorithm for calculating hash values for files for the procedure of PA", alias="DataHashAlgorithm")
-    files: List[RfidDataFile] = Field(description="List of containers to store information about the read files of the application", alias="Files")
-    __properties: ClassVar[List[str]] = ["Type", "Status", "ApplicationID", "Version", "UnicodeVersion", "DataHashAlgorithm", "Files"]
-
-    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 RfidApplication 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 files (list)
-        _items = []
-        if self.files:
-            for _item_files in self.files:
-                if _item_files:
-                    _items.append(_item_files.to_dict())
-            _dict['Files'] = _items
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RfidApplication from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "Type": obj.get("Type"),
-            "Status": obj.get("Status"),
-            "ApplicationID": obj.get("ApplicationID"),
-            "Version": obj.get("Version"),
-            "UnicodeVersion": obj.get("UnicodeVersion"),
-            "DataHashAlgorithm": obj.get("DataHashAlgorithm"),
-            "Files": [RfidDataFile.from_dict(_item) for _item in obj["Files"]] if obj.get("Files") is not None else None
-        })
-        return _obj
-
-

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

@@ -1,37 +0,0 @@
-# coding: utf-8
-
-"""
-    Generated by: https://openapi-generator.tech
-"""
-
-from __future__ import annotations
-import json
-from enum import Enum
-from typing_extensions import Self
-
-
-class RfidApplicationType(int, Enum):
-    """
-    Enumeration contains a set of constants that define the type of application within the context of the communication session with electronic document
-    """
-
-    """
-    allowed enum values
-    """
-    UNSPECIFIED = 0
-    E_PASSPORT = 1
-    E_ID = 2
-    E_SIGN = 3
-    E_DL = 4
-    LDS2_TravelRecords = 5
-    LDS2_VisaRecords = 6
-    LDS2_AddBiometrics = 7
-    eDTC_PC = 8
-    ROOT_FILES = 0
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Self:
-        """Create an instance of RfidApplicationType from a JSON string"""
-        return cls(json.loads(json_str))
-
-

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

@@ -1,81 +0,0 @@
-# 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, StrictStr
-from typing import Any, ClassVar, Dict, List
-from typing import Optional, Set
-from typing_extensions import Self
-
-class RfidAttributeData(BaseModel):
-    """
-    Structure contains the data of one attribute of the digital signature object.
-    """ # noqa: E501
-    type: StrictStr = Field(description="Contents of the identifier in the format S1 (S2), where S1 – attribute name, S2 – identifier (OID string)", alias="Type")
-    data: StrictStr = Field(description="Attribute binary data. Base64 encoded.", alias="Data")
-    __properties: ClassVar[List[str]] = ["Type", "Data"]
-
-    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 RfidAttributeData 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 RfidAttributeData from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "Type": obj.get("Type"),
-            "Data": obj.get("Data")
-        })
-        return _obj
-
-

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

@@ -1,85 +0,0 @@
-# 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, StrictStr
-from typing import Any, ClassVar, Dict, List
-from regula.documentreader.webclient.gen.models.trf_ft_string import TrfFtString
-from typing import Optional, Set
-from typing_extensions import Self
-
-class RfidAttributeName(BaseModel):
-    """
-    Structure contains information that serves as the distinguished name (identifier) of an object.
-    """ # noqa: E501
-    type: StrictStr = Field(description="Attribute identifier (OID ASCII string); contents of the identifier in the format S1 (S2), where S1 – attribute name, S2 – identifier (OID string)", alias="Type")
-    value: TrfFtString = Field(alias="Value")
-    __properties: ClassVar[List[str]] = ["Type", "Value"]
-
-    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 RfidAttributeName 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 value
-        if self.value:
-            _dict['Value'] = self.value.to_dict()
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RfidAttributeName from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "Type": obj.get("Type"),
-            "Value": TrfFtString.from_dict(obj["Value"]) if obj.get("Value") is not None else None
-        })
-        return _obj
-
-

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

@@ -1,31 +0,0 @@
-# coding: utf-8
-
-"""
-    Generated by: https://openapi-generator.tech
-"""
-
-from __future__ import annotations
-import json
-from enum import Enum
-from typing_extensions import Self
-
-
-class RfidAuthenticationProcedureType(int, Enum):
-    """
-    Enumeration contains a set of constants that define the type of performed procedure of document authentication within the current session
-    """
-
-    """
-    allowed enum values
-    """
-    UNDEFINED = 0
-    STANDARD = 1
-    ADVANCED = 2
-    GENERAL = 3
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Self:
-        """Create an instance of RfidAuthenticationProcedureType from a JSON string"""
-        return cls(json.loads(json_str))
-
-

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

@@ -1,32 +0,0 @@
-# coding: utf-8
-
-"""
-    Generated by: https://openapi-generator.tech
-"""
-
-from __future__ import annotations
-import json
-from enum import Enum
-from typing_extensions import Self
-
-
-class RfidBaudRate(int, Enum):
-    """
-    Enumeration contains a set of constants specifying the rate of data exchange between the reader and the RFID-chip
-    """
-
-    """
-    allowed enum values
-    """
-    UNKNOWN = 0
-    RFBR_106 = 1
-    RFBR_212 = 2
-    RFBR_424 = 4
-    RFBR_848 = 8
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Self:
-        """Create an instance of RfidBaudRate from a JSON string"""
-        return cls(json.loads(json_str))
-
-

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

@@ -1,123 +0,0 @@
-# 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, StrictFloat, StrictInt, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional, Union
-from regula.documentreader.webclient.gen.models.rfid_a_chip import RfidAChip
-from regula.documentreader.webclient.gen.models.rfid_baud_rate import RfidBaudRate
-from regula.documentreader.webclient.gen.models.rfid_type import RfidType
-from typing import Optional, Set
-from typing_extensions import Self
-
-class RfidCardPropertiesExt(BaseModel):
-    """
-    Structure is used to store extended information about the characteristics of the RFID-chip located in the scope of the reader
-    """ # noqa: E501
-    rfid_type: RfidType = Field(alias="RFID_Type")
-    baudrate1: StrictStr = Field(description="Numeric Baudrate1 value in hexadecimal format (e.g. 0x0000000F)", alias="Baudrate1")
-    baudrate2: StrictStr = Field(description="Numeric Baudrate2 value in hexadecimal format", alias="Baudrate2")
-    support_4: StrictBool = Field(description="Boolean Support_4 value", alias="Support_4")
-    chip_type_a: RfidAChip = Field(alias="ChipType_A")
-    support_mifare: StrictBool = Field(description="Sign of support for ISO/IEC 14443-3 data exchange protocol", alias="Support_Mifare")
-    mifare_memory: Union[StrictFloat, StrictInt] = Field(description="Amount of operational memory MIFARE® of the chip, kilobytes", alias="MifareMemory")
-    uid: StrictStr = Field(description="UID contents in text format. Each byte is represented by its hexadecimal value. The individual bytes are separated by spaces (e.g. F9 4F 41 60)", alias="UID")
-    atq_a: Optional[Any] = Field(description="Reply of the «A» type chip to «REQA» command of ISO/IEC 14443-3 protocol (Answer To Request, Type A – ATQA) – for the internal use by the main control library", alias="ATQ_A")
-    sak: Optional[Any] = Field(description="Response of type-A RFID-chip to SELECT command of ISO/IEC 14443-3 protocol (Select Acknowledge, SAK).", alias="SAK")
-    atq_b: Optional[Any] = Field(description="ATQ_B contents in text format. Each byte is represented by its hexadecimal value. The individual bytes are separated by spaces (e.g. 50 F9 4F 41 60 00 00 00 00 77 81 81)", alias="ATQ_B")
-    bit_rate_s: RfidBaudRate = Field(alias="BitRateS")
-    bit_rate_r: RfidBaudRate = Field(alias="BitRateR")
-    atr: StrictStr = Field(description="ATR-string of RFID-chip", alias="ATR")
-    __properties: ClassVar[List[str]] = ["RFID_Type", "Baudrate1", "Baudrate2", "Support_4", "ChipType_A", "Support_Mifare", "MifareMemory", "UID", "ATQ_A", "SAK", "ATQ_B", "BitRateS", "BitRateR", "ATR"]
-
-    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 RfidCardPropertiesExt 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,
-        )
-        # set to None if atq_a (nullable) is None
-        # and model_fields_set contains the field
-        if self.atq_a is None and "atq_a" in self.model_fields_set:
-            _dict['ATQ_A'] = None
-
-        # set to None if sak (nullable) is None
-        # and model_fields_set contains the field
-        if self.sak is None and "sak" in self.model_fields_set:
-            _dict['SAK'] = None
-
-        # set to None if atq_b (nullable) is None
-        # and model_fields_set contains the field
-        if self.atq_b is None and "atq_b" in self.model_fields_set:
-            _dict['ATQ_B'] = None
-
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RfidCardPropertiesExt from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "RFID_Type": obj.get("RFID_Type"),
-            "Baudrate1": obj.get("Baudrate1"),
-            "Baudrate2": obj.get("Baudrate2"),
-            "Support_4": obj.get("Support_4"),
-            "ChipType_A": obj.get("ChipType_A"),
-            "Support_Mifare": obj.get("Support_Mifare"),
-            "MifareMemory": obj.get("MifareMemory"),
-            "UID": obj.get("UID"),
-            "ATQ_A": obj.get("ATQ_A"),
-            "SAK": obj.get("SAK"),
-            "ATQ_B": obj.get("ATQ_B"),
-            "BitRateS": obj.get("BitRateS"),
-            "BitRateR": obj.get("BitRateR"),
-            "ATR": obj.get("ATR")
-        })
-        return _obj
-
-