regula-documentreader-webclient 8.1.349rc0__py3-none-any.whl → 8.1.351.dev0__py3-none-any.whl

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

@@ -0,0 +1,79 @@
+# 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_candidate.py

@@ -4,154 +4,83 @@
     Generated by: https://openapi-generator.tech
 """
 
+from __future__ import annotations
 import pprint
 import re  # noqa: F401
+import json
 
-import six
-
-from regula.documentreader.webclient.gen.configuration import Configuration
-# this line was added to enable pycharm type hinting
-from regula.documentreader.webclient.gen.models import *
-
-
-"""
-Describes an individual character recognition candidate
-"""
-class SymbolCandidate(object):
-    """NOTE: This class is auto generated by OpenAPI Generator.
-    Ref: https://openapi-generator.tech
-
-    Do not edit the class manually.
-    """
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
 
+class SymbolCandidate(BaseModel):
     """
-    Attributes:
-      openapi_types (dict): The key is attribute name
-                            and the value is attribute type.
-      attribute_map (dict): The key is attribute name
-                            and the value is json key in definition.
-    """
-    openapi_types = {
-        'symbol_code': 'int',
-        'symbol_probability': 'int'
-    }
-
-    attribute_map = {
-        'symbol_code': 'SymbolCode',
-        'symbol_probability': 'SymbolProbability'
-    }
-
-    def __init__(self, symbol_code=None, symbol_probability=None, local_vars_configuration=None):  # noqa: E501
-        """SymbolCandidate - a model defined in OpenAPI"""  # noqa: E501
-        if local_vars_configuration is None:
-            local_vars_configuration = Configuration()
-        self.local_vars_configuration = local_vars_configuration
-
-        self._symbol_code = None
-        self._symbol_probability = None
-        self.discriminator = None
-
-        self.symbol_code = symbol_code
-        self.symbol_probability = symbol_probability
-
-    @property
-    def symbol_code(self):
-        """Gets the symbol_code of this SymbolCandidate.  # noqa: E501
-
-        Unicode symbol code  # noqa: E501
-
-        :return: The symbol_code of this SymbolCandidate.  # noqa: E501
-        :rtype: int
+    Describes an individual character recognition candidate
+    """ # noqa: E501
+    symbol_code: StrictInt = Field(description="Unicode symbol code", alias="SymbolCode")
+    symbol_probability: Annotated[int, Field(le=100, strict=True, ge=0)] = Field(description="character recognition probability (0–100,%)", alias="SymbolProbability")
+    var_class: Optional[StrictInt] = Field(default=None, alias="Class")
+    sub_class: Optional[StrictInt] = Field(default=None, alias="SubClass")
+    __properties: ClassVar[List[str]] = ["SymbolCode", "SymbolProbability", "Class", "SubClass"]
+
+    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 SymbolCandidate 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.
         """
-        return self._symbol_code
-
-    @symbol_code.setter
-    def symbol_code(self, symbol_code):
-        """Sets the symbol_code of this SymbolCandidate.
-
-        Unicode symbol code  # noqa: E501
-
-        :param symbol_code: The symbol_code of this SymbolCandidate.  # noqa: E501
-        :type symbol_code: int
-        """
-        if self.local_vars_configuration.client_side_validation and symbol_code is None:  # noqa: E501
-            raise ValueError("Invalid value for `symbol_code`, must not be `None`")  # noqa: E501
-
-        self._symbol_code = symbol_code
+        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 SymbolCandidate from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "SymbolCode": obj.get("SymbolCode"),
+            "SymbolProbability": obj.get("SymbolProbability"),
+            "Class": obj.get("Class"),
+            "SubClass": obj.get("SubClass")
+        })
+        return _obj
 
