lusid-sdk 2.1.351__py3-none-any.whl → 2.1.405__py3-none-any.whl

lusid/models/futures_contract_details.py

@@ -29,7 +29,7 @@ class FuturesContractDetails(BaseModel):
     fgn_ccy: Optional[StrictStr] = Field(None, alias="fgnCcy", description="Currency of the underlying, for use with FX Futures")
     asset_class: Optional[StrictStr] = Field(None, alias="assetClass", description="The asset class of the underlying. Optional and will default to Unknown if not set.    Supported string (enumeration) values are: [InterestRates, FX, Inflation, Equities, Credit, Commodities, Money].")
     contract_code: constr(strict=True, min_length=1) = Field(..., alias="contractCode", description="The contract code used by the exchange, e.g. “CL” for Crude Oil, “ES” for E-mini SP 500, “FGBL” for Bund Futures, etc.")
-    contract_month: constr(strict=True, min_length=1) = Field(..., alias="contractMonth", description="Which month does the contract trade for.    Supported string (enumeration) values are: [F, G, H, J, K, M, N, Q, U, V, X, Z].")
+    contract_month: Optional[StrictStr] = Field(None, alias="contractMonth", description="Which month does the contract trade for.    Supported string (enumeration) values are: [F, G, H, J, K, M, N, Q, U, V, X, Z].")
     contract_size: Union[StrictFloat, StrictInt] = Field(..., alias="contractSize", description="Size of a single contract.")
     convention: Optional[StrictStr] = Field(None, description="If appropriate, the day count convention method used in pricing (rates futures).  For more information on day counts, see [knowledge base article KA-01798](https://support.lusid.com/knowledgebase/article/KA-01798)                Supported string (enumeration) values are: [Actual360, Act360, MoneyMarket, Actual365, Act365, Thirty360, ThirtyU360, Bond, ThirtyE360, EuroBond, ActualActual, ActAct, ActActIsda, ActActIsma, ActActIcma, OneOne, Act364, Act365F, Act365L, Act365_25, Act252, Bus252, NL360, NL365, ActActAFB, Act365Cad, ThirtyActIsda, Thirty365Isda, ThirtyEActIsda, ThirtyE360Isda, ThirtyE365Isda, ThirtyU360EOM].")
     country: Optional[StrictStr] = Field(None, description="Country (code) for the exchange.")
@@ -76,6 +76,11 @@ class FuturesContractDetails(BaseModel):
         if self.asset_class is None and "asset_class" in self.__fields_set__:
             _dict['assetClass'] = None
 
+        # set to None if contract_month (nullable) is None
+        # and __fields_set__ contains the field
+        if self.contract_month is None and "contract_month" in self.__fields_set__:
+            _dict['contractMonth'] = None
+
         # set to None if convention (nullable) is None
         # and __fields_set__ contains the field
         if self.convention is None and "convention" in self.__fields_set__:

lusid/models/fx_forward_settlement_event.py

@@ -37,15 +37,16 @@ class FxForwardSettlementEvent(InstrumentEvent):
     cash_flow_per_unit: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="cashFlowPerUnit", description="Optional.  Required if the event is an NDF (i.e. if IsNdf = true).  CashFlow per unit.  Paid in the SettlementCcy.")
     domestic_to_foreign_rate: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="domesticToForeignRate", description="Domestic currency to foreign currency FX rate.  Not required, only used to override quotes.")
     domestic_to_settlement_rate: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="domesticToSettlementRate", description="Domestic currency to settlement currency FX rate  Not required, only used to override quotes.")
