lusid-sdk 1.1.118__py3-none-any.whl → 2.0.50b0__py3-none-any.whl

lusid/models/reconciliation_request.py

@@ -5,260 +5,111 @@
 
     FINBOURNE Technology  # noqa: E501
 
-    The version of the OpenAPI document: 1.1.118
     Contact: info@finbourne.com
-    Generated by: https://openapi-generator.tech
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
 """
 
 
-try:
-    from inspect import getfullargspec
-except ImportError:
-    from inspect import getargspec as getfullargspec
+from __future__ import annotations
 import pprint
 import re  # noqa: F401
-import six
-
-from lusid.configuration import Configuration
-
+import json
 
-class ReconciliationRequest(object):
-    """NOTE: This class is auto generated by OpenAPI Generator.
-    Ref: https://openapi-generator.tech
 
-    Do not edit the class manually.
-    """
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field, StrictStr, conlist
+from lusid.models.reconciliation_left_right_address_key_pair import ReconciliationLeftRightAddressKeyPair
+from lusid.models.reconciliation_rule import ReconciliationRule
+from lusid.models.valuation_request import ValuationRequest
 
+class ReconciliationRequest(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.
-      required_map (dict): The key is attribute name
-                           and the value is whether it is 'required' or 'optional'.
+    Specification for the reconciliation request. Left and Right hand sides are constructed. Each consists of a valuation of a portfolio  using an aggregation request. The results of this can then be compared to each other. The difference, which is effectively a risk based  difference allows comparison of the effects of changing a recipe, valuation date, or (though it may or may not make logical sense) a portfolio.  For instance, one might look at the difference in risk caused by the addition of transaction to a portfolio, or through changing the valuation  methodology or system.  # noqa: E501
     """
