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

lusid/models/stock_dividend_event.py

@@ -18,8 +18,8 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from typing import Any, Dict, Optional
-from pydantic.v1 import Field, StrictStr, validator
+from typing import Any, Dict, Optional, Union
+from pydantic.v1 import Field, StrictFloat, StrictInt, StrictStr, validator
 from lusid.models.instrument_event import InstrumentEvent
 from lusid.models.units_ratio import UnitsRatio
 
@@ -31,10 +31,12 @@ class StockDividendEvent(InstrumentEvent):
     ex_date: datetime = Field(..., alias="exDate", description="The first business day on which the dividend is not owed to the buying party.  Typically this is T-1 from the RecordDate.")
     payment_date: datetime = Field(..., alias="paymentDate", description="The date the company pays out dividends to shareholders.")
     record_date: Optional[datetime] = Field(None, alias="recordDate", description="Date you have to be the holder of record in order to participate in the tender.")
+    fractional_units_cash_price: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="fractionalUnitsCashPrice", description="The cash price paid in lieu of fractionalUnits.")
+    fractional_units_cash_currency: Optional[StrictStr] = Field(None, alias="fractionalUnitsCashCurrency", description="The currency of the cash paid in lieu of fractionalUnits.")
     units_ratio: UnitsRatio = Field(..., alias="unitsRatio")
     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", "announcementDate", "exDate", "paymentDate", "recordDate", "unitsRatio"]
+    __properties = ["instrumentEventType", "announcementDate", "exDate", "paymentDate", "recordDate", "fractionalUnitsCashPrice", "fractionalUnitsCashCurrency", "unitsRatio"]
 
     @validator('instrument_event_type')
     def instrument_event_type_validate_enum(cls, value):
@@ -86,6 +88,16 @@ class StockDividendEvent(InstrumentEvent):
         if self.record_date is None and "record_date" in self.__fields_set__:
             _dict['recordDate'] = None
 
+        # set to None if fractional_units_cash_price (nullable) is None
+        # and __fields_set__ contains the field
+        if self.fractional_units_cash_price is None and "fractional_units_cash_price" in self.__fields_set__:
+            _dict['fractionalUnitsCashPrice'] = None
+
+        # set to None if fractional_units_cash_currency (nullable) is None
+        # and __fields_set__ contains the field
+        if self.fractional_units_cash_currency is None and "fractional_units_cash_currency" in self.__fields_set__:
+            _dict['fractionalUnitsCashCurrency'] = None
+
         return _dict
 
     @classmethod
@@ -103,6 +115,8 @@ class StockDividendEvent(InstrumentEvent):
             "ex_date": obj.get("exDate"),
             "payment_date": obj.get("paymentDate"),
             "record_date": obj.get("recordDate"),
+            "fractional_units_cash_price": obj.get("fractionalUnitsCashPrice"),
+            "fractional_units_cash_currency": obj.get("fractionalUnitsCashCurrency"),
             "units_ratio": UnitsRatio.from_dict(obj.get("unitsRatio")) if obj.get("unitsRatio") is not None else None
         })
         # store additional fields in additional_properties

lusid/models/string_list.py

