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

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

@@ -1,135 +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, StrictFloat, StrictInt
-from typing import Any, ClassVar, Dict, List, Union
-from regula.documentreader.webclient.gen.models.error_coordinates import ErrorCoordinates
-from regula.documentreader.webclient.gen.models.field_item import FieldItem
-from regula.documentreader.webclient.gen.models.rectangle_coordinates import RectangleCoordinates
-from regula.documentreader.webclient.gen.models.symbol_estimation_item import SymbolEstimationItem
-from typing import Optional, Set
-from typing_extensions import Self
-
-class StringItem(BaseModel):
-    """
-    StringItem
-    """ # noqa: E501
-    alignment_symbols_in_string: StrictInt = Field(alias="ALIGNMENT_SYMBOLS_IN_STRING")
-    check_sums: StrictInt = Field(alias="CHECK_SUMS")
-    error_position: ErrorCoordinates = Field(alias="ErrorPOSITION")
-    field_count: StrictInt = Field(alias="FieldCount")
-    fields: List[FieldItem] = Field(alias="Fields")
-    strings_distance: StrictInt = Field(alias="STRINGS_DISTANCE")
-    strings_interval: StrictInt = Field(alias="STRINGS_INTERVAL")
-    string_filling: StrictInt = Field(alias="STRING_FILLING")
-    string_position: StrictInt = Field(alias="STRING_POSITION")
-    symbols_param: StrictInt = Field(alias="SYMBOLS_PARAM")
-    size_error_alignment: Union[StrictFloat, StrictInt] = Field(alias="SizeError_ALIGNMENT")
-    size_error_distance: Union[StrictFloat, StrictInt] = Field(alias="SizeError_DISTANCE")
-    size_error_interval: Union[StrictFloat, StrictInt] = Field(alias="SizeError_INTERVAL")
-    string_angle: Union[StrictFloat, StrictInt] = Field(alias="StringAngle")
-    string_borders: RectangleCoordinates = Field(alias="StringBorders")
-    symbols_count: StrictInt = Field(alias="SymbolsCount")
-    symbols_estimations: List[SymbolEstimationItem] = Field(alias="SymbolsEstimations")
-    __properties: ClassVar[List[str]] = ["ALIGNMENT_SYMBOLS_IN_STRING", "CHECK_SUMS", "ErrorPOSITION", "FieldCount", "Fields", "STRINGS_DISTANCE", "STRINGS_INTERVAL", "STRING_FILLING", "STRING_POSITION", "SYMBOLS_PARAM", "SizeError_ALIGNMENT", "SizeError_DISTANCE", "SizeError_INTERVAL", "StringAngle", "StringBorders", "SymbolsCount", "SymbolsEstimations"]
-
-    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 StringItem 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 error_position
-        if self.error_position:
-            _dict['ErrorPOSITION'] = self.error_position.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
-        _items = []
-        if self.fields:
-            for _item_fields in self.fields:
-                if _item_fields:
-                    _items.append(_item_fields.to_dict())
-            _dict['Fields'] = _items
-        # override the default output from pydantic by calling `to_dict()` of string_borders
-        if self.string_borders:
-            _dict['StringBorders'] = self.string_borders.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in symbols_estimations (list)
-        _items = []
-        if self.symbols_estimations:
-            for _item_symbols_estimations in self.symbols_estimations:
-                if _item_symbols_estimations:
-                    _items.append(_item_symbols_estimations.to_dict())
-            _dict['SymbolsEstimations'] = _items
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of StringItem from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "ALIGNMENT_SYMBOLS_IN_STRING": obj.get("ALIGNMENT_SYMBOLS_IN_STRING"),
-            "CHECK_SUMS": obj.get("CHECK_SUMS"),
-            "ErrorPOSITION": ErrorCoordinates.from_dict(obj["ErrorPOSITION"]) if obj.get("ErrorPOSITION") is not None else None,
-            "FieldCount": obj.get("FieldCount"),
-            "Fields": [FieldItem.from_dict(_item) for _item in obj["Fields"]] if obj.get("Fields") is not None else None,
-            "STRINGS_DISTANCE": obj.get("STRINGS_DISTANCE"),
-            "STRINGS_INTERVAL": obj.get("STRINGS_INTERVAL"),
-            "STRING_FILLING": obj.get("STRING_FILLING"),
-            "STRING_POSITION": obj.get("STRING_POSITION"),
-            "SYMBOLS_PARAM": obj.get("SYMBOLS_PARAM"),
-            "SizeError_ALIGNMENT": obj.get("SizeError_ALIGNMENT"),
-            "SizeError_DISTANCE": obj.get("SizeError_DISTANCE"),
-            "SizeError_INTERVAL": obj.get("SizeError_INTERVAL"),
-            "StringAngle": obj.get("StringAngle"),
-            "StringBorders": RectangleCoordinates.from_dict(obj["StringBorders"]) if obj.get("StringBorders") is not None else None,
-            "SymbolsCount": obj.get("SymbolsCount"),
-            "SymbolsEstimations": [SymbolEstimationItem.from_dict(_item) for _item in obj["SymbolsEstimations"]] if obj.get("SymbolsEstimations") is not None else None
-        })
-        return _obj
-
-

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