-    @property
-    def symbol_probability(self):
-        """Gets the symbol_probability of this SymbolCandidate.  # noqa: E501
 
-        character recognition probability (0–100,%)  # noqa: E501
-
-        :return: The symbol_probability of this SymbolCandidate.  # noqa: E501
-        :rtype: int
-        """
-        return self._symbol_probability
-
-    @symbol_probability.setter
-    def symbol_probability(self, symbol_probability):
-        """Sets the symbol_probability of this SymbolCandidate.
-
-        character recognition probability (0–100,%)  # noqa: E501
-
-        :param symbol_probability: The symbol_probability of this SymbolCandidate.  # noqa: E501
-        :type symbol_probability: int
-        """
-        if self.local_vars_configuration.client_side_validation and symbol_probability is None:  # noqa: E501
-            raise ValueError("Invalid value for `symbol_probability`, must not be `None`")  # noqa: E501
-        if (self.local_vars_configuration.client_side_validation and
-                symbol_probability is not None and symbol_probability > 100):  # noqa: E501
-            raise ValueError("Invalid value for `symbol_probability`, must be a value less than or equal to `100`")  # noqa: E501
-        if (self.local_vars_configuration.client_side_validation and
-                symbol_probability is not None and symbol_probability < 0):  # noqa: E501
-            raise ValueError("Invalid value for `symbol_probability`, must be a value greater than or equal to `0`")  # noqa: E501
-
-        self._symbol_probability = symbol_probability
-
-    def to_dict(self):
-        """Returns the model properties as a dict"""
-        result = {}
-
-        for attr, _ in six.iteritems(self.openapi_types):
-            value = getattr(self, attr)
-            if isinstance(value, list):
-                result[attr] = list(map(
-                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
-                    value
-                ))
-            elif hasattr(value, "to_dict"):
-                result[attr] = value.to_dict()
-            elif isinstance(value, dict):
-                result[attr] = dict(map(
-                    lambda item: (item[0], item[1].to_dict())
-                    if hasattr(item[1], "to_dict") else item,
-                    value.items()
-                ))
-            else:
-                result[attr] = value
-
-        return result
-
-    def to_str(self):
-        """Returns the string representation of the model"""
-        return pprint.pformat(self.to_dict())
-
-    def __repr__(self):
-        """For `print` and `pprint`"""
-        return self.to_str()
-
-    def __eq__(self, other):
-        """Returns true if both objects are equal"""
-        if not isinstance(other, SymbolCandidate):
-            return False
-
-        return self.to_dict() == other.to_dict()
-
-    def __ne__(self, other):
-        """Returns true if both objects are not equal"""
-        if not isinstance(other, SymbolCandidate):
-            return True
-
-        return self.to_dict() != other.to_dict()

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

@@ -0,0 +1,115 @@
+# 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/symbol_recognition_result.py

@@ -4,146 +4,98 @@
     Generated by: https://openapi-generator.tech
 """
 
+from __future__ import annotations
 import pprint
 import re  # noqa: F401
+import json
 
-import six
-
-from regula.documentreader.webclient.gen.configuration import Configuration
-# this line was added to enable pycharm type hinting
-from regula.documentreader.webclient.gen.models import *
-
-
-"""
-Describes a single character recognition results in the text field line
-"""
-class SymbolRecognitionResult(object):
-    """NOTE: This class is auto generated by OpenAPI Generator.
-    Ref: https://openapi-generator.tech
-
-    Do not edit the class manually.
-    """
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from regula.documentreader.webclient.gen.models.rectangle_coordinates import RectangleCoordinates
+from regula.documentreader.webclient.gen.models.symbol_candidate import SymbolCandidate
+from typing import Optional, Set
+from typing_extensions import Self
 
+class SymbolRecognitionResult(BaseModel):
     """
-    Attributes:
-      openapi_types (dict): The key is attribute name
-                            and the value is attribute type.
-      attribute_map (dict): The key is attribute name
-                            and the value is json key in definition.
-    """
-    openapi_types = {
-        'symbol_rect': 'RectangleCoordinates',
-        'list_of_candidates': 'list[SymbolCandidate]'
-    }
-
-    attribute_map = {
-        'symbol_rect': 'SymbolRect',
-        'list_of_candidates': 'ListOfCandidates'
-    }
-
-    def __init__(self, symbol_rect=None, list_of_candidates=None, local_vars_configuration=None):  # noqa: E501
-        """SymbolRecognitionResult - a model defined in OpenAPI"""  # noqa: E501
-        if local_vars_configuration is None:
-            local_vars_configuration = Configuration()
-        self.local_vars_configuration = local_vars_configuration
-
-        self._symbol_rect = None
-        self._list_of_candidates = None
-        self.discriminator = None
-
-        self.symbol_rect = symbol_rect
-        self.list_of_candidates = list_of_candidates
-
-    @property
-    def symbol_rect(self):
-        """Gets the symbol_rect of this SymbolRecognitionResult.  # noqa: E501
-
-
-        :return: The symbol_rect of this SymbolRecognitionResult.  # noqa: E501
-        :rtype: RectangleCoordinates
+    Describes a single character recognition results in the text field line
+    """ # noqa: E501
+    symbol_rect: Optional[RectangleCoordinates] = Field(default=None, alias="SymbolRect")
+    candidates_count: Union[StrictFloat, StrictInt] = Field(description="Number of significant elements of ListOfCandidates array", alias="CandidatesCount")
+    list_of_candidates: List[SymbolCandidate] = Field(description="Array of candidate characters. Sorted in descending order of recognition probabilities (the first element has highest probability)", alias="ListOfCandidates")
+    base_line_bottom: Optional[StrictInt] = Field(default=None, alias="BaseLineBottom")
+    base_line_top: Optional[StrictInt] = Field(default=None, alias="BaseLineTop")
+    reserved: Optional[StrictInt] = Field(default=None, alias="Reserved")
+    __properties: ClassVar[List[str]] = ["SymbolRect", "CandidatesCount", "ListOfCandidates", "BaseLineBottom", "BaseLineTop", "Reserved"]
+
+    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 SymbolRecognitionResult 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.
         """
