lusid-sdk 1.1.131__py3-none-any.whl → 2.1.683__py3-none-any.whl

lusid/models/market_context.py

@@ -5,257 +5,133 @@
 
     FINBOURNE Technology  # noqa: E501
 
-    The version of the OpenAPI document: 1.1.131
     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
+import json
 
-from lusid.configuration import Configuration
 
+from typing import Any, Dict, List, Optional
+from pydantic.v1 import BaseModel, Field, conlist
+from lusid.models.group_of_market_data_key_rules import GroupOfMarketDataKeyRules
+from lusid.models.market_context_suppliers import MarketContextSuppliers
+from lusid.models.market_data_key_rule import MarketDataKeyRule
+from lusid.models.market_data_specific_rule import MarketDataSpecificRule
+from lusid.models.market_options import MarketOptions
 
-class MarketContext(object):
-    """NOTE: This class is auto generated by OpenAPI Generator.
-    Ref: https://openapi-generator.tech
-
-    Do not edit the class manually.
+class MarketContext(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'.
+    Market context node. This defines how LUSID processes parts of a request that require resolution of market data such as instrument prices or  Fx rates. It controls where the data is loaded from and which sources take precedence.  # noqa: E501
     """
-    openapi_types = {
-        'market_rules': 'list[MarketDataKeyRule]',
-        'suppliers': 'MarketContextSuppliers',
-        'options': 'MarketOptions',
-        'specific_rules': 'list[MarketDataSpecificRule]',
-        'grouped_market_rules': 'list[GroupOfMarketDataKeyRules]'
-    }
-
-    attribute_map = {
-        'market_rules': 'marketRules',
-        'suppliers': 'suppliers',
-        'options': 'options',
-        'specific_rules': 'specificRules',
-        'grouped_market_rules': 'groupedMarketRules'
-    }
-
-    required_map = {
-        'market_rules': 'optional',
-        'suppliers': 'optional',
-        'options': 'optional',
-        'specific_rules': 'optional',
-        'grouped_market_rules': 'optional'
-    }
-
-    def __init__(self, market_rules=None, suppliers=None, options=None, specific_rules=None, grouped_market_rules=None, local_vars_configuration=None):  # noqa: E501
-        """MarketContext - a model defined in OpenAPI"
-        
-        :param market_rules:  The set of rules that define how to resolve particular use cases. These can be relatively general or specific in nature.  Nominally any number are possible and will be processed in order where applicable. However, there is evidently a potential  for increased computational cost where many rules must be applied to resolve data. Ensuring that portfolios are structured in  such a way as to reduce the number of rules required is therefore sensible.
-        :type market_rules: list[lusid.MarketDataKeyRule]
-        :param suppliers: 
-        :type suppliers: lusid.MarketContextSuppliers
-        :param options: 
-        :type options: lusid.MarketOptions
-        :param specific_rules:  Extends market data key rules to be able to catch dependencies depending on where the dependency comes from, as opposed to what the dependency is asking for.  Using two specific rules, one could instruct rates curves requested by bonds to be retrieved from a different scope than rates curves requested by swaps.  WARNING: The use of specific rules impacts performance. Where possible, one should use MarketDataKeyRules only.
-        :type specific_rules: list[lusid.MarketDataSpecificRule]
-        :param grouped_market_rules:  The list of groups of rules that will be used in market data resolution.  Rules given within a group will, if the group is being used to resolve data,  all be applied with the results of those individual resolution attempts combined into a single result.  The method for combining results is determined by the operation detailed in the GroupOfMarketDataKeyRules.                Notes:  - When resolving MarketData, MarketRules will be applied first followed by GroupedMarketRules  if data could not be found using only the MarketRules provided.  - GroupedMarketRules can only be used for resolving data from the QuoteStore.                Caution: As every rule in a given group will be applied in resolution if the group is applied,  groups are computationally expensive for market data resolution.  Therefore, heuristically, rule groups should be kept as small as possible.
-        :type grouped_market_rules: list[lusid.GroupOfMarketDataKeyRules]
-
-        """  # noqa: E501
-        if local_vars_configuration is None:
-            local_vars_configuration = Configuration.get_default_copy()
-        self.local_vars_configuration = local_vars_configuration
-
-        self._market_rules = None
-        self._suppliers = None
-        self._options = None
-        self._specific_rules = None
-        self._grouped_market_rules = None
-        self.discriminator = None
-
-        self.market_rules = market_rules
-        self.suppliers = suppliers
-        if options is not None:
-            self.options = options
-        self.specific_rules = specific_rules
-        self.grouped_market_rules = grouped_market_rules
-
-    @property
-    def market_rules(self):
-        """Gets the market_rules of this MarketContext.  # noqa: E501
-
-        The set of rules that define how to resolve particular use cases. These can be relatively general or specific in nature.  Nominally any number are possible and will be processed in order where applicable. However, there is evidently a potential  for increased computational cost where many rules must be applied to resolve data. Ensuring that portfolios are structured in  such a way as to reduce the number of rules required is therefore sensible.  # noqa: E501
-
-        :return: The market_rules of this MarketContext.  # noqa: E501
-        :rtype: list[lusid.MarketDataKeyRule]
-        """
-        return self._market_rules
-
-    @market_rules.setter
-    def market_rules(self, market_rules):
-        """Sets the market_rules of this MarketContext.
-
-        The set of rules that define how to resolve particular use cases. These can be relatively general or specific in nature.  Nominally any number are possible and will be processed in order where applicable. However, there is evidently a potential  for increased computational cost where many rules must be applied to resolve data. Ensuring that portfolios are structured in  such a way as to reduce the number of rules required is therefore sensible.  # noqa: E501
-
-        :param market_rules: The market_rules of this MarketContext.  # noqa: E501
-        :type market_rules: list[lusid.MarketDataKeyRule]
-        """
-
-        self._market_rules = market_rules
-
-    @property
-    def suppliers(self):
-        """Gets the suppliers of this MarketContext.  # noqa: E501
-
-
-        :return: The suppliers of this MarketContext.  # noqa: E501
-        :rtype: lusid.MarketContextSuppliers
-        """
-        return self._suppliers
-
-    @suppliers.setter
-    def suppliers(self, suppliers):
-        """Sets the suppliers of this MarketContext.
-
-
-        :param suppliers: The suppliers of this MarketContext.  # noqa: E501
-        :type suppliers: lusid.MarketContextSuppliers
-        """
-
-        self._suppliers = suppliers
-
-    @property
-    def options(self):
-        """Gets the options of this MarketContext.  # noqa: E501
-
-
-        :return: The options of this MarketContext.  # noqa: E501
-        :rtype: lusid.MarketOptions
-        """
-        return self._options
-
-    @options.setter
-    def options(self, options):
-        """Sets the options of this MarketContext.
-
-
-        :param options: The options of this MarketContext.  # noqa: E501
-        :type options: lusid.MarketOptions
-        """
-
-        self._options = options
-
-    @property
-    def specific_rules(self):
-        """Gets the specific_rules of this MarketContext.  # noqa: E501
-
-        Extends market data key rules to be able to catch dependencies depending on where the dependency comes from, as opposed to what the dependency is asking for.  Using two specific rules, one could instruct rates curves requested by bonds to be retrieved from a different scope than rates curves requested by swaps.  WARNING: The use of specific rules impacts performance. Where possible, one should use MarketDataKeyRules only.  # noqa: E501
-
-        :return: The specific_rules of this MarketContext.  # noqa: E501
-        :rtype: list[lusid.MarketDataSpecificRule]
-        """
-        return self._specific_rules
-
-    @specific_rules.setter
-    def specific_rules(self, specific_rules):
-        """Sets the specific_rules of this MarketContext.
-
-        Extends market data key rules to be able to catch dependencies depending on where the dependency comes from, as opposed to what the dependency is asking for.  Using two specific rules, one could instruct rates curves requested by bonds to be retrieved from a different scope than rates curves requested by swaps.  WARNING: The use of specific rules impacts performance. Where possible, one should use MarketDataKeyRules only.  # noqa: E501
-
-        :param specific_rules: The specific_rules of this MarketContext.  # noqa: E501
-        :type specific_rules: list[lusid.MarketDataSpecificRule]
-        """
-
-        self._specific_rules = specific_rules
-
-    @property
-    def grouped_market_rules(self):
-        """Gets the grouped_market_rules of this MarketContext.  # noqa: E501
-
-        The list of groups of rules that will be used in market data resolution.  Rules given within a group will, if the group is being used to resolve data,  all be applied with the results of those individual resolution attempts combined into a single result.  The method for combining results is determined by the operation detailed in the GroupOfMarketDataKeyRules.                Notes:  - When resolving MarketData, MarketRules will be applied first followed by GroupedMarketRules  if data could not be found using only the MarketRules provided.  - GroupedMarketRules can only be used for resolving data from the QuoteStore.                Caution: As every rule in a given group will be applied in resolution if the group is applied,  groups are computationally expensive for market data resolution.  Therefore, heuristically, rule groups should be kept as small as possible.  # noqa: E501
-
-        :return: The grouped_market_rules of this MarketContext.  # noqa: E501
-        :rtype: list[lusid.GroupOfMarketDataKeyRules]
-        """
-        return self._grouped_market_rules
-
-    @grouped_market_rules.setter
-    def grouped_market_rules(self, grouped_market_rules):
-        """Sets the grouped_market_rules of this MarketContext.
-
-        The list of groups of rules that will be used in market data resolution.  Rules given within a group will, if the group is being used to resolve data,  all be applied with the results of those individual resolution attempts combined into a single result.  The method for combining results is determined by the operation detailed in the GroupOfMarketDataKeyRules.                Notes:  - When resolving MarketData, MarketRules will be applied first followed by GroupedMarketRules  if data could not be found using only the MarketRules provided.  - GroupedMarketRules can only be used for resolving data from the QuoteStore.                Caution: As every rule in a given group will be applied in resolution if the group is applied,  groups are computationally expensive for market data resolution.  Therefore, heuristically, rule groups should be kept as small as possible.  # noqa: E501
-
-        :param grouped_market_rules: The grouped_market_rules of this MarketContext.  # noqa: E501
-        :type grouped_market_rules: list[lusid.GroupOfMarketDataKeyRules]
-        """
-
-        self._grouped_market_rules = grouped_market_rules
-
-    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())
+    market_rules: Optional[conlist(MarketDataKeyRule)] = Field(None, alias="marketRules", description="The set of rules that define how to resolve particular use cases. These can be relatively general or specific in nature.  Nominally any number are possible and will be processed in order where applicable. However, there is evidently a potential  for increased computational cost where many rules must be applied to resolve data. Ensuring that portfolios are structured in  such a way as to reduce the number of rules required is therefore sensible.")
+    suppliers: Optional[MarketContextSuppliers] = None
+    options: Optional[MarketOptions] = None
+    specific_rules: Optional[conlist(MarketDataSpecificRule)] = Field(None, alias="specificRules", description="Extends market data key rules to be able to catch dependencies depending on where the dependency comes from, as opposed to what the dependency is asking for.  Using two specific rules, one could instruct rates curves requested by bonds to be retrieved from a different scope than rates curves requested by swaps.  WARNING: The use of specific rules impacts performance. Where possible, one should use MarketDataKeyRules only.")
+    grouped_market_rules: Optional[conlist(GroupOfMarketDataKeyRules)] = Field(None, alias="groupedMarketRules", description="The list of groups of rules that will be used in market data resolution.  Rules given within a group will, if the group is being used to resolve data,  all be applied with the results of those individual resolution attempts combined into a single result.  The method for combining results is determined by the operation detailed in the GroupOfMarketDataKeyRules.                Notes:  - When resolving MarketData, MarketRules will be applied first followed by GroupedMarketRules  if data could not be found using only the MarketRules provided.  - GroupedMarketRules can only be used for resolving data from the QuoteStore.                Caution: As every rule in a given group will be applied in resolution if the group is applied,  groups are computationally expensive for market data resolution.  Therefore, heuristically, rule groups should be kept as small as possible.")
+    __properties = ["marketRules", "suppliers", "options", "specificRules", "groupedMarketRules"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
 
     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, MarketContext):