-    instrument_event_type: StrictStr = Field(..., alias="instrumentEventType", description="The Type of Event. The available values are: TransitionEvent, InformationalEvent, OpenEvent, CloseEvent, StockSplitEvent, BondDefaultEvent, CashDividendEvent, AmortisationEvent, CashFlowEvent, ExerciseEvent, ResetEvent, TriggerEvent, RawVendorEvent, InformationalErrorEvent, BondCouponEvent, DividendReinvestmentEvent, AccumulationEvent, BondPrincipalEvent, DividendOptionEvent, MaturityEvent, FxForwardSettlementEvent, ExpiryEvent, ScripDividendEvent, StockDividendEvent, ReverseStockSplitEvent, CapitalDistributionEvent, SpinOffEvent, MergerEvent, FutureExpiryEvent")
+    foreign_to_settlement_rate: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="foreignToSettlementRate", description="Foreign currency to settlement currency FX rate  Not required, only used to override quotes.")
+    instrument_event_type: StrictStr = Field(..., alias="instrumentEventType", description="The Type of Event. The available values are: TransitionEvent, InformationalEvent, OpenEvent, CloseEvent, StockSplitEvent, BondDefaultEvent, CashDividendEvent, AmortisationEvent, CashFlowEvent, ExerciseEvent, ResetEvent, TriggerEvent, RawVendorEvent, InformationalErrorEvent, BondCouponEvent, DividendReinvestmentEvent, AccumulationEvent, BondPrincipalEvent, DividendOptionEvent, MaturityEvent, FxForwardSettlementEvent, ExpiryEvent, ScripDividendEvent, StockDividendEvent, ReverseStockSplitEvent, CapitalDistributionEvent, SpinOffEvent, MergerEvent, FutureExpiryEvent, SwapCashFlowEvent, SwapPrincipalEvent, CreditPremiumCashFlowEvent, CdsCreditEvent, CdxCreditEvent")
     additional_properties: Dict[str, Any] = {}
-    __properties = ["instrumentEventType", "maturityDate", "domAmountPerUnit", "domCcy", "fgnAmountPerUnit", "fgnCcy", "isNdf", "fixingDate", "settlementCcy", "cashFlowPerUnit", "domesticToForeignRate", "domesticToSettlementRate"]
+    __properties = ["instrumentEventType", "maturityDate", "domAmountPerUnit", "domCcy", "fgnAmountPerUnit", "fgnCcy", "isNdf", "fixingDate", "settlementCcy", "cashFlowPerUnit", "domesticToForeignRate", "domesticToSettlementRate", "foreignToSettlementRate"]
 
     @validator('instrument_event_type')
     def instrument_event_type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in ('TransitionEvent', 'InformationalEvent', 'OpenEvent', 'CloseEvent', 'StockSplitEvent', 'BondDefaultEvent', 'CashDividendEvent', 'AmortisationEvent', 'CashFlowEvent', 'ExerciseEvent', 'ResetEvent', 'TriggerEvent', 'RawVendorEvent', 'InformationalErrorEvent', 'BondCouponEvent', 'DividendReinvestmentEvent', 'AccumulationEvent', 'BondPrincipalEvent', 'DividendOptionEvent', 'MaturityEvent', 'FxForwardSettlementEvent', 'ExpiryEvent', 'ScripDividendEvent', 'StockDividendEvent', 'ReverseStockSplitEvent', 'CapitalDistributionEvent', 'SpinOffEvent', 'MergerEvent', 'FutureExpiryEvent'):
-            raise ValueError("must be one of enum values ('TransitionEvent', 'InformationalEvent', 'OpenEvent', 'CloseEvent', 'StockSplitEvent', 'BondDefaultEvent', 'CashDividendEvent', 'AmortisationEvent', 'CashFlowEvent', 'ExerciseEvent', 'ResetEvent', 'TriggerEvent', 'RawVendorEvent', 'InformationalErrorEvent', 'BondCouponEvent', 'DividendReinvestmentEvent', 'AccumulationEvent', 'BondPrincipalEvent', 'DividendOptionEvent', 'MaturityEvent', 'FxForwardSettlementEvent', 'ExpiryEvent', 'ScripDividendEvent', 'StockDividendEvent', 'ReverseStockSplitEvent', 'CapitalDistributionEvent', 'SpinOffEvent', 'MergerEvent', 'FutureExpiryEvent')")
+        if value not in ('TransitionEvent', 'InformationalEvent', 'OpenEvent', 'CloseEvent', 'StockSplitEvent', 'BondDefaultEvent', 'CashDividendEvent', 'AmortisationEvent', 'CashFlowEvent', 'ExerciseEvent', 'ResetEvent', 'TriggerEvent', 'RawVendorEvent', 'InformationalErrorEvent', 'BondCouponEvent', 'DividendReinvestmentEvent', 'AccumulationEvent', 'BondPrincipalEvent', 'DividendOptionEvent', 'MaturityEvent', 'FxForwardSettlementEvent', 'ExpiryEvent', 'ScripDividendEvent', 'StockDividendEvent', 'ReverseStockSplitEvent', 'CapitalDistributionEvent', 'SpinOffEvent', 'MergerEvent', 'FutureExpiryEvent', 'SwapCashFlowEvent', 'SwapPrincipalEvent', 'CreditPremiumCashFlowEvent', 'CdsCreditEvent', 'CdxCreditEvent'):
+            raise ValueError("must be one of enum values ('TransitionEvent', 'InformationalEvent', 'OpenEvent', 'CloseEvent', 'StockSplitEvent', 'BondDefaultEvent', 'CashDividendEvent', 'AmortisationEvent', 'CashFlowEvent', 'ExerciseEvent', 'ResetEvent', 'TriggerEvent', 'RawVendorEvent', 'InformationalErrorEvent', 'BondCouponEvent', 'DividendReinvestmentEvent', 'AccumulationEvent', 'BondPrincipalEvent', 'DividendOptionEvent', 'MaturityEvent', 'FxForwardSettlementEvent', 'ExpiryEvent', 'ScripDividendEvent', 'StockDividendEvent', 'ReverseStockSplitEvent', 'CapitalDistributionEvent', 'SpinOffEvent', 'MergerEvent', 'FutureExpiryEvent', 'SwapCashFlowEvent', 'SwapPrincipalEvent', 'CreditPremiumCashFlowEvent', 'CdsCreditEvent', 'CdxCreditEvent')")
         return value
 
     class Config:
