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

lusid/models/fund_id_list.py

@@ -0,0 +1,99 @@
+# 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 Field, StrictStr, conlist, validator
+from lusid.models.reference_list import ReferenceList
+from lusid.models.resource_id import ResourceId
+
+class FundIdList(ReferenceList):
+    """
+    FundIdList
+    """
+    values: conlist(ResourceId, max_items=100) = Field(...)
+    reference_list_type: StrictStr = Field(..., alias="referenceListType", description="The reference list values. The available values are: PortfolioGroupIdList, PortfolioIdList, AddressKeyList, StringList, InstrumentList, DecimalList, PropertyList, FundIdList")
+    additional_properties: Dict[str, Any] = {}
+    __properties = ["referenceListType", "values"]
+
+    @validator('reference_list_type')
+    def reference_list_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in ('PortfolioGroupIdList', 'PortfolioIdList', 'AddressKeyList', 'StringList', 'InstrumentList', 'DecimalList', 'PropertyList', 'FundIdList'):
+            raise ValueError("must be one of enum values ('PortfolioGroupIdList', 'PortfolioIdList', 'AddressKeyList', 'StringList', 'InstrumentList', 'DecimalList', 'PropertyList', 'FundIdList')")
+        return 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) -> FundIdList:
+        """Create an instance of FundIdList 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={
+                            "additional_properties"
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in values (list)
+        _items = []
+        if self.values:
+            for _item in self.values:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['values'] = _items
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> FundIdList:
+        """Create an instance of FundIdList from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return FundIdList.parse_obj(obj)
+
+        _obj = FundIdList.parse_obj({
+            "reference_list_type": obj.get("referenceListType"),
+            "values": [ResourceId.from_dict(_item) for _item in obj.get("values")] if obj.get("values") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj

lusid/models/group_reconciliation_aggregate_attribute_rule.py

@@ -18,7 +18,7 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 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
@@ -29,7 +29,7 @@ class GroupReconciliationAggregateAttributeRule(BaseModel):
     """
     left: GroupReconciliationAggregateComparisonRuleOperand = Field(...)
     right: GroupReconciliationAggregateComparisonRuleOperand = Field(...)
-    tolerance: GroupReconciliationComparisonRuleTolerance = Field(...)
+    tolerance: Optional[GroupReconciliationComparisonRuleTolerance] = None
     __properties = ["left", "right", "tolerance"]
 
     class Config:

lusid/models/group_reconciliation_aggregate_comparison_rule_operand.py

@@ -25,7 +25,7 @@ class GroupReconciliationAggregateComparisonRuleOperand(BaseModel):
     """
     GroupReconciliationAggregateComparisonRuleOperand
     """
-    key: constr(strict=True, max_length=256, min_length=1) = Field(..., description="The key of the value to compare")
+    key: constr(strict=True, max_length=1024, min_length=0) = 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"]
 

lusid/models/group_reconciliation_core_comparison_rule_operand.py

@@ -25,7 +25,7 @@ class GroupReconciliationCoreComparisonRuleOperand(BaseModel):
     """
     GroupReconciliationCoreComparisonRuleOperand
     """
-    key: constr(strict=True, max_length=256, min_length=1) = Field(..., description="The key of the value to compare")
+    key: constr(strict=True, max_length=1024, min_length=0) = 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"]
 

lusid/models/group_reconciliation_definition.py

@@ -0,0 +1,136 @@
+# 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, Optional
+from pydantic.v1 import BaseModel, Field, StrictStr
+from lusid.models.break_code_source import BreakCodeSource
+from lusid.models.group_reconciliation_definition_comparison_ruleset_ids import GroupReconciliationDefinitionComparisonRulesetIds
+from lusid.models.group_reconciliation_definition_currencies import GroupReconciliationDefinitionCurrencies
+from lusid.models.group_reconciliation_definition_portfolio_entity_ids import GroupReconciliationDefinitionPortfolioEntityIds
+from lusid.models.group_reconciliation_definition_recipe_ids import GroupReconciliationDefinitionRecipeIds
+from lusid.models.resource_id import ResourceId
+from lusid.models.transaction_date_windows import TransactionDateWindows
+from lusid.models.version import Version
+
+class GroupReconciliationDefinition(BaseModel):
+    """
+    GroupReconciliationDefinition
+    """
+    id: Optional[ResourceId] = None
+    display_name: Optional[StrictStr] = Field(None, alias="displayName", description="The name of the Group Reconciliation Definition")
+    description: Optional[StrictStr] = Field(None, description="The description of the Group Reconciliation Definition")
+    portfolio_entity_ids: Optional[GroupReconciliationDefinitionPortfolioEntityIds] = Field(None, alias="portfolioEntityIds")
+    recipe_ids: Optional[GroupReconciliationDefinitionRecipeIds] = Field(None, alias="recipeIds")
+    currencies: Optional[GroupReconciliationDefinitionCurrencies] = None
+    transaction_date_windows: Optional[TransactionDateWindows] = Field(None, alias="transactionDateWindows")
+    comparison_ruleset_ids: Optional[GroupReconciliationDefinitionComparisonRulesetIds] = Field(None, alias="comparisonRulesetIds")
+    break_code_source: Optional[BreakCodeSource] = Field(None, alias="breakCodeSource")
+    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
+    __properties = ["id", "displayName", "description", "portfolioEntityIds", "recipeIds", "currencies", "transactionDateWindows", "comparisonRulesetIds", "breakCodeSource", "href", "version"]
+
+    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) -> GroupReconciliationDefinition:
+        """Create an instance of GroupReconciliationDefinition 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 portfolio_entity_ids
+        if self.portfolio_entity_ids:
+            _dict['portfolioEntityIds'] = self.portfolio_entity_ids.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of recipe_ids
+        if self.recipe_ids:
+            _dict['recipeIds'] = self.recipe_ids.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of currencies
+        if self.currencies:
+            _dict['currencies'] = self.currencies.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of transaction_date_windows
+        if self.transaction_date_windows:
+            _dict['transactionDateWindows'] = self.transaction_date_windows.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of comparison_ruleset_ids
+        if self.comparison_ruleset_ids:
+            _dict['comparisonRulesetIds'] = self.comparison_ruleset_ids.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of break_code_source
+        if self.break_code_source:
+            _dict['breakCodeSource'] = self.break_code_source.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of version
+        if self.version:
+            _dict['version'] = self.version.to_dict()
+        # set to None if display_name (nullable) is None
+        # and __fields_set__ contains the field
+        if self.display_name is None and "display_name" in self.__fields_set__:
+            _dict['displayName'] = None
+
+        # set to None if description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = None
+
+        # 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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationDefinition:
+        """Create an instance of GroupReconciliationDefinition from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationDefinition.parse_obj(obj)
+
+        _obj = GroupReconciliationDefinition.parse_obj({
+            "id": ResourceId.from_dict(obj.get("id")) if obj.get("id") is not None else None,
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "portfolio_entity_ids": GroupReconciliationDefinitionPortfolioEntityIds.from_dict(obj.get("portfolioEntityIds")) if obj.get("portfolioEntityIds") is not None else None,
+            "recipe_ids": GroupReconciliationDefinitionRecipeIds.from_dict(obj.get("recipeIds")) if obj.get("recipeIds") is not None else None,
+            "currencies": GroupReconciliationDefinitionCurrencies.from_dict(obj.get("currencies")) if obj.get("currencies") is not None else None,
+            "transaction_date_windows": TransactionDateWindows.from_dict(obj.get("transactionDateWindows")) if obj.get("transactionDateWindows") is not None else None,
+            "comparison_ruleset_ids": GroupReconciliationDefinitionComparisonRulesetIds.from_dict(obj.get("comparisonRulesetIds")) if obj.get("comparisonRulesetIds") is not None else None,
+            "break_code_source": BreakCodeSource.from_dict(obj.get("breakCodeSource")) if obj.get("breakCodeSource") 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
+        })
+        return _obj

lusid/models/group_reconciliation_definition_comparison_ruleset_ids.py

@@ -0,0 +1,83 @@
+# 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, Optional
+from pydantic.v1 import BaseModel, Field
+from lusid.models.resource_id import ResourceId
+
+class GroupReconciliationDefinitionComparisonRulesetIds(BaseModel):
+    """
+    GroupReconciliationDefinitionComparisonRulesetIds
+    """
+    transaction_reconciliation: Optional[ResourceId] = Field(None, alias="transactionReconciliation")
+    holding_reconciliation: Optional[ResourceId] = Field(None, alias="holdingReconciliation")
+    valuation_reconciliation: Optional[ResourceId] = Field(None, alias="valuationReconciliation")
+    __properties = ["transactionReconciliation", "holdingReconciliation", "valuationReconciliation"]
+
+    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) -> GroupReconciliationDefinitionComparisonRulesetIds:
+        """Create an instance of GroupReconciliationDefinitionComparisonRulesetIds 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 transaction_reconciliation
+        if self.transaction_reconciliation:
+            _dict['transactionReconciliation'] = self.transaction_reconciliation.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of holding_reconciliation
+        if self.holding_reconciliation:
+            _dict['holdingReconciliation'] = self.holding_reconciliation.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of valuation_reconciliation
+        if self.valuation_reconciliation:
+            _dict['valuationReconciliation'] = self.valuation_reconciliation.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationDefinitionComparisonRulesetIds:
+        """Create an instance of GroupReconciliationDefinitionComparisonRulesetIds from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationDefinitionComparisonRulesetIds.parse_obj(obj)
+
+        _obj = GroupReconciliationDefinitionComparisonRulesetIds.parse_obj({
+            "transaction_reconciliation": ResourceId.from_dict(obj.get("transactionReconciliation")) if obj.get("transactionReconciliation") is not None else None,
+            "holding_reconciliation": ResourceId.from_dict(obj.get("holdingReconciliation")) if obj.get("holdingReconciliation") is not None else None,
+            "valuation_reconciliation": ResourceId.from_dict(obj.get("valuationReconciliation")) if obj.get("valuationReconciliation") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_definition_currencies.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 GroupReconciliationDefinitionCurrencies(BaseModel):
+    """
+    GroupReconciliationDefinitionCurrencies
+    """
+    left: constr(strict=True, max_length=3, min_length=0) = Field(..., description="Currency for the left side of a reconciliation")
+    right: constr(strict=True, max_length=3, min_length=0) = Field(..., description="Currency for the right side of a reconciliation")
+    __properties = ["left", "right"]
+
+    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) -> GroupReconciliationDefinitionCurrencies:
+        """Create an instance of GroupReconciliationDefinitionCurrencies 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) -> GroupReconciliationDefinitionCurrencies:
+        """Create an instance of GroupReconciliationDefinitionCurrencies from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationDefinitionCurrencies.parse_obj(obj)
+
+        _obj = GroupReconciliationDefinitionCurrencies.parse_obj({
+            "left": obj.get("left"),
+            "right": obj.get("right")
+        })
+        return _obj

lusid/models/group_reconciliation_definition_portfolio_entity_ids.py

@@ -0,0 +1,86 @@
+# 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, conlist
+from lusid.models.portfolio_entity_id import PortfolioEntityId
+
+class GroupReconciliationDefinitionPortfolioEntityIds(BaseModel):
+    """
+    GroupReconciliationDefinitionPortfolioEntityIds
+    """
+    left: conlist(PortfolioEntityId, min_items=1) = Field(..., description="Portfolio Entity Id of the left side of a reconciliation")
+    right: conlist(PortfolioEntityId, min_items=1) = Field(..., description="Portfolio Entity Id of the right side of a reconciliation")
+    __properties = ["left", "right"]
+
+    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) -> GroupReconciliationDefinitionPortfolioEntityIds:
+        """Create an instance of GroupReconciliationDefinitionPortfolioEntityIds 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 left (list)
+        _items = []
+        if self.left:
+            for _item in self.left:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['left'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in right (list)
+        _items = []
+        if self.right:
+            for _item in self.right:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['right'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationDefinitionPortfolioEntityIds:
+        """Create an instance of GroupReconciliationDefinitionPortfolioEntityIds from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationDefinitionPortfolioEntityIds.parse_obj(obj)
+
+        _obj = GroupReconciliationDefinitionPortfolioEntityIds.parse_obj({
+            "left": [PortfolioEntityId.from_dict(_item) for _item in obj.get("left")] if obj.get("left") is not None else None,
+            "right": [PortfolioEntityId.from_dict(_item) for _item in obj.get("right")] if obj.get("right") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_definition_recipe_ids.py

@@ -0,0 +1,78 @@
+# 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.resource_id import ResourceId
+
+class GroupReconciliationDefinitionRecipeIds(BaseModel):
+    """
+    GroupReconciliationDefinitionRecipeIds
+    """
+    left: ResourceId = Field(...)
+    right: ResourceId = Field(...)
+    __properties = ["left", "right"]
+
+    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) -> GroupReconciliationDefinitionRecipeIds:
+        """Create an instance of GroupReconciliationDefinitionRecipeIds 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()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationDefinitionRecipeIds:
+        """Create an instance of GroupReconciliationDefinitionRecipeIds from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationDefinitionRecipeIds.parse_obj(obj)
+
+        _obj = GroupReconciliationDefinitionRecipeIds.parse_obj({
+            "left": ResourceId.from_dict(obj.get("left")) if obj.get("left") is not None else None,
+            "right": ResourceId.from_dict(obj.get("right")) if obj.get("right") is not None else None
+        })
+        return _obj

lusid/models/instrument.py

@@ -25,6 +25,7 @@ from lusid.models.lusid_instrument import LusidInstrument
 from lusid.models.model_property import ModelProperty
 from lusid.models.relationship import Relationship
 from lusid.models.resource_id import ResourceId
+from lusid.models.settlement_cycle import SettlementCycle
 from lusid.models.staged_modifications_info import StagedModificationsInfo
 from lusid.models.version import Version
 
@@ -46,8 +47,9 @@ class Instrument(BaseModel):
     asset_class: Optional[StrictStr] = Field(None, alias="assetClass", description="The nominal asset class of the instrument, e.g. InterestRates, FX, Inflation, Equities, Credit, Commodities, etc. The available values are: InterestRates, FX, Inflation, Equities, Credit, Commodities, Money, Unknown")
     dom_ccy: Optional[StrictStr] = Field(None, alias="domCcy", description="The domestic currency, meaning the currency in which the instrument would typically be expected to pay cashflows, e.g. a share in AAPL being USD.")
     relationships: Optional[conlist(Relationship)] = Field(None, description="A set of relationships associated to the instrument.")
+    settlement_cycle: Optional[SettlementCycle] = Field(None, alias="settlementCycle")
     links: Optional[conlist(Link)] = None
-    __properties = ["href", "scope", "lusidInstrumentId", "version", "stagedModifications", "name", "identifiers", "properties", "lookthroughPortfolio", "instrumentDefinition", "state", "assetClass", "domCcy", "relationships", "links"]
+    __properties = ["href", "scope", "lusidInstrumentId", "version", "stagedModifications", "name", "identifiers", "properties", "lookthroughPortfolio", "instrumentDefinition", "state", "assetClass", "domCcy", "relationships", "settlementCycle", "links"]
 
     @validator('state')
     def state_validate_enum(cls, value):
@@ -116,6 +118,9 @@ class Instrument(BaseModel):
                 if _item:
                     _items.append(_item.to_dict())
             _dict['relationships'] = _items
+        # override the default output from pydantic by calling `to_dict()` of settlement_cycle
+        if self.settlement_cycle:
+            _dict['settlementCycle'] = self.settlement_cycle.to_dict()
         # override the default output from pydantic by calling `to_dict()` of each item in links (list)
         _items = []
         if self.links:
@@ -179,6 +184,7 @@ class Instrument(BaseModel):
             "asset_class": obj.get("assetClass"),
             "dom_ccy": obj.get("domCcy"),
             "relationships": [Relationship.from_dict(_item) for _item in obj.get("relationships")] if obj.get("relationships") is not None else None,
+            "settlement_cycle": SettlementCycle.from_dict(obj.get("settlementCycle")) if obj.get("settlementCycle") 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

lusid/models/instrument_definition.py

@@ -24,6 +24,7 @@ from lusid.models.instrument_id_value import InstrumentIdValue
 from lusid.models.lusid_instrument import LusidInstrument
 from lusid.models.model_property import ModelProperty
 from lusid.models.resource_id import ResourceId
+from lusid.models.settlement_cycle import SettlementCycle
 
 class InstrumentDefinition(BaseModel):
     """
@@ -34,7 +35,8 @@ class InstrumentDefinition(BaseModel):
     properties: Optional[conlist(ModelProperty)] = Field(None, description="Set of unique instrument properties and associated values to store with the instrument. Each property must be from the 'Instrument' domain.")
     look_through_portfolio_id: Optional[ResourceId] = Field(None, alias="lookThroughPortfolioId")
     definition: Optional[LusidInstrument] = None
-    __properties = ["name", "identifiers", "properties", "lookThroughPortfolioId", "definition"]
+    settlement_cycle: Optional[SettlementCycle] = Field(None, alias="settlementCycle")
+    __properties = ["name", "identifiers", "properties", "lookThroughPortfolioId", "definition", "settlementCycle"]
 
     class Config:
         """Pydantic configuration"""
@@ -80,6 +82,9 @@ class InstrumentDefinition(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of definition
         if self.definition:
             _dict['definition'] = self.definition.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of settlement_cycle
+        if self.settlement_cycle:
+            _dict['settlementCycle'] = self.settlement_cycle.to_dict()
         # set to None if properties (nullable) is None
         # and __fields_set__ contains the field
         if self.properties is None and "properties" in self.__fields_set__:
@@ -106,6 +111,7 @@ class InstrumentDefinition(BaseModel):
             else None,
             "properties": [ModelProperty.from_dict(_item) for _item in obj.get("properties")] if obj.get("properties") is not None else None,
             "look_through_portfolio_id": ResourceId.from_dict(obj.get("lookThroughPortfolioId")) if obj.get("lookThroughPortfolioId") is not None else None,
-            "definition": LusidInstrument.from_dict(obj.get("definition")) if obj.get("definition") is not None else None
+            "definition": LusidInstrument.from_dict(obj.get("definition")) if obj.get("definition") is not None else None,
+            "settlement_cycle": SettlementCycle.from_dict(obj.get("settlementCycle")) if obj.get("settlementCycle") is not None else None
         })
         return _obj