@@ -1,79 +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, StrictInt
-from typing import Any, ClassVar, Dict, List
-from typing import Optional, Set
-from typing_extensions import Self
-
-class Symbol(BaseModel):
-    """
-    Symbol
-    """ # noqa: E501
-    bounding_rect: List[StrictInt] = Field(alias="boundingRect")
-    __properties: ClassVar[List[str]] = ["boundingRect"]
-
-    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 Symbol 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 Symbol from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "boundingRect": obj.get("boundingRect")
-        })
-        return _obj
-
-

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

@@ -1,115 +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, StrictFloat, StrictInt
-from typing import Any, ClassVar, Dict, List, Union
-from regula.documentreader.webclient.gen.models.rectangle_coordinates import RectangleCoordinates
-from typing import Optional, Set
-from typing_extensions import Self
-
-class SymbolEstimationItem(BaseModel):
-    """
-    SymbolEstimationItem
-    """ # noqa: E501
-    alignment_nearest_symbols: StrictInt = Field(alias="ALIGNMENT_NEAREST_SYMBOLS")
-    contrast_print: StrictInt = Field(alias="CONTRAST_PRINT")
-    contrast_symbol: StrictInt = Field(alias="CONTRAST_SYMBOL")
-    char_symbol: StrictInt = Field(alias="CharSymbol")
-    edge: StrictInt = Field(alias="EDGE")
-    emptiness: StrictInt = Field(alias="EMPTINESS")
-    stain: StrictInt = Field(alias="STAIN")
-    symbols_interval: StrictInt = Field(alias="SYMBOLS_INTERVAL")
-    symbol_param: StrictInt = Field(alias="SYMBOL_PARAM")
-    symbol_size: StrictInt = Field(alias="SYMBOL_SIZE")
-    size_error_align_with_next: Union[StrictFloat, StrictInt] = Field(alias="SizeErrorAlignWithNext")
-    size_error_align_with_prev: Union[StrictFloat, StrictInt] = Field(alias="SizeErrorAlignWithPrev")
-    size_error_interv_with_next: Union[StrictFloat, StrictInt] = Field(alias="SizeErrorIntervWithNext")
-    size_error_interv_with_prev: Union[StrictFloat, StrictInt] = Field(alias="SizeErrorIntervWithPrev")
-    size_error_symbol_height: Union[StrictFloat, StrictInt] = Field(alias="SizeErrorSymbolHeight")
-    size_error_symbol_width: Union[StrictFloat, StrictInt] = Field(alias="SizeErrorSymbolWidth")
-    symbol_bounds: RectangleCoordinates = Field(alias="SymbolBounds")
-    __properties: ClassVar[List[str]] = ["ALIGNMENT_NEAREST_SYMBOLS", "CONTRAST_PRINT", "CONTRAST_SYMBOL", "CharSymbol", "EDGE", "EMPTINESS", "STAIN", "SYMBOLS_INTERVAL", "SYMBOL_PARAM", "SYMBOL_SIZE", "SizeErrorAlignWithNext", "SizeErrorAlignWithPrev", "SizeErrorIntervWithNext", "SizeErrorIntervWithPrev", "SizeErrorSymbolHeight", "SizeErrorSymbolWidth", "SymbolBounds"]
-
-    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 SymbolEstimationItem 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 symbol_bounds
-        if self.symbol_bounds:
-            _dict['SymbolBounds'] = self.symbol_bounds.to_dict()
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of SymbolEstimationItem from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "ALIGNMENT_NEAREST_SYMBOLS": obj.get("ALIGNMENT_NEAREST_SYMBOLS"),
-            "CONTRAST_PRINT": obj.get("CONTRAST_PRINT"),
-            "CONTRAST_SYMBOL": obj.get("CONTRAST_SYMBOL"),
-            "CharSymbol": obj.get("CharSymbol"),
-            "EDGE": obj.get("EDGE"),
-            "EMPTINESS": obj.get("EMPTINESS"),
-            "STAIN": obj.get("STAIN"),
-            "SYMBOLS_INTERVAL": obj.get("SYMBOLS_INTERVAL"),
-            "SYMBOL_PARAM": obj.get("SYMBOL_PARAM"),
-            "SYMBOL_SIZE": obj.get("SYMBOL_SIZE"),
-            "SizeErrorAlignWithNext": obj.get("SizeErrorAlignWithNext"),
-            "SizeErrorAlignWithPrev": obj.get("SizeErrorAlignWithPrev"),
-            "SizeErrorIntervWithNext": obj.get("SizeErrorIntervWithNext"),
-            "SizeErrorIntervWithPrev": obj.get("SizeErrorIntervWithPrev"),
-            "SizeErrorSymbolHeight": obj.get("SizeErrorSymbolHeight"),
-            "SizeErrorSymbolWidth": obj.get("SizeErrorSymbolWidth"),
-            "SymbolBounds": RectangleCoordinates.from_dict(obj["SymbolBounds"]) if obj.get("SymbolBounds") is not None else None
-        })
-        return _obj
-
-

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