@@ -70,6 +71,7 @@ class FxForwardSettlementEvent(InstrumentEvent):
         """Returns the dictionary representation of the model using alias"""
         _dict = self.dict(by_alias=True,
                           exclude={
+                            "foreign_to_settlement_rate",
                             "additional_properties"
                           },
                           exclude_none=True)
@@ -103,6 +105,11 @@ class FxForwardSettlementEvent(InstrumentEvent):
         if self.domestic_to_settlement_rate is None and "domestic_to_settlement_rate" in self.__fields_set__:
             _dict['domesticToSettlementRate'] = None
 
+        # set to None if foreign_to_settlement_rate (nullable) is None
+        # and __fields_set__ contains the field
+        if self.foreign_to_settlement_rate is None and "foreign_to_settlement_rate" in self.__fields_set__:
+            _dict['foreignToSettlementRate'] = None
+
         return _dict
 
     @classmethod
@@ -126,7 +133,8 @@ class FxForwardSettlementEvent(InstrumentEvent):
             "settlement_ccy": obj.get("settlementCcy"),
             "cash_flow_per_unit": obj.get("cashFlowPerUnit"),
             "domestic_to_foreign_rate": obj.get("domesticToForeignRate"),
-            "domestic_to_settlement_rate": obj.get("domesticToSettlementRate")
+            "domestic_to_settlement_rate": obj.get("domesticToSettlementRate"),
+            "foreign_to_settlement_rate": obj.get("foreignToSettlementRate")
         })
         # store additional fields in additional_properties
         for _key in obj.keys():

lusid/models/generated_event_diagnostics.py

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, List
+from pydantic.v1 import BaseModel, Field, StrictStr, conlist, constr
+
+class GeneratedEventDiagnostics(BaseModel):
+    """
+    Represents a set of diagnostics per generatedEvent, where applicable.  # noqa: E501
+    """
+    instrument_event_id: constr(strict=True, min_length=1) = Field(..., alias="instrumentEventId")
+    type: constr(strict=True, min_length=1) = Field(...)
+    detail: constr(strict=True, min_length=1) = Field(...)
+    error_details: conlist(StrictStr) = Field(..., alias="errorDetails")
+    __properties = ["instrumentEventId", "type", "detail", "errorDetails"]
+
+    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) -> GeneratedEventDiagnostics:
+        """Create an instance of GeneratedEventDiagnostics 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)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GeneratedEventDiagnostics:
+        """Create an instance of GeneratedEventDiagnostics from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GeneratedEventDiagnostics.parse_obj(obj)
+
+        _obj = GeneratedEventDiagnostics.parse_obj({
+            "instrument_event_id": obj.get("instrumentEventId"),
+            "type": obj.get("type"),
+            "detail": obj.get("detail"),
+            "error_details": obj.get("errorDetails")
+        })
+        return _obj

lusid/models/group_reconciliation_aggregate_attribute_rule.py