-            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, MarketContext):
-            return True
-
-        return self.to_dict() != other.to_dict()
+    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) -> MarketContext:
+        """Create an instance of MarketContext 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 market_rules (list)
+        _items = []
+        if self.market_rules:
+            for _item in self.market_rules:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['marketRules'] = _items
+        # override the default output from pydantic by calling `to_dict()` of suppliers
+        if self.suppliers:
+            _dict['suppliers'] = self.suppliers.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of options
+        if self.options:
+            _dict['options'] = self.options.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in specific_rules (list)
+        _items = []
+        if self.specific_rules:
+            for _item in self.specific_rules:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['specificRules'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in grouped_market_rules (list)
+        _items = []
+        if self.grouped_market_rules:
+            for _item in self.grouped_market_rules:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['groupedMarketRules'] = _items
+        # set to None if market_rules (nullable) is None
+        # and __fields_set__ contains the field
+        if self.market_rules is None and "market_rules" in self.__fields_set__:
+            _dict['marketRules'] = None
+
+        # set to None if suppliers (nullable) is None
+        # and __fields_set__ contains the field
+        if self.suppliers is None and "suppliers" in self.__fields_set__:
+            _dict['suppliers'] = None
+
+        # set to None if specific_rules (nullable) is None
+        # and __fields_set__ contains the field
+        if self.specific_rules is None and "specific_rules" in self.__fields_set__:
+            _dict['specificRules'] = None
+
+        # set to None if grouped_market_rules (nullable) is None
+        # and __fields_set__ contains the field
+        if self.grouped_market_rules is None and "grouped_market_rules" in self.__fields_set__:
+            _dict['groupedMarketRules'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> MarketContext:
+        """Create an instance of MarketContext from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return MarketContext.parse_obj(obj)
+
+        _obj = MarketContext.parse_obj({
+            "market_rules": [MarketDataKeyRule.from_dict(_item) for _item in obj.get("marketRules")] if obj.get("marketRules") is not None else None,
+            "suppliers": MarketContextSuppliers.from_dict(obj.get("suppliers")) if obj.get("suppliers") is not None else None,
+            "options": MarketOptions.from_dict(obj.get("options")) if obj.get("options") is not None else None,
+            "specific_rules": [MarketDataSpecificRule.from_dict(_item) for _item in obj.get("specificRules")] if obj.get("specificRules") is not None else None,
+            "grouped_market_rules": [GroupOfMarketDataKeyRules.from_dict(_item) for _item in obj.get("groupedMarketRules")] if obj.get("groupedMarketRules") is not None else None
+        })
+        return _obj