@@ -27,15 +27,15 @@ class StringList(ReferenceList):
     StringList
     """
     values: conlist(StrictStr, max_items=100, min_items=0) = Field(...)
-    reference_list_type: StrictStr = Field(..., alias="referenceListType", description="The reference list values. The available values are: PortfolioGroupIdList, PortfolioIdList, AddressKeyList, StringList, InstrumentList, DecimalList, PropertyList")
+    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'):
-            raise ValueError("must be one of enum values ('PortfolioGroupIdList', 'PortfolioIdList', 'AddressKeyList', 'StringList', 'InstrumentList', 'DecimalList', 'PropertyList')")
+        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:

lusid/models/transaction.py

@@ -53,7 +53,8 @@ class Transaction(BaseModel):
     order_id: Optional[ResourceId] = Field(None, alias="orderId")
     allocation_id: Optional[ResourceId] = Field(None, alias="allocationId")
     custodian_account: Optional[CustodianAccount] = Field(None, alias="custodianAccount")
-    __properties = ["transactionId", "type", "instrumentIdentifiers", "instrumentScope", "instrumentUid", "transactionDate", "settlementDate", "units", "transactionPrice", "totalConsideration", "exchangeRate", "transactionCurrency", "properties", "counterpartyId", "source", "entryDateTime", "otcConfirmation", "transactionStatus", "cancelDateTime", "orderId", "allocationId", "custodianAccount"]
+    transaction_group_id: Optional[StrictStr] = Field(None, alias="transactionGroupId", description="The identifier for grouping economic events across multiple transactions")
+    __properties = ["transactionId", "type", "instrumentIdentifiers", "instrumentScope", "instrumentUid", "transactionDate", "settlementDate", "units", "transactionPrice", "totalConsideration", "exchangeRate", "transactionCurrency", "properties", "counterpartyId", "source", "entryDateTime", "otcConfirmation", "transactionStatus", "cancelDateTime", "orderId", "allocationId", "custodianAccount", "transactionGroupId"]
 
     @validator('transaction_status')
     def transaction_status_validate_enum(cls, value):
@@ -154,6 +155,11 @@ class Transaction(BaseModel):
         if self.cancel_date_time is None and "cancel_date_time" in self.__fields_set__:
             _dict['cancelDateTime'] = None
 
+        # set to None if transaction_group_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.transaction_group_id is None and "transaction_group_id" in self.__fields_set__:
+            _dict['transactionGroupId'] = None
+
         return _dict
 
     @classmethod
@@ -192,6 +198,7 @@ class Transaction(BaseModel):
             "cancel_date_time": obj.get("cancelDateTime"),
             "order_id": ResourceId.from_dict(obj.get("orderId")) if obj.get("orderId") is not None else None,
             "allocation_id": ResourceId.from_dict(obj.get("allocationId")) if obj.get("allocationId") is not None else None,
-            "custodian_account": CustodianAccount.from_dict(obj.get("custodianAccount")) if obj.get("custodianAccount") is not None else None
+            "custodian_account": CustodianAccount.from_dict(obj.get("custodianAccount")) if obj.get("custodianAccount") is not None else None,
+            "transaction_group_id": obj.get("transactionGroupId")
         })
         return _obj

lusid/models/transaction_date_windows.py

@@ -0,0 +1,85 @@
+# 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, validator
+
+class TransactionDateWindows(BaseModel):
+    """
+    TransactionDateWindows
+    """
+    left: constr(strict=True, max_length=30, min_length=2) = Field(..., description="Transaction Date Window for the left side of a reconciliation")
+    right: constr(strict=True, max_length=30, min_length=2) = Field(..., description="Transaction Date Window for the right side of a reconciliation")
+    __properties = ["left", "right"]
+
+    @validator('left')
+    def left_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^P(?!$)((\d+Y)|(\d+\.\d+Y$))?((\d+M)|(\d+\.\d+M$))?((\d+W)|(\d+\.\d+W$))?((\d+D)|(\d+\.\d+D$))?(T(?=\d)((\d+H)|(\d+\.\d+H$))?((\d+M)|(\d+\.\d+M$))?(\d+(\.\d+)?S)?)??$", value):
+            raise ValueError(r"must validate the regular expression /^P(?!$)((\d+Y)|(\d+\.\d+Y$))?((\d+M)|(\d+\.\d+M$))?((\d+W)|(\d+\.\d+W$))?((\d+D)|(\d+\.\d+D$))?(T(?=\d)((\d+H)|(\d+\.\d+H$))?((\d+M)|(\d+\.\d+M$))?(\d+(\.\d+)?S)?)??$/")
+        return value
+
+    @validator('right')
+    def right_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^P(?!$)((\d+Y)|(\d+\.\d+Y$))?((\d+M)|(\d+\.\d+M$))?((\d+W)|(\d+\.\d+W$))?((\d+D)|(\d+\.\d+D$))?(T(?=\d)((\d+H)|(\d+\.\d+H$))?((\d+M)|(\d+\.\d+M$))?(\d+(\.\d+)?S)?)??$", value):
+            raise ValueError(r"must validate the regular expression /^P(?!$)((\d+Y)|(\d+\.\d+Y$))?((\d+M)|(\d+\.\d+M$))?((\d+W)|(\d+\.\d+W$))?((\d+D)|(\d+\.\d+D$))?(T(?=\d)((\d+H)|(\d+\.\d+H$))?((\d+M)|(\d+\.\d+M$))?(\d+(\.\d+)?S)?)??$/")
+        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) -> TransactionDateWindows:
+        """Create an instance of TransactionDateWindows 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) -> TransactionDateWindows:
+        """Create an instance of TransactionDateWindows from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return TransactionDateWindows.parse_obj(obj)
+
+        _obj = TransactionDateWindows.parse_obj({
+            "left": obj.get("left"),
+            "right": obj.get("right")
+        })
+        return _obj

lusid/models/transaction_request.py

@@ -47,7 +47,8 @@ class TransactionRequest(BaseModel):
     order_id: Optional[ResourceId] = Field(None, alias="orderId")
     allocation_id: Optional[ResourceId] = Field(None, alias="allocationId")
     custodian_account_id: Optional[ResourceId] = Field(None, alias="custodianAccountId")
-    __properties = ["transactionId", "type", "instrumentIdentifiers", "transactionDate", "settlementDate", "units", "transactionPrice", "totalConsideration", "exchangeRate", "transactionCurrency", "properties", "counterpartyId", "source", "otcConfirmation", "orderId", "allocationId", "custodianAccountId"]
+    transaction_group_id: Optional[constr(strict=True, max_length=64, min_length=1)] = Field(None, alias="transactionGroupId", description="The identifier for grouping economic events across multiple transactions")
+    __properties = ["transactionId", "type", "instrumentIdentifiers", "transactionDate", "settlementDate", "units", "transactionPrice", "totalConsideration", "exchangeRate", "transactionCurrency", "properties", "counterpartyId", "source", "otcConfirmation", "orderId", "allocationId", "custodianAccountId", "transactionGroupId"]
 
     class Config:
         """Pydantic configuration"""
@@ -123,6 +124,11 @@ class TransactionRequest(BaseModel):
         if self.source is None and "source" in self.__fields_set__:
             _dict['source'] = None
 
+        # set to None if transaction_group_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.transaction_group_id is None and "transaction_group_id" in self.__fields_set__:
+            _dict['transactionGroupId'] = None
+
         return _dict
 
     @classmethod
@@ -156,6 +162,7 @@ class TransactionRequest(BaseModel):
             "otc_confirmation": OtcConfirmation.from_dict(obj.get("otcConfirmation")) if obj.get("otcConfirmation") is not None else None,
             "order_id": ResourceId.from_dict(obj.get("orderId")) if obj.get("orderId") is not None else None,
             "allocation_id": ResourceId.from_dict(obj.get("allocationId")) if obj.get("allocationId") is not None else None,
-            "custodian_account_id": ResourceId.from_dict(obj.get("custodianAccountId")) if obj.get("custodianAccountId") is not None else None
+            "custodian_account_id": ResourceId.from_dict(obj.get("custodianAccountId")) if obj.get("custodianAccountId") is not None else None,
+            "transaction_group_id": obj.get("transactionGroupId")
         })
         return _obj

lusid/models/update_group_reconciliation_comparison_ruleset_request.py

@@ -0,0 +1,91 @@
+# 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, constr
+from lusid.models.group_reconciliation_aggregate_attribute_rule import GroupReconciliationAggregateAttributeRule
+from lusid.models.group_reconciliation_core_attribute_rule import GroupReconciliationCoreAttributeRule
+
+class UpdateGroupReconciliationComparisonRulesetRequest(BaseModel):
+    """
+    UpdateGroupReconciliationComparisonRulesetRequest
+    """
+    display_name: constr(strict=True, max_length=256, 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, min_items=1) = Field(..., alias="coreAttributeRules", description="The core comparison rules")
+    aggregate_attribute_rules: conlist(GroupReconciliationAggregateAttributeRule, min_items=1) = Field(..., alias="aggregateAttributeRules", description="The aggregate comparison rules")
+    __properties = ["displayName", "reconciliationType", "coreAttributeRules", "aggregateAttributeRules"]
+
+    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) -> UpdateGroupReconciliationComparisonRulesetRequest:
+        """Create an instance of UpdateGroupReconciliationComparisonRulesetRequest 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 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
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> UpdateGroupReconciliationComparisonRulesetRequest:
+        """Create an instance of UpdateGroupReconciliationComparisonRulesetRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return UpdateGroupReconciliationComparisonRulesetRequest.parse_obj(obj)
+
+        _obj = UpdateGroupReconciliationComparisonRulesetRequest.parse_obj({
+            "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
+        })
+        return _obj

lusid/models/update_group_reconciliation_definition_request.py

@@ -0,0 +1,107 @@
+# 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, constr
+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.transaction_date_windows import TransactionDateWindows
+
+class UpdateGroupReconciliationDefinitionRequest(BaseModel):
+    """
+    UpdateGroupReconciliationDefinitionRequest
+    """
+    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="The name of the Group Reconciliation Definition")
+    description: constr(strict=True, min_length=1) = Field(..., description="The description of the Group Reconciliation Definition")
+    portfolio_entity_ids: GroupReconciliationDefinitionPortfolioEntityIds = Field(..., 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: BreakCodeSource = Field(..., alias="breakCodeSource")
+    __properties = ["displayName", "description", "portfolioEntityIds", "recipeIds", "currencies", "transactionDateWindows", "comparisonRulesetIds", "breakCodeSource"]
+
+    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) -> UpdateGroupReconciliationDefinitionRequest:
+        """Create an instance of UpdateGroupReconciliationDefinitionRequest 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 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()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> UpdateGroupReconciliationDefinitionRequest:
+        """Create an instance of UpdateGroupReconciliationDefinitionRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return UpdateGroupReconciliationDefinitionRequest.parse_obj(obj)
+
+        _obj = UpdateGroupReconciliationDefinitionRequest.parse_obj({
+            "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
+        })
+        return _obj

lusid/models/upsert_reference_portfolio_constituent_properties_request.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, StrictStr
+from lusid.models.perpetual_property import PerpetualProperty
+
+class UpsertReferencePortfolioConstituentPropertiesRequest(BaseModel):
+    """
+    UpsertReferencePortfolioConstituentPropertiesRequest
+    """
+    identifiers: Dict[str, StrictStr] = Field(..., description="A set of instrument identifiers that can resolve the constituent to a unique instrument.")
+    properties: Dict[str, PerpetualProperty] = Field(..., description="The updated collection of properties of the constituent.")
+    __properties = ["identifiers", "properties"]
+
+    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) -> UpsertReferencePortfolioConstituentPropertiesRequest:
+        """Create an instance of UpsertReferencePortfolioConstituentPropertiesRequest 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 value in properties (dict)
+        _field_dict = {}
+        if self.properties:
+            for _key in self.properties:
+                if self.properties[_key]:
+                    _field_dict[_key] = self.properties[_key].to_dict()
+            _dict['properties'] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> UpsertReferencePortfolioConstituentPropertiesRequest:
+        """Create an instance of UpsertReferencePortfolioConstituentPropertiesRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return UpsertReferencePortfolioConstituentPropertiesRequest.parse_obj(obj)
+
+        _obj = UpsertReferencePortfolioConstituentPropertiesRequest.parse_obj({
+            "identifiers": obj.get("identifiers"),
+            "properties": dict(
+                (_k, PerpetualProperty.from_dict(_v))
+                for _k, _v in obj.get("properties").items()
+            )
+            if obj.get("properties") is not None
+            else None
+        })
+        return _obj

lusid/models/upsert_reference_portfolio_constituent_properties_response.py

@@ -0,0 +1,115 @@
+# 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
+from lusid.models.link import Link
+from lusid.models.perpetual_property import PerpetualProperty
+from lusid.models.version import Version
+
+class UpsertReferencePortfolioConstituentPropertiesResponse(BaseModel):
+    """
+    UpsertReferencePortfolioConstituentPropertiesResponse
+    """
+    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: Optional[Dict[str, PerpetualProperty]] = Field(None, description="The updated collection of properties of the constituent.")
+    links: Optional[conlist(Link)] = None
+    __properties = ["href", "version", "properties", "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) -> UpsertReferencePortfolioConstituentPropertiesResponse:
+        """Create an instance of UpsertReferencePortfolioConstituentPropertiesResponse 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 version
+        if self.version:
+            _dict['version'] = self.version.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each value in properties (dict)
+        _field_dict = {}
+        if self.properties:
+            for _key in self.properties:
+                if self.properties[_key]:
+                    _field_dict[_key] = self.properties[_key].to_dict()
+            _dict['properties'] = _field_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 properties (nullable) is None
+        # and __fields_set__ contains the field
+        if self.properties is None and "properties" in self.__fields_set__:
+            _dict['properties'] = 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) -> UpsertReferencePortfolioConstituentPropertiesResponse:
+        """Create an instance of UpsertReferencePortfolioConstituentPropertiesResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return UpsertReferencePortfolioConstituentPropertiesResponse.parse_obj(obj)
+
+        _obj = UpsertReferencePortfolioConstituentPropertiesResponse.parse_obj({
+            "href": obj.get("href"),
+            "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None,
+            "properties": dict(
+                (_k, PerpetualProperty.from_dict(_v))
+                for _k, _v in obj.get("properties").items()
+            )
+            if obj.get("properties") 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