@@ -0,0 +1,84 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict
+from pydantic.v1 import BaseModel, Field
+from lusid.models.group_reconciliation_aggregate_comparison_rule_operand import GroupReconciliationAggregateComparisonRuleOperand
+from lusid.models.group_reconciliation_comparison_rule_tolerance import GroupReconciliationComparisonRuleTolerance
+
+class GroupReconciliationAggregateAttributeRule(BaseModel):
+    """
+    GroupReconciliationAggregateAttributeRule
+    """
+    left: GroupReconciliationAggregateComparisonRuleOperand = Field(...)
+    right: GroupReconciliationAggregateComparisonRuleOperand = Field(...)
+    tolerance: GroupReconciliationComparisonRuleTolerance = Field(...)
+    __properties = ["left", "right", "tolerance"]
+
+    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) -> GroupReconciliationAggregateAttributeRule:
+        """Create an instance of GroupReconciliationAggregateAttributeRule 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 tolerance
+        if self.tolerance:
+            _dict['tolerance'] = self.tolerance.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationAggregateAttributeRule:
+        """Create an instance of GroupReconciliationAggregateAttributeRule from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationAggregateAttributeRule.parse_obj(obj)
+
+        _obj = GroupReconciliationAggregateAttributeRule.parse_obj({
+            "left": GroupReconciliationAggregateComparisonRuleOperand.from_dict(obj.get("left")) if obj.get("left") is not None else None,
+            "right": GroupReconciliationAggregateComparisonRuleOperand.from_dict(obj.get("right")) if obj.get("right") is not None else None,
+            "tolerance": GroupReconciliationComparisonRuleTolerance.from_dict(obj.get("tolerance")) if obj.get("tolerance") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_aggregate_comparison_rule_operand.py

@@ -0,0 +1,71 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict
+from pydantic.v1 import BaseModel, Field, constr
+
+class GroupReconciliationAggregateComparisonRuleOperand(BaseModel):
+    """
+    GroupReconciliationAggregateComparisonRuleOperand
+    """
+    key: constr(strict=True, max_length=256, min_length=1) = Field(..., description="The key of the value to compare")
+    operation: constr(strict=True, min_length=1) = Field(..., description="What to do with the value pointed to by the key, e.g. Sum. Only \"Value is allowed for core rules\"")
+    __properties = ["key", "operation"]
+
+    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) -> GroupReconciliationAggregateComparisonRuleOperand:
+        """Create an instance of GroupReconciliationAggregateComparisonRuleOperand 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)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationAggregateComparisonRuleOperand:
+        """Create an instance of GroupReconciliationAggregateComparisonRuleOperand from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationAggregateComparisonRuleOperand.parse_obj(obj)
+
+        _obj = GroupReconciliationAggregateComparisonRuleOperand.parse_obj({
+            "key": obj.get("key"),
+            "operation": obj.get("operation")
+        })
+        return _obj

lusid/models/group_reconciliation_comparison_rule_string_value_map.py

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict
+from pydantic.v1 import BaseModel, Field, constr
+
+class GroupReconciliationComparisonRuleStringValueMap(BaseModel):
+    """
+    GroupReconciliationComparisonRuleStringValueMap
+    """
+    left_value: constr(strict=True, max_length=256, min_length=1) = Field(..., alias="leftValue", description="The left string to map")
+    right_value: constr(strict=True, max_length=256, min_length=1) = Field(..., alias="rightValue", description="The right string to map")
+    direction: constr(strict=True, min_length=1) = Field(..., description="The direction to map. \"UniDirectional\" | \"BiDirectional\"")
+    __properties = ["leftValue", "rightValue", "direction"]
+
+    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) -> GroupReconciliationComparisonRuleStringValueMap:
+        """Create an instance of GroupReconciliationComparisonRuleStringValueMap 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)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationComparisonRuleStringValueMap:
+        """Create an instance of GroupReconciliationComparisonRuleStringValueMap from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationComparisonRuleStringValueMap.parse_obj(obj)
+
+        _obj = GroupReconciliationComparisonRuleStringValueMap.parse_obj({
+            "left_value": obj.get("leftValue"),
+            "right_value": obj.get("rightValue"),
+            "direction": obj.get("direction")
+        })
+        return _obj

lusid/models/group_reconciliation_comparison_rule_tolerance.py