-    openapi_types = {
-        'left': 'ValuationRequest',
-        'right': 'ValuationRequest',
-        'left_to_right_mapping': 'list[ReconciliationLeftRightAddressKeyPair]',
-        'comparison_rules': 'list[ReconciliationRule]',
-        'preserve_keys': 'list[str]'
-    }
-
-    attribute_map = {
-        'left': 'left',
-        'right': 'right',
-        'left_to_right_mapping': 'leftToRightMapping',
-        'comparison_rules': 'comparisonRules',
-        'preserve_keys': 'preserveKeys'
-    }
-
-    required_map = {
-        'left': 'required',
-        'right': 'required',
-        'left_to_right_mapping': 'optional',
-        'comparison_rules': 'optional',
-        'preserve_keys': 'optional'
-    }
-
-    def __init__(self, left=None, right=None, left_to_right_mapping=None, comparison_rules=None, preserve_keys=None, local_vars_configuration=None):  # noqa: E501
-        """ReconciliationRequest - a model defined in OpenAPI"
-        
-        :param left:  (required)
-        :type left: lusid.ValuationRequest
-        :param right:  (required)
-        :type right: lusid.ValuationRequest
-        :param left_to_right_mapping:  The mapping from property keys requested by left aggregation to property keys on right hand side
-        :type left_to_right_mapping: list[lusid.ReconciliationLeftRightAddressKeyPair]
-        :param comparison_rules:  The set of rules to be used in comparing values. These are the rules that determine what constitues a match.  The simplest is obviously an exact one-for-one comparison, but tolerances on numerical or date time values and  case-insensitive string comparison are supported amongst other types.
-        :type comparison_rules: list[lusid.ReconciliationRule]
-        :param preserve_keys:  List of keys to preserve (from rhs) in the diff. Used in conjunction with filtering/grouping.  If two values are equal, for a given key then the value is elided from the results. Setting it here  will preserve it (takes the values from the RHS and puts it into the line by line results).
-        :type preserve_keys: list[str]
-
-        """  # noqa: E501
-        if local_vars_configuration is None:
-            local_vars_configuration = Configuration.get_default_copy()
-        self.local_vars_configuration = local_vars_configuration
-
-        self._left = None
-        self._right = None
-        self._left_to_right_mapping = None
-        self._comparison_rules = None
-        self._preserve_keys = None
-        self.discriminator = None
-
-        self.left = left
-        self.right = right
-        self.left_to_right_mapping = left_to_right_mapping
-        self.comparison_rules = comparison_rules
-        self.preserve_keys = preserve_keys
-
-    @property
-    def left(self):
-        """Gets the left of this ReconciliationRequest.  # noqa: E501
-
-
-        :return: The left of this ReconciliationRequest.  # noqa: E501
-        :rtype: lusid.ValuationRequest
-        """
-        return self._left
-
-    @left.setter
-    def left(self, left):
-        """Sets the left of this ReconciliationRequest.
-
-
-        :param left: The left of this ReconciliationRequest.  # noqa: E501
-        :type left: lusid.ValuationRequest
-        """
-        if self.local_vars_configuration.client_side_validation and left is None:  # noqa: E501
-            raise ValueError("Invalid value for `left`, must not be `None`")  # noqa: E501
-
-        self._left = left
-
-    @property
-    def right(self):
-        """Gets the right of this ReconciliationRequest.  # noqa: E501
-
-
-        :return: The right of this ReconciliationRequest.  # noqa: E501
-        :rtype: lusid.ValuationRequest
-        """
-        return self._right
-
-    @right.setter
-    def right(self, right):
-        """Sets the right of this ReconciliationRequest.
-
-
-        :param right: The right of this ReconciliationRequest.  # noqa: E501
-        :type right: lusid.ValuationRequest
-        """
-        if self.local_vars_configuration.client_side_validation and right is None:  # noqa: E501
-            raise ValueError("Invalid value for `right`, must not be `None`")  # noqa: E501
-
-        self._right = right
-
-    @property
-    def left_to_right_mapping(self):
-        """Gets the left_to_right_mapping of this ReconciliationRequest.  # noqa: E501
-
-        The mapping from property keys requested by left aggregation to property keys on right hand side  # noqa: E501
-
-        :return: The left_to_right_mapping of this ReconciliationRequest.  # noqa: E501
-        :rtype: list[lusid.ReconciliationLeftRightAddressKeyPair]
-        """
-        return self._left_to_right_mapping
-
-    @left_to_right_mapping.setter
-    def left_to_right_mapping(self, left_to_right_mapping):
-        """Sets the left_to_right_mapping of this ReconciliationRequest.
-
-        The mapping from property keys requested by left aggregation to property keys on right hand side  # noqa: E501
-
-        :param left_to_right_mapping: The left_to_right_mapping of this ReconciliationRequest.  # noqa: E501
-        :type left_to_right_mapping: list[lusid.ReconciliationLeftRightAddressKeyPair]
-        """
-
-        self._left_to_right_mapping = left_to_right_mapping
-
-    @property
-    def comparison_rules(self):
-        """Gets the comparison_rules of this ReconciliationRequest.  # noqa: E501
-
-        The set of rules to be used in comparing values. These are the rules that determine what constitues a match.  The simplest is obviously an exact one-for-one comparison, but tolerances on numerical or date time values and  case-insensitive string comparison are supported amongst other types.  # noqa: E501
-
-        :return: The comparison_rules of this ReconciliationRequest.  # noqa: E501
-        :rtype: list[lusid.ReconciliationRule]
-        """
-        return self._comparison_rules
-
-    @comparison_rules.setter
-    def comparison_rules(self, comparison_rules):
-        """Sets the comparison_rules of this ReconciliationRequest.
-
-        The set of rules to be used in comparing values. These are the rules that determine what constitues a match.  The simplest is obviously an exact one-for-one comparison, but tolerances on numerical or date time values and  case-insensitive string comparison are supported amongst other types.  # noqa: E501
-
-        :param comparison_rules: The comparison_rules of this ReconciliationRequest.  # noqa: E501
-        :type comparison_rules: list[lusid.ReconciliationRule]
-        """
-
-        self._comparison_rules = comparison_rules
-
-    @property
-    def preserve_keys(self):
-        """Gets the preserve_keys of this ReconciliationRequest.  # noqa: E501
-
-        List of keys to preserve (from rhs) in the diff. Used in conjunction with filtering/grouping.  If two values are equal, for a given key then the value is elided from the results. Setting it here  will preserve it (takes the values from the RHS and puts it into the line by line results).  # noqa: E501
-
-        :return: The preserve_keys of this ReconciliationRequest.  # noqa: E501
-        :rtype: list[str]
-        """
-        return self._preserve_keys
-
-    @preserve_keys.setter
-    def preserve_keys(self, preserve_keys):
-        """Sets the preserve_keys of this ReconciliationRequest.
-
-        List of keys to preserve (from rhs) in the diff. Used in conjunction with filtering/grouping.  If two values are equal, for a given key then the value is elided from the results. Setting it here  will preserve it (takes the values from the RHS and puts it into the line by line results).  # noqa: E501
-
-        :param preserve_keys: The preserve_keys of this ReconciliationRequest.  # noqa: E501
-        :type preserve_keys: list[str]
-        """
-
-        self._preserve_keys = preserve_keys
-
-    def to_dict(self, serialize=False):
-        """Returns the model properties as a dict"""
-        result = {}
-
-        def convert(x):
-            if hasattr(x, "to_dict"):
-                args = getfullargspec(x.to_dict).args
-                if len(args) == 1:
-                    return x.to_dict()
-                else:
-                    return x.to_dict(serialize)
-            else:
-                return x
-
-        for attr, _ in six.iteritems(self.openapi_types):
-            value = getattr(self, attr)
-            attr = self.attribute_map.get(attr, attr) if serialize else attr
-            if isinstance(value, list):
-                result[attr] = list(map(
-                    lambda x: convert(x),
-                    value
-                ))
-            elif isinstance(value, dict):
-                result[attr] = dict(map(
-                    lambda item: (item[0], convert(item[1])),
-                    value.items()
-                ))
-            else:
-                result[attr] = convert(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, ReconciliationRequest):
-            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, ReconciliationRequest):
-            return True
-
-        return self.to_dict() != other.to_dict()
+    left: ValuationRequest = Field(...)
+    right: ValuationRequest = Field(...)
+    left_to_right_mapping: Optional[conlist(ReconciliationLeftRightAddressKeyPair)] = Field(None, alias="leftToRightMapping", description="The mapping from property keys requested by left aggregation to property keys on right hand side")
+    comparison_rules: Optional[conlist(ReconciliationRule)] = Field(None, alias="comparisonRules", description="The set of rules to be used in comparing values. These are the rules that determine what constitues a match.  The simplest is obviously an exact one-for-one comparison, but tolerances on numerical or date time values and  case-insensitive string comparison are supported amongst other types.")
+    preserve_keys: Optional[conlist(StrictStr)] = Field(None, alias="preserveKeys", description="List of keys to preserve (from rhs) in the diff. Used in conjunction with filtering/grouping.  If two values are equal, for a given key then the value is elided from the results. Setting it here  will preserve it (takes the values from the RHS and puts it into the line by line results).")
+    __properties = ["left", "right", "leftToRightMapping", "comparisonRules", "preserveKeys"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> ReconciliationRequest:
+        """Create an instance of ReconciliationRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of left
+        if self.left:
+            _dict['left'] = self.left.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of right
+        if self.right:
+            _dict['right'] = self.right.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in left_to_right_mapping (list)
+        _items = []
+        if self.left_to_right_mapping:
+            for _item in self.left_to_right_mapping:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['leftToRightMapping'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in comparison_rules (list)
+        _items = []
+        if self.comparison_rules:
+            for _item in self.comparison_rules:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['comparisonRules'] = _items
+        # set to None if left_to_right_mapping (nullable) is None
+        # and __fields_set__ contains the field
+        if self.left_to_right_mapping is None and "left_to_right_mapping" in self.__fields_set__:
+            _dict['leftToRightMapping'] = None
+
+        # set to None if comparison_rules (nullable) is None
+        # and __fields_set__ contains the field
+        if self.comparison_rules is None and "comparison_rules" in self.__fields_set__:
+            _dict['comparisonRules'] = None
+
+        # set to None if preserve_keys (nullable) is None
+        # and __fields_set__ contains the field
+        if self.preserve_keys is None and "preserve_keys" in self.__fields_set__:
+            _dict['preserveKeys'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ReconciliationRequest:
+        """Create an instance of ReconciliationRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ReconciliationRequest.parse_obj(obj)
+
+        _obj = ReconciliationRequest.parse_obj({
+            "left": ValuationRequest.from_dict(obj.get("left")) if obj.get("left") is not None else None,
+            "right": ValuationRequest.from_dict(obj.get("right")) if obj.get("right") is not None else None,
+            "left_to_right_mapping": [ReconciliationLeftRightAddressKeyPair.from_dict(_item) for _item in obj.get("leftToRightMapping")] if obj.get("leftToRightMapping") is not None else None,
+            "comparison_rules": [ReconciliationRule.from_dict(_item) for _item in obj.get("comparisonRules")] if obj.get("comparisonRules") is not None else None,
+            "preserve_keys": obj.get("preserveKeys")
+        })
+        return _obj

lusid/models/reconciliation_response.py

@@ -5,169 +5,84 @@
 
     FINBOURNE Technology  # noqa: E501
 
-    The version of the OpenAPI document: 1.1.118
     Contact: info@finbourne.com
-    Generated by: https://openapi-generator.tech
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
 """
 
 
-try:
-    from inspect import getfullargspec
-except ImportError:
-    from inspect import getargspec as getfullargspec
+from __future__ import annotations
 import pprint
 import re  # noqa: F401
-import six
-
-from lusid.configuration import Configuration
-
+import json
 
-class ReconciliationResponse(object):
-    """NOTE: This class is auto generated by OpenAPI Generator.
-    Ref: https://openapi-generator.tech
 
-    Do not edit the class manually.
-    """
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field, conlist
+from lusid.models.reconciliation_line import ReconciliationLine
+from lusid.models.result_data_schema import ResultDataSchema
 
+class ReconciliationResponse(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.
-      required_map (dict): The key is attribute name
-                           and the value is whether it is 'required' or 'optional'.
+    Class representing the set of comparisons that result from comparing holdings and their valuations between two separate evaluations.  # noqa: E501
     """
-    openapi_types = {
-        'comparisons': 'list[ReconciliationLine]',
-        'data_schema': 'ResultDataSchema'
-    }
-
-    attribute_map = {
-        'comparisons': 'comparisons',
-        'data_schema': 'dataSchema'
-    }
-
-    required_map = {
-        'comparisons': 'optional',
-        'data_schema': 'optional'
-    }
-
-    def __init__(self, comparisons=None, data_schema=None, local_vars_configuration=None):  # noqa: E501
-        """ReconciliationResponse - a model defined in OpenAPI"
-        
-        :param comparisons:  List of comparisons of left to right hand sides.
-        :type comparisons: list[lusid.ReconciliationLine]
-        :param data_schema: 
-        :type data_schema: lusid.ResultDataSchema
-
-        """  # noqa: E501
-        if local_vars_configuration is None:
-            local_vars_configuration = Configuration.get_default_copy()
-        self.local_vars_configuration = local_vars_configuration
-
-        self._comparisons = None
-        self._data_schema = None
-        self.discriminator = None
-
-        self.comparisons = comparisons
-        if data_schema is not None:
-            self.data_schema = data_schema
-
-    @property
-    def comparisons(self):
-        """Gets the comparisons of this ReconciliationResponse.  # noqa: E501
-
-        List of comparisons of left to right hand sides.  # noqa: E501
-
-        :return: The comparisons of this ReconciliationResponse.  # noqa: E501
-        :rtype: list[lusid.ReconciliationLine]
-        """
-        return self._comparisons
-
-    @comparisons.setter
-    def comparisons(self, comparisons):
-        """Sets the comparisons of this ReconciliationResponse.
-
-        List of comparisons of left to right hand sides.  # noqa: E501
-
-        :param comparisons: The comparisons of this ReconciliationResponse.  # noqa: E501
-        :type comparisons: list[lusid.ReconciliationLine]
-        """
-
-        self._comparisons = comparisons
-
-    @property
-    def data_schema(self):
-        """Gets the data_schema of this ReconciliationResponse.  # noqa: E501
-
-
-        :return: The data_schema of this ReconciliationResponse.  # noqa: E501
-        :rtype: lusid.ResultDataSchema
-        """
-        return self._data_schema
-
-    @data_schema.setter
-    def data_schema(self, data_schema):
-        """Sets the data_schema of this ReconciliationResponse.
-
-
-        :param data_schema: The data_schema of this ReconciliationResponse.  # noqa: E501
-        :type data_schema: lusid.ResultDataSchema
-        """
-
-        self._data_schema = data_schema
-
-    def to_dict(self, serialize=False):
-        """Returns the model properties as a dict"""
-        result = {}
-
-        def convert(x):
-            if hasattr(x, "to_dict"):
-                args = getfullargspec(x.to_dict).args
-                if len(args) == 1:
-                    return x.to_dict()
-                else:
-                    return x.to_dict(serialize)
-            else:
-                return x
-
-        for attr, _ in six.iteritems(self.openapi_types):
-            value = getattr(self, attr)
-            attr = self.attribute_map.get(attr, attr) if serialize else attr
-            if isinstance(value, list):
-                result[attr] = list(map(
-                    lambda x: convert(x),
-                    value
-                ))
-            elif isinstance(value, dict):
-                result[attr] = dict(map(
-                    lambda item: (item[0], convert(item[1])),
-                    value.items()
-                ))
-            else:
-                result[attr] = convert(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, ReconciliationResponse):
-            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, ReconciliationResponse):
-            return True
-
-        return self.to_dict() != other.to_dict()
+    comparisons: Optional[conlist(ReconciliationLine)] = Field(None, description="List of comparisons of left to right hand sides.")
+    data_schema: Optional[ResultDataSchema] = Field(None, alias="dataSchema")
+    __properties = ["comparisons", "dataSchema"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> ReconciliationResponse:
+        """Create an instance of ReconciliationResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in comparisons (list)
+        _items = []
+        if self.comparisons:
+            for _item in self.comparisons:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['comparisons'] = _items
+        # override the default output from pydantic by calling `to_dict()` of data_schema
+        if self.data_schema:
+            _dict['dataSchema'] = self.data_schema.to_dict()
+        # set to None if comparisons (nullable) is None
+        # and __fields_set__ contains the field
+        if self.comparisons is None and "comparisons" in self.__fields_set__:
+            _dict['comparisons'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ReconciliationResponse:
+        """Create an instance of ReconciliationResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ReconciliationResponse.parse_obj(obj)
+
+        _obj = ReconciliationResponse.parse_obj({
+            "comparisons": [ReconciliationLine.from_dict(_item) for _item in obj.get("comparisons")] if obj.get("comparisons") is not None else None,
+            "data_schema": ResultDataSchema.from_dict(obj.get("dataSchema")) if obj.get("dataSchema") is not None else None
+        })
+        return _obj