-        return self._symbol_rect
-
-    @symbol_rect.setter
-    def symbol_rect(self, symbol_rect):
-        """Sets the symbol_rect of this SymbolRecognitionResult.
-
-
-        :param symbol_rect: The symbol_rect of this SymbolRecognitionResult.  # noqa: E501
-        :type symbol_rect: RectangleCoordinates
-        """
-        if self.local_vars_configuration.client_side_validation and symbol_rect is None:  # noqa: E501
-            raise ValueError("Invalid value for `symbol_rect`, must not be `None`")  # noqa: E501
-
-        self._symbol_rect = symbol_rect
+        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_rect
+        if self.symbol_rect:
+            _dict['SymbolRect'] = self.symbol_rect.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in list_of_candidates (list)
+        _items = []
+        if self.list_of_candidates:
+            for _item_list_of_candidates in self.list_of_candidates:
+                if _item_list_of_candidates:
+                    _items.append(_item_list_of_candidates.to_dict())
+            _dict['ListOfCandidates'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SymbolRecognitionResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "SymbolRect": RectangleCoordinates.from_dict(obj["SymbolRect"]) if obj.get("SymbolRect") is not None else None,
+            "CandidatesCount": obj.get("CandidatesCount"),
+            "ListOfCandidates": [SymbolCandidate.from_dict(_item) for _item in obj["ListOfCandidates"]] if obj.get("ListOfCandidates") is not None else None,
+            "BaseLineBottom": obj.get("BaseLineBottom"),
+            "BaseLineTop": obj.get("BaseLineTop"),
+            "Reserved": obj.get("Reserved")
+        })
+        return _obj
 
-    @property
-    def list_of_candidates(self):
-        """Gets the list_of_candidates of this SymbolRecognitionResult.  # noqa: E501
 
-        Array of candidate characters. Sorted in descending order of recognition probabilities (the first element has highest probability)  # noqa: E501
-
-        :return: The list_of_candidates of this SymbolRecognitionResult.  # noqa: E501
-        :rtype: list[SymbolCandidate]
-        """
-        return self._list_of_candidates
-
-    @list_of_candidates.setter
-    def list_of_candidates(self, list_of_candidates):
-        """Sets the list_of_candidates of this SymbolRecognitionResult.
-
-        Array of candidate characters. Sorted in descending order of recognition probabilities (the first element has highest probability)  # noqa: E501
-
-        :param list_of_candidates: The list_of_candidates of this SymbolRecognitionResult.  # noqa: E501
-        :type list_of_candidates: list[SymbolCandidate]
-        """
-        if self.local_vars_configuration.client_side_validation and list_of_candidates is None:  # noqa: E501
-            raise ValueError("Invalid value for `list_of_candidates`, must not be `None`")  # noqa: E501
-
-        self._list_of_candidates = list_of_candidates
-
-    def to_dict(self):
-        """Returns the model properties as a dict"""
-        result = {}
-
-        for attr, _ in six.iteritems(self.openapi_types):
-            value = getattr(self, attr)
-            if isinstance(value, list):
-                result[attr] = list(map(
-                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
-                    value
-                ))
-            elif hasattr(value, "to_dict"):
-                result[attr] = value.to_dict()
-            elif isinstance(value, dict):
-                result[attr] = dict(map(
-                    lambda item: (item[0], item[1].to_dict())
-                    if hasattr(item[1], "to_dict") else item,
-                    value.items()
-                ))
-            else:
-                result[attr] = value
-
-        return result
-
-    def to_str(self):
-        """Returns the string representation of the model"""
-        return pprint.pformat(self.to_dict())
-
-    def __repr__(self):
-        """For `print` and `pprint`"""
-        return self.to_str()
-
-    def __eq__(self, other):
-        """Returns true if both objects are equal"""
-        if not isinstance(other, SymbolRecognitionResult):
-            return False
-
-        return self.to_dict() == other.to_dict()
-
-    def __ne__(self, other):
-        """Returns true if both objects are not equal"""
-        if not isinstance(other, SymbolRecognitionResult):
-            return True
-
-        return self.to_dict() != other.to_dict()