@@ -0,0 +1,71 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, Union
+from pydantic.v1 import BaseModel, Field, StrictFloat, StrictInt, constr
+
+class GroupReconciliationComparisonRuleTolerance(BaseModel):
+    """
+    GroupReconciliationComparisonRuleTolerance
+    """
+    type: constr(strict=True, min_length=1) = Field(..., description="The type of tolerance to allow. \"Relative\" | \"Absolute\"")
+    value: Union[StrictFloat, StrictInt] = Field(..., description="The decimal value of how much tolerance to allow when comparing in relative (i.e percentage) or absolute terms depending on the ToleranceType specified")
+    __properties = ["type", "value"]
+
+    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) -> GroupReconciliationComparisonRuleTolerance:
+        """Create an instance of GroupReconciliationComparisonRuleTolerance 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)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationComparisonRuleTolerance:
+        """Create an instance of GroupReconciliationComparisonRuleTolerance from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationComparisonRuleTolerance.parse_obj(obj)
+
+        _obj = GroupReconciliationComparisonRuleTolerance.parse_obj({
+            "type": obj.get("type"),
+            "value": obj.get("value")
+        })
+        return _obj

lusid/models/group_reconciliation_comparison_ruleset.py

@@ -0,0 +1,125 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, List, Optional
+from pydantic.v1 import BaseModel, Field, StrictStr, conlist, constr
+from lusid.models.group_reconciliation_aggregate_attribute_rule import GroupReconciliationAggregateAttributeRule
+from lusid.models.group_reconciliation_core_attribute_rule import GroupReconciliationCoreAttributeRule
+from lusid.models.link import Link
+from lusid.models.resource_id import ResourceId
+from lusid.models.version import Version
+
+class GroupReconciliationComparisonRuleset(BaseModel):
+    """
+    GroupReconciliationComparisonRuleset
+    """
+    id: ResourceId = Field(...)
+    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="The name of the ruleset")
+    reconciliation_type: constr(strict=True, min_length=1) = Field(..., alias="reconciliationType", description="The type of reconciliation to perform. \"Holding\" | \"Transaction\" | \"Valuation\"")
+    core_attribute_rules: conlist(GroupReconciliationCoreAttributeRule) = Field(..., alias="coreAttributeRules", description="The core comparison rules")
+    aggregate_attribute_rules: conlist(GroupReconciliationAggregateAttributeRule) = Field(..., alias="aggregateAttributeRules", description="The aggregate comparison rules")
+    href: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.")
+    version: Optional[Version] = None
+    links: Optional[conlist(Link)] = None
+    __properties = ["id", "displayName", "reconciliationType", "coreAttributeRules", "aggregateAttributeRules", "href", "version", "links"]
+
+    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) -> GroupReconciliationComparisonRuleset:
+        """Create an instance of GroupReconciliationComparisonRuleset 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 id
+        if self.id:
+            _dict['id'] = self.id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in core_attribute_rules (list)
+        _items = []
+        if self.core_attribute_rules:
+            for _item in self.core_attribute_rules:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['coreAttributeRules'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in aggregate_attribute_rules (list)
+        _items = []
+        if self.aggregate_attribute_rules:
+            for _item in self.aggregate_attribute_rules:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['aggregateAttributeRules'] = _items
+        # override the default output from pydantic by calling `to_dict()` of version
+        if self.version:
+            _dict['version'] = self.version.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in links (list)
+        _items = []
+        if self.links:
+            for _item in self.links:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['links'] = _items
+        # set to None if href (nullable) is None
+        # and __fields_set__ contains the field
+        if self.href is None and "href" in self.__fields_set__:
+            _dict['href'] = None
+
+        # set to None if links (nullable) is None
+        # and __fields_set__ contains the field
+        if self.links is None and "links" in self.__fields_set__:
+            _dict['links'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationComparisonRuleset:
+        """Create an instance of GroupReconciliationComparisonRuleset from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationComparisonRuleset.parse_obj(obj)
+
+        _obj = GroupReconciliationComparisonRuleset.parse_obj({
+            "id": ResourceId.from_dict(obj.get("id")) if obj.get("id") is not None else None,
+            "display_name": obj.get("displayName"),
+            "reconciliation_type": obj.get("reconciliationType"),
+            "core_attribute_rules": [GroupReconciliationCoreAttributeRule.from_dict(_item) for _item in obj.get("coreAttributeRules")] if obj.get("coreAttributeRules") is not None else None,
+            "aggregate_attribute_rules": [GroupReconciliationAggregateAttributeRule.from_dict(_item) for _item in obj.get("aggregateAttributeRules")] if obj.get("aggregateAttributeRules") is not None else None,
+            "href": obj.get("href"),
+            "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None,
+            "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
+        })
+        return _obj