@@ -1,93 +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
-from typing import Any, ClassVar, Dict, List, Optional
-from regula.documentreader.webclient.gen.models.binary_data import BinaryData
-from regula.documentreader.webclient.gen.models.rfid_raw_data import RfidRawData
-from typing import Optional, Set
-from typing_extensions import Self
-
-class TDocBinaryInfo(BaseModel):
-    """
-    TDocBinaryInfo
-    """ # noqa: E501
-    rfid_binary_data: Optional[BinaryData] = Field(default=None, alias="RFID_BINARY_DATA")
-    rfid_raw_data: Optional[List[RfidRawData]] = Field(default=None, alias="RFID_RAW_DATA")
-    __properties: ClassVar[List[str]] = ["RFID_BINARY_DATA", "RFID_RAW_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 TDocBinaryInfo 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 rfid_binary_data
-        if self.rfid_binary_data:
-            _dict['RFID_BINARY_DATA'] = self.rfid_binary_data.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in rfid_raw_data (list)
-        _items = []
-        if self.rfid_raw_data:
-            for _item_rfid_raw_data in self.rfid_raw_data:
-                if _item_rfid_raw_data:
-                    _items.append(_item_rfid_raw_data.to_dict())
-            _dict['RFID_RAW_DATA'] = _items
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of TDocBinaryInfo from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "RFID_BINARY_DATA": BinaryData.from_dict(obj["RFID_BINARY_DATA"]) if obj.get("RFID_BINARY_DATA") is not None else None,
-            "RFID_RAW_DATA": [RfidRawData.from_dict(_item) for _item in obj["RFID_RAW_DATA"]] if obj.get("RFID_RAW_DATA") is not None else None
-        })
-        return _obj
-
-

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

@@ -1,83 +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
-from typing import Any, ClassVar, Dict, List
-from regula.documentreader.webclient.gen.models.t_doc_binary_info import TDocBinaryInfo
-from typing import Optional, Set
-from typing_extensions import Self
-
-class TDocBinaryInfoItem(BaseModel):
-    """
-    TDocBinaryInfoItem
-    """ # noqa: E501
-    t_doc_binary_info: TDocBinaryInfo = Field(alias="TDocBinaryInfo")
-    __properties: ClassVar[List[str]] = ["TDocBinaryInfo"]
-
-    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 TDocBinaryInfoItem 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 t_doc_binary_info
-        if self.t_doc_binary_info:
-            _dict['TDocBinaryInfo'] = self.t_doc_binary_info.to_dict()
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of TDocBinaryInfoItem from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "TDocBinaryInfo": TDocBinaryInfo.from_dict(obj["TDocBinaryInfo"]) if obj.get("TDocBinaryInfo") is not None else None
-        })
-        return _obj
-
-

regula/documentreader/webclient/gen/models/t_original_rfid_graphics_info.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
-from typing import Any, ClassVar, Dict, List
-from regula.documentreader.webclient.gen.models.graph_data import GraphData
-from typing import Optional, Set
-from typing_extensions import Self
-
-class TOriginalRFIDGraphicsInfo(BaseModel):
-    """
-    TOriginalRFIDGraphicsInfo
-    """ # noqa: E501
-    rfid_original_graph_data: List[GraphData] = Field(alias="RFID_ORIGINAL_GRAPH_DATA")
-    __properties: ClassVar[List[str]] = ["RFID_ORIGINAL_GRAPH_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 TOriginalRFIDGraphicsInfo 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 rfid_original_graph_data (list)
-        _items = []
-        if self.rfid_original_graph_data:
-            for _item_rfid_original_graph_data in self.rfid_original_graph_data:
-                if _item_rfid_original_graph_data:
-                    _items.append(_item_rfid_original_graph_data.to_dict())
-            _dict['RFID_ORIGINAL_GRAPH_DATA'] = _items
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of TOriginalRFIDGraphicsInfo from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "RFID_ORIGINAL_GRAPH_DATA": [GraphData.from_dict(_item) for _item in obj["RFID_ORIGINAL_GRAPH_DATA"]] if obj.get("RFID_ORIGINAL_GRAPH_DATA") is not None else None
-        })
-        return _obj
-
-

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

@@ -1,83 +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
-from typing import Any, ClassVar, Dict, List
-from regula.documentreader.webclient.gen.models.t_original_rfid_graphics_info import TOriginalRFIDGraphicsInfo
-from typing import Optional, Set
-from typing_extensions import Self
-
-class TOriginalRFIDGraphicsInfoItem(BaseModel):
-    """
-    TOriginalRFIDGraphicsInfoItem
-    """ # noqa: E501
-    t_original_rfid_graphics_info: TOriginalRFIDGraphicsInfo = Field(alias="TOriginalRFIDGraphicsInfo")
-    __properties: ClassVar[List[str]] = ["TOriginalRFIDGraphicsInfo"]
-
-    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 TOriginalRFIDGraphicsInfoItem 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 t_original_rfid_graphics_info
-        if self.t_original_rfid_graphics_info:
-            _dict['TOriginalRFIDGraphicsInfo'] = self.t_original_rfid_graphics_info.to_dict()
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of TOriginalRFIDGraphicsInfoItem from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "TOriginalRFIDGraphicsInfo": TOriginalRFIDGraphicsInfo.from_dict(obj["TOriginalRFIDGraphicsInfo"]) if obj.get("TOriginalRFIDGraphicsInfo") is not None else None
-        })
-        return _obj
-
-