lusid-sdk 2.1.726__py3-none-any.whl → 2.1.728__py3-none-any.whl

lusid/api/instruments_api.py

@@ -76,22 +76,22 @@ class InstrumentsApi:
 
 
     @overload
-    async def batch_upsert_instrument_properties(self, request_body : Annotated[Dict[str, UpsertInstrumentPropertyRequest], Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, identifier_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve each instrument from the provided identifiers. Defaults to the current LUSID system datetime if not specified.")] = None, success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, **kwargs) -> BatchUpsertInstrumentPropertiesResponse:  # noqa: E501
+    async def batch_upsert_instrument_properties(self, request_body : Annotated[Dict[str, UpsertInstrumentPropertyRequest], Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, identifier_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve each instrument from the provided identifiers. Defaults to the current LUSID system datetime if not specified.")] = None, success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, **kwargs) -> BatchUpsertInstrumentPropertiesResponse:  # noqa: E501
         ...
 
     @overload
-    def batch_upsert_instrument_properties(self, request_body : Annotated[Dict[str, UpsertInstrumentPropertyRequest], Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, identifier_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve each instrument from the provided identifiers. Defaults to the current LUSID system datetime if not specified.")] = None, success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, async_req: Optional[bool]=True, **kwargs) -> BatchUpsertInstrumentPropertiesResponse:  # noqa: E501
+    def batch_upsert_instrument_properties(self, request_body : Annotated[Dict[str, UpsertInstrumentPropertyRequest], Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, identifier_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve each instrument from the provided identifiers. Defaults to the current LUSID system datetime if not specified.")] = None, success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, async_req: Optional[bool]=True, **kwargs) -> BatchUpsertInstrumentPropertiesResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def batch_upsert_instrument_properties(self, request_body : Annotated[Dict[str, UpsertInstrumentPropertyRequest], Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, identifier_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve each instrument from the provided identifiers. Defaults to the current LUSID system datetime if not specified.")] = None, success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpsertInstrumentPropertiesResponse, Awaitable[BatchUpsertInstrumentPropertiesResponse]]:  # noqa: E501
+    def batch_upsert_instrument_properties(self, request_body : Annotated[Dict[str, UpsertInstrumentPropertyRequest], Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, identifier_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve each instrument from the provided identifiers. Defaults to the current LUSID system datetime if not specified.")] = None, success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpsertInstrumentPropertiesResponse, Awaitable[BatchUpsertInstrumentPropertiesResponse]]:  # noqa: E501
         """BatchUpsertInstrumentProperties: Batch upsert instruments properties  # noqa: E501
 
         Create or update one or more properties for particular instruments.    Each instrument property is updated if it exists and created if it does not. For any failures, a reason  is provided.    Properties have an <i>effectiveFrom</i> datetime from which the property is valid, and an <i>effectiveUntil</i>  datetime until which the property is valid. Not supplying an <i>effectiveUntil</i> datetime results in the property being  valid indefinitely, or until the next <i>effectiveFrom</i> datetime of the property.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.batch_upsert_instrument_properties(request_body, scope, identifier_effective_at, success_mode, async_req=True)
+        >>> thread = api.batch_upsert_instrument_properties(request_body, scope, identifier_effective_at, success_mode, data_model_scope, data_model_code, async_req=True)
         >>> result = thread.get()
 
         :param request_body: A list of instruments and associated instrument properties to create or update. (required)
@@ -102,6 +102,10 @@ class InstrumentsApi:
         :type identifier_effective_at: str
         :param success_mode: Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.
         :type success_mode: str
+        :param data_model_scope: The optional scope of a Hierarchical Data Model to use
+        :type data_model_scope: str
+        :param data_model_code: The optional code of a Hierarchical Data Model to use
+        :type data_model_code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
@@ -118,17 +122,17 @@ class InstrumentsApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.batch_upsert_instrument_properties_with_http_info(request_body, scope, identifier_effective_at, success_mode, **kwargs)  # noqa: E501
+        return self.batch_upsert_instrument_properties_with_http_info(request_body, scope, identifier_effective_at, success_mode, data_model_scope, data_model_code, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def batch_upsert_instrument_properties_with_http_info(self, request_body : Annotated[Dict[str, UpsertInstrumentPropertyRequest], Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, identifier_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve each instrument from the provided identifiers. Defaults to the current LUSID system datetime if not specified.")] = None, success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def batch_upsert_instrument_properties_with_http_info(self, request_body : Annotated[Dict[str, UpsertInstrumentPropertyRequest], Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, identifier_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve each instrument from the provided identifiers. Defaults to the current LUSID system datetime if not specified.")] = None, success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """BatchUpsertInstrumentProperties: Batch upsert instruments properties  # noqa: E501
 
         Create or update one or more properties for particular instruments.    Each instrument property is updated if it exists and created if it does not. For any failures, a reason  is provided.    Properties have an <i>effectiveFrom</i> datetime from which the property is valid, and an <i>effectiveUntil</i>  datetime until which the property is valid. Not supplying an <i>effectiveUntil</i> datetime results in the property being  valid indefinitely, or until the next <i>effectiveFrom</i> datetime of the property.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.batch_upsert_instrument_properties_with_http_info(request_body, scope, identifier_effective_at, success_mode, async_req=True)
+        >>> thread = api.batch_upsert_instrument_properties_with_http_info(request_body, scope, identifier_effective_at, success_mode, data_model_scope, data_model_code, async_req=True)
         >>> result = thread.get()
 
         :param request_body: A list of instruments and associated instrument properties to create or update. (required)
@@ -139,6 +143,10 @@ class InstrumentsApi:
         :type identifier_effective_at: str
         :param success_mode: Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.
         :type success_mode: str
+        :param data_model_scope: The optional scope of a Hierarchical Data Model to use
+        :type data_model_scope: str
+        :param data_model_code: The optional code of a Hierarchical Data Model to use
+        :type data_model_code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -169,7 +177,9 @@ class InstrumentsApi:
             'request_body',
             'scope',
             'identifier_effective_at',
-            'success_mode'
+            'success_mode',
+            'data_model_scope',
+            'data_model_code'
         ]
         _all_params.extend(
             [
@@ -210,6 +220,12 @@ class InstrumentsApi:
         if _params.get('success_mode') is not None:  # noqa: E501
             _query_params.append(('successMode', _params['success_mode']))
 
+        if _params.get('data_model_scope') is not None:  # noqa: E501
+            _query_params.append(('dataModelScope', _params['data_model_scope']))
+
+        if _params.get('data_model_code') is not None:  # noqa: E501
+            _query_params.append(('dataModelCode', _params['data_model_code']))
+
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters
@@ -614,22 +630,22 @@ class InstrumentsApi:
 
 
     @overload
-    async def delete_instrument_properties(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], request_body : Annotated[conlist(StrictStr), Field(..., description="A list of property keys from the 'Instruments' domain whose properties to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, **kwargs) -> DeleteInstrumentPropertiesResponse:  # noqa: E501
+    async def delete_instrument_properties(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], request_body : Annotated[conlist(StrictStr), Field(..., description="A list of property keys from the 'Instruments' domain whose properties to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, **kwargs) -> DeleteInstrumentPropertiesResponse:  # noqa: E501
         ...
 
     @overload
-    def delete_instrument_properties(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], request_body : Annotated[conlist(StrictStr), Field(..., description="A list of property keys from the 'Instruments' domain whose properties to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=True, **kwargs) -> DeleteInstrumentPropertiesResponse:  # noqa: E501
+    def delete_instrument_properties(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], request_body : Annotated[conlist(StrictStr), Field(..., description="A list of property keys from the 'Instruments' domain whose properties to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, async_req: Optional[bool]=True, **kwargs) -> DeleteInstrumentPropertiesResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def delete_instrument_properties(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], request_body : Annotated[conlist(StrictStr), Field(..., description="A list of property keys from the 'Instruments' domain whose properties to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeleteInstrumentPropertiesResponse, Awaitable[DeleteInstrumentPropertiesResponse]]:  # noqa: E501
+    def delete_instrument_properties(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], request_body : Annotated[conlist(StrictStr), Field(..., description="A list of property keys from the 'Instruments' domain whose properties to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeleteInstrumentPropertiesResponse, Awaitable[DeleteInstrumentPropertiesResponse]]:  # noqa: E501
         """[EARLY ACCESS] DeleteInstrumentProperties: Delete instrument properties  # noqa: E501
 
         Delete one or more properties from a particular instrument. If the properties are time-variant then an effective datetime from which  to delete properties must be specified. If the properties are perpetual then it is invalid to specify an effective datetime for deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.delete_instrument_properties(identifier_type, identifier, request_body, effective_at, scope, async_req=True)
+        >>> thread = api.delete_instrument_properties(identifier_type, identifier, request_body, effective_at, scope, data_model_scope, data_model_code, async_req=True)
         >>> result = thread.get()
 
         :param identifier_type: The unique identifier type to search, for example 'Figi'. (required)
@@ -642,6 +658,10 @@ class InstrumentsApi:
         :type effective_at: str
         :param scope: The scope in which the instrument lies. When not supplied the scope is 'default'.
         :type scope: str
+        :param data_model_scope: The optional scope of a Hierarchical Data Model to use
+        :type data_model_scope: str
+        :param data_model_code: The optional code of a Hierarchical Data Model to use
+        :type data_model_code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
@@ -658,17 +678,17 @@ class InstrumentsApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.delete_instrument_properties_with_http_info(identifier_type, identifier, request_body, effective_at, scope, **kwargs)  # noqa: E501
+        return self.delete_instrument_properties_with_http_info(identifier_type, identifier, request_body, effective_at, scope, data_model_scope, data_model_code, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def delete_instrument_properties_with_http_info(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], request_body : Annotated[conlist(StrictStr), Field(..., description="A list of property keys from the 'Instruments' domain whose properties to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def delete_instrument_properties_with_http_info(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], request_body : Annotated[conlist(StrictStr), Field(..., description="A list of property keys from the 'Instruments' domain whose properties to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] DeleteInstrumentProperties: Delete instrument properties  # noqa: E501
 
         Delete one or more properties from a particular instrument. If the properties are time-variant then an effective datetime from which  to delete properties must be specified. If the properties are perpetual then it is invalid to specify an effective datetime for deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.delete_instrument_properties_with_http_info(identifier_type, identifier, request_body, effective_at, scope, async_req=True)
+        >>> thread = api.delete_instrument_properties_with_http_info(identifier_type, identifier, request_body, effective_at, scope, data_model_scope, data_model_code, async_req=True)
         >>> result = thread.get()
 
         :param identifier_type: The unique identifier type to search, for example 'Figi'. (required)
@@ -681,6 +701,10 @@ class InstrumentsApi:
         :type effective_at: str
         :param scope: The scope in which the instrument lies. When not supplied the scope is 'default'.
         :type scope: str
+        :param data_model_scope: The optional scope of a Hierarchical Data Model to use
+        :type data_model_scope: str
+        :param data_model_code: The optional code of a Hierarchical Data Model to use
+        :type data_model_code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -712,7 +736,9 @@ class InstrumentsApi:
             'identifier',
             'request_body',
             'effective_at',
-            'scope'
+            'scope',
+            'data_model_scope',
+            'data_model_code'
         ]
         _all_params.extend(
             [
@@ -756,6 +782,12 @@ class InstrumentsApi:
         if _params.get('scope') is not None:  # noqa: E501
             _query_params.append(('scope', _params['scope']))
 
+        if _params.get('data_model_scope') is not None:  # noqa: E501
+            _query_params.append(('dataModelScope', _params['data_model_scope']))
+
+        if _params.get('data_model_code') is not None:  # noqa: E501
+            _query_params.append(('dataModelCode', _params['data_model_code']))
+
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters
@@ -3511,22 +3543,22 @@ class InstrumentsApi:
 
 
     @overload
-    async def update_instrument_identifier(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], update_instrument_identifier_request : Annotated[UpdateInstrumentIdentifierRequest, Field(..., description="The identifier to update or delete. This need not be the same value as the               'identifier' parameter used to retrieve the instrument.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, **kwargs) -> Instrument:  # noqa: E501
+    async def update_instrument_identifier(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], update_instrument_identifier_request : Annotated[UpdateInstrumentIdentifierRequest, Field(..., description="The identifier to update or delete. This need not be the same value as the               'identifier' parameter used to retrieve the instrument.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, **kwargs) -> Instrument:  # noqa: E501
         ...
 
     @overload
-    def update_instrument_identifier(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], update_instrument_identifier_request : Annotated[UpdateInstrumentIdentifierRequest, Field(..., description="The identifier to update or delete. This need not be the same value as the               'identifier' parameter used to retrieve the instrument.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=True, **kwargs) -> Instrument:  # noqa: E501
+    def update_instrument_identifier(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], update_instrument_identifier_request : Annotated[UpdateInstrumentIdentifierRequest, Field(..., description="The identifier to update or delete. This need not be the same value as the               'identifier' parameter used to retrieve the instrument.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, async_req: Optional[bool]=True, **kwargs) -> Instrument:  # noqa: E501
         ...
 
     @validate_arguments
-    def update_instrument_identifier(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], update_instrument_identifier_request : Annotated[UpdateInstrumentIdentifierRequest, Field(..., description="The identifier to update or delete. This need not be the same value as the               'identifier' parameter used to retrieve the instrument.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Instrument, Awaitable[Instrument]]:  # noqa: E501
+    def update_instrument_identifier(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], update_instrument_identifier_request : Annotated[UpdateInstrumentIdentifierRequest, Field(..., description="The identifier to update or delete. This need not be the same value as the               'identifier' parameter used to retrieve the instrument.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Instrument, Awaitable[Instrument]]:  # noqa: E501
         """UpdateInstrumentIdentifier: Update instrument identifier  # noqa: E501
 
         Create, update or delete a particular instrument identifier for an instrument.                To delete the identifier, leave the value unspecified in the request. If not being deleted, the  identifier is updated if it exists and created if it does not.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.update_instrument_identifier(identifier_type, identifier, update_instrument_identifier_request, scope, async_req=True)
+        >>> thread = api.update_instrument_identifier(identifier_type, identifier, update_instrument_identifier_request, scope, data_model_scope, data_model_code, async_req=True)
         >>> result = thread.get()
 
         :param identifier_type: The unique identifier type to search, for example 'Figi'. (required)
@@ -3537,6 +3569,10 @@ class InstrumentsApi:
         :type update_instrument_identifier_request: UpdateInstrumentIdentifierRequest
         :param scope: The scope in which the instrument lies. When not supplied the scope is 'default'.
         :type scope: str
+        :param data_model_scope: The optional scope of a Hierarchical Data Model to use
+        :type data_model_scope: str
+        :param data_model_code: The optional code of a Hierarchical Data Model to use
+        :type data_model_code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
@@ -3553,17 +3589,17 @@ class InstrumentsApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.update_instrument_identifier_with_http_info(identifier_type, identifier, update_instrument_identifier_request, scope, **kwargs)  # noqa: E501
+        return self.update_instrument_identifier_with_http_info(identifier_type, identifier, update_instrument_identifier_request, scope, data_model_scope, data_model_code, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def update_instrument_identifier_with_http_info(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], update_instrument_identifier_request : Annotated[UpdateInstrumentIdentifierRequest, Field(..., description="The identifier to update or delete. This need not be the same value as the               'identifier' parameter used to retrieve the instrument.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def update_instrument_identifier_with_http_info(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], update_instrument_identifier_request : Annotated[UpdateInstrumentIdentifierRequest, Field(..., description="The identifier to update or delete. This need not be the same value as the               'identifier' parameter used to retrieve the instrument.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """UpdateInstrumentIdentifier: Update instrument identifier  # noqa: E501
 
         Create, update or delete a particular instrument identifier for an instrument.                To delete the identifier, leave the value unspecified in the request. If not being deleted, the  identifier is updated if it exists and created if it does not.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.update_instrument_identifier_with_http_info(identifier_type, identifier, update_instrument_identifier_request, scope, async_req=True)
+        >>> thread = api.update_instrument_identifier_with_http_info(identifier_type, identifier, update_instrument_identifier_request, scope, data_model_scope, data_model_code, async_req=True)
         >>> result = thread.get()
 
         :param identifier_type: The unique identifier type to search, for example 'Figi'. (required)
@@ -3574,6 +3610,10 @@ class InstrumentsApi:
         :type update_instrument_identifier_request: UpdateInstrumentIdentifierRequest
         :param scope: The scope in which the instrument lies. When not supplied the scope is 'default'.
         :type scope: str
+        :param data_model_scope: The optional scope of a Hierarchical Data Model to use
+        :type data_model_scope: str
+        :param data_model_code: The optional code of a Hierarchical Data Model to use
+        :type data_model_code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -3604,7 +3644,9 @@ class InstrumentsApi:
             'identifier_type',
             'identifier',
             'update_instrument_identifier_request',
-            'scope'
+            'scope',
+            'data_model_scope',
+            'data_model_code'
         ]
         _all_params.extend(
             [
@@ -3645,6 +3687,12 @@ class InstrumentsApi:
         if _params.get('scope') is not None:  # noqa: E501
             _query_params.append(('scope', _params['scope']))
 
+        if _params.get('data_model_scope') is not None:  # noqa: E501
+            _query_params.append(('dataModelScope', _params['data_model_scope']))
+
+        if _params.get('data_model_code') is not None:  # noqa: E501
+            _query_params.append(('dataModelCode', _params['data_model_code']))
+
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters
@@ -3877,28 +3925,32 @@ class InstrumentsApi:
 
 
     @overload
-    async def upsert_instruments_properties(self, upsert_instrument_property_request : Annotated[conlist(UpsertInstrumentPropertyRequest), Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, **kwargs) -> UpsertInstrumentPropertiesResponse:  # noqa: E501
+    async def upsert_instruments_properties(self, upsert_instrument_property_request : Annotated[conlist(UpsertInstrumentPropertyRequest), Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, **kwargs) -> UpsertInstrumentPropertiesResponse:  # noqa: E501
         ...
 
     @overload
-    def upsert_instruments_properties(self, upsert_instrument_property_request : Annotated[conlist(UpsertInstrumentPropertyRequest), Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=True, **kwargs) -> UpsertInstrumentPropertiesResponse:  # noqa: E501
+    def upsert_instruments_properties(self, upsert_instrument_property_request : Annotated[conlist(UpsertInstrumentPropertyRequest), Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, async_req: Optional[bool]=True, **kwargs) -> UpsertInstrumentPropertiesResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_instruments_properties(self, upsert_instrument_property_request : Annotated[conlist(UpsertInstrumentPropertyRequest), Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[UpsertInstrumentPropertiesResponse, Awaitable[UpsertInstrumentPropertiesResponse]]:  # noqa: E501
+    def upsert_instruments_properties(self, upsert_instrument_property_request : Annotated[conlist(UpsertInstrumentPropertyRequest), Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[UpsertInstrumentPropertiesResponse, Awaitable[UpsertInstrumentPropertiesResponse]]:  # noqa: E501
         """UpsertInstrumentsProperties: Upsert instruments properties  # noqa: E501
 
         Create or update one or more properties for particular instruments.                Each instrument property is updated if it exists and created if it does not. For any failures, a reason  is provided.                Properties have an <i>effectiveFrom</i> datetime from which the property is valid, and an <i>effectiveUntil</i>  datetime until which the property is valid. Not supplying an <i>effectiveUntil</i> datetime results in the property being  valid indefinitely, or until the next <i>effectiveFrom</i> datetime of the property.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.upsert_instruments_properties(upsert_instrument_property_request, scope, async_req=True)
+        >>> thread = api.upsert_instruments_properties(upsert_instrument_property_request, scope, data_model_scope, data_model_code, async_req=True)
         >>> result = thread.get()
 
         :param upsert_instrument_property_request: A list of instruments and associated instrument properties to create or update. (required)
         :type upsert_instrument_property_request: List[UpsertInstrumentPropertyRequest]
         :param scope: The scope in which the instrument lies. When not supplied the scope is 'default'.
         :type scope: str
+        :param data_model_scope: The optional scope of a Hierarchical Data Model to use
+        :type data_model_scope: str
+        :param data_model_code: The optional code of a Hierarchical Data Model to use
+        :type data_model_code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
@@ -3915,23 +3967,27 @@ class InstrumentsApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.upsert_instruments_properties_with_http_info(upsert_instrument_property_request, scope, **kwargs)  # noqa: E501
+        return self.upsert_instruments_properties_with_http_info(upsert_instrument_property_request, scope, data_model_scope, data_model_code, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_instruments_properties_with_http_info(self, upsert_instrument_property_request : Annotated[conlist(UpsertInstrumentPropertyRequest), Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_instruments_properties_with_http_info(self, upsert_instrument_property_request : Annotated[conlist(UpsertInstrumentPropertyRequest), Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Hierarchical Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Hierarchical Data Model to use")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """UpsertInstrumentsProperties: Upsert instruments properties  # noqa: E501
 
         Create or update one or more properties for particular instruments.                Each instrument property is updated if it exists and created if it does not. For any failures, a reason  is provided.                Properties have an <i>effectiveFrom</i> datetime from which the property is valid, and an <i>effectiveUntil</i>  datetime until which the property is valid. Not supplying an <i>effectiveUntil</i> datetime results in the property being  valid indefinitely, or until the next <i>effectiveFrom</i> datetime of the property.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.upsert_instruments_properties_with_http_info(upsert_instrument_property_request, scope, async_req=True)
+        >>> thread = api.upsert_instruments_properties_with_http_info(upsert_instrument_property_request, scope, data_model_scope, data_model_code, async_req=True)
         >>> result = thread.get()
 
         :param upsert_instrument_property_request: A list of instruments and associated instrument properties to create or update. (required)
         :type upsert_instrument_property_request: List[UpsertInstrumentPropertyRequest]
         :param scope: The scope in which the instrument lies. When not supplied the scope is 'default'.
         :type scope: str
+        :param data_model_scope: The optional scope of a Hierarchical Data Model to use
+        :type data_model_scope: str
+        :param data_model_code: The optional code of a Hierarchical Data Model to use
+        :type data_model_code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -3960,7 +4016,9 @@ class InstrumentsApi:
 
         _all_params = [
             'upsert_instrument_property_request',
-            'scope'
+            'scope',
+            'data_model_scope',
+            'data_model_code'
         ]
         _all_params.extend(
             [
@@ -3995,6 +4053,12 @@ class InstrumentsApi:
         if _params.get('scope') is not None:  # noqa: E501
             _query_params.append(('scope', _params['scope']))
 
+        if _params.get('data_model_scope') is not None:  # noqa: E501
+            _query_params.append(('dataModelScope', _params['data_model_scope']))
+
+        if _params.get('data_model_code') is not None:  # noqa: E501
+            _query_params.append(('dataModelCode', _params['data_model_code']))
+
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters

lusid/configuration.py

@@ -445,7 +445,7 @@ class Configuration:
         return "Python SDK Debug Report:\n"\
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
-               "Version of the API: 0.11.7478\n"\
+               "Version of the API: 0.11.7484\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 

lusid/models/pricing_options.py

@@ -37,9 +37,10 @@ class PricingOptions(BaseModel):
     remove_contingent_cashflows_in_payment_diary: Optional[StrictBool] = Field(None, alias="removeContingentCashflowsInPaymentDiary", description="When creating a payment diary, should contingent cash payments (e.g. from exercise of a swaption into a swap) be included or not.  i.e. Is exercise or default being assumed to happen or not.")
     use_child_sub_holding_keys_for_portfolio_expansion: Optional[StrictBool] = Field(None, alias="useChildSubHoldingKeysForPortfolioExpansion", description="Should fund constituents inherit subholding keys from the parent subholding keyb")
     validate_domestic_and_quote_currencies_are_consistent: Optional[StrictBool] = Field(None, alias="validateDomesticAndQuoteCurrenciesAreConsistent", description="Do we validate that the instrument domestic currency matches the quote currency (unless unknown/zzz) when using lookup pricing.")
+    mbs_valuation_using_holding_current_face: Optional[StrictBool] = Field(None, alias="mbsValuationUsingHoldingCurrentFace")
     conserved_quantity_for_lookthrough_expansion:  Optional[StrictStr] = Field(None,alias="conservedQuantityForLookthroughExpansion", description="When performing lookthrough portfolio expansion with ScalingMethodology set to \"Sum\" or \"AbsoluteSum\",  the quantity specified here will be conserved and apportioned to lookthrough constituents.  For example, an equal-weighting index with 100 constituents can be modelled as a reference portfolio with 1% weights on each equity.  When expanding a $9000 holding of that index into its constituents while conserving PV, we end up with $90 of each equity.  The number of units of each equity held is then implied.  Note that conservation of one quantity may imply non-conservation of others, especially when some constituents are OTCs.                Allowed values are: \"PV\" (default), \"Exposure\".") 
     return_zero_pv: Optional[ReturnZeroPvOptions] = Field(None, alias="returnZeroPv")
-    __properties = ["modelSelection", "useInstrumentTypeToDeterminePricer", "allowAnyInstrumentsWithSecUidToPriceOffLookup", "allowPartiallySuccessfulEvaluation", "produceSeparateResultForLinearOtcLegs", "enableUseOfCachedUnitResults", "windowValuationOnInstrumentStartEnd", "removeContingentCashflowsInPaymentDiary", "useChildSubHoldingKeysForPortfolioExpansion", "validateDomesticAndQuoteCurrenciesAreConsistent", "conservedQuantityForLookthroughExpansion", "returnZeroPv"]
+    __properties = ["modelSelection", "useInstrumentTypeToDeterminePricer", "allowAnyInstrumentsWithSecUidToPriceOffLookup", "allowPartiallySuccessfulEvaluation", "produceSeparateResultForLinearOtcLegs", "enableUseOfCachedUnitResults", "windowValuationOnInstrumentStartEnd", "removeContingentCashflowsInPaymentDiary", "useChildSubHoldingKeysForPortfolioExpansion", "validateDomesticAndQuoteCurrenciesAreConsistent", "mbsValuationUsingHoldingCurrentFace", "conservedQuantityForLookthroughExpansion", "returnZeroPv"]
 
     class Config:
         """Pydantic configuration"""
@@ -106,6 +107,7 @@ class PricingOptions(BaseModel):
             "remove_contingent_cashflows_in_payment_diary": obj.get("removeContingentCashflowsInPaymentDiary"),
             "use_child_sub_holding_keys_for_portfolio_expansion": obj.get("useChildSubHoldingKeysForPortfolioExpansion"),
             "validate_domestic_and_quote_currencies_are_consistent": obj.get("validateDomesticAndQuoteCurrenciesAreConsistent"),
+            "mbs_valuation_using_holding_current_face": obj.get("mbsValuationUsingHoldingCurrentFace"),
             "conserved_quantity_for_lookthrough_expansion": obj.get("conservedQuantityForLookthroughExpansion"),
             "return_zero_pv": ReturnZeroPvOptions.from_dict(obj.get("returnZeroPv")) if obj.get("returnZeroPv") is not None else None
         })

lusid/models/transaction.py

@@ -22,6 +22,7 @@ from typing import Any, Dict, List, Optional, Union
 from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictFloat, StrictInt, StrictStr, conlist, constr, validator 
 from lusid.models.currency_and_amount import CurrencyAndAmount
 from lusid.models.custodian_account import CustodianAccount
+from lusid.models.data_model_membership import DataModelMembership
 from lusid.models.otc_confirmation import OtcConfirmation
 from lusid.models.perpetual_property import PerpetualProperty
 from lusid.models.resource_id import ResourceId
@@ -58,7 +59,8 @@ class Transaction(BaseModel):
     transaction_group_id:  Optional[StrictStr] = Field(None,alias="transactionGroupId", description="The identifier for grouping economic events across multiple transactions") 
     strategy_tag: Optional[conlist(Strategy)] = Field(None, alias="strategyTag", description="A list of strategies representing the allocation of units across multiple sub-holding keys")
     resolved_transaction_type_details: Optional[TransactionTypeDetails] = Field(None, alias="resolvedTransactionTypeDetails")
-    __properties = ["transactionId", "type", "instrumentIdentifiers", "instrumentScope", "instrumentUid", "transactionDate", "settlementDate", "units", "transactionPrice", "totalConsideration", "exchangeRate", "transactionCurrency", "properties", "counterpartyId", "source", "entryDateTime", "otcConfirmation", "transactionStatus", "cancelDateTime", "orderId", "allocationId", "custodianAccount", "transactionGroupId", "strategyTag", "resolvedTransactionTypeDetails"]
+    data_model_membership: Optional[DataModelMembership] = Field(None, alias="dataModelMembership")
+    __properties = ["transactionId", "type", "instrumentIdentifiers", "instrumentScope", "instrumentUid", "transactionDate", "settlementDate", "units", "transactionPrice", "totalConsideration", "exchangeRate", "transactionCurrency", "properties", "counterpartyId", "source", "entryDateTime", "otcConfirmation", "transactionStatus", "cancelDateTime", "orderId", "allocationId", "custodianAccount", "transactionGroupId", "strategyTag", "resolvedTransactionTypeDetails", "dataModelMembership"]
 
     @validator('transaction_status')
     def transaction_status_validate_enum(cls, value):
@@ -137,6 +139,9 @@ class Transaction(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of resolved_transaction_type_details
         if self.resolved_transaction_type_details:
             _dict['resolvedTransactionTypeDetails'] = self.resolved_transaction_type_details.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of data_model_membership
+        if self.data_model_membership:
+            _dict['dataModelMembership'] = self.data_model_membership.to_dict()
         # set to None if instrument_identifiers (nullable) is None
         # and __fields_set__ contains the field
         if self.instrument_identifiers is None and "instrument_identifiers" in self.__fields_set__:
@@ -228,6 +233,7 @@ class Transaction(BaseModel):
             "custodian_account": CustodianAccount.from_dict(obj.get("custodianAccount")) if obj.get("custodianAccount") is not None else None,
             "transaction_group_id": obj.get("transactionGroupId"),
             "strategy_tag": [Strategy.from_dict(_item) for _item in obj.get("strategyTag")] if obj.get("strategyTag") is not None else None,
-            "resolved_transaction_type_details": TransactionTypeDetails.from_dict(obj.get("resolvedTransactionTypeDetails")) if obj.get("resolvedTransactionTypeDetails") is not None else None
+            "resolved_transaction_type_details": TransactionTypeDetails.from_dict(obj.get("resolvedTransactionTypeDetails")) if obj.get("resolvedTransactionTypeDetails") is not None else None,
+            "data_model_membership": DataModelMembership.from_dict(obj.get("dataModelMembership")) if obj.get("dataModelMembership") is not None else None
         })
         return _obj

{lusid_sdk-2.1.726.dist-info → lusid_sdk-2.1.728.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lusid-sdk
-Version: 2.1.726
+Version: 2.1.728
 Summary: LUSID API
 Home-page: https://github.com/finbourne/lusid-sdk-python
 License: MIT

{lusid_sdk-2.1.726.dist-info → lusid_sdk-2.1.728.dist-info}/RECORD

@@ -32,7 +32,7 @@ lusid/api/group_reconciliations_api.py,sha256=WdD_ZZI4ApdqkwG8FUiRzNawy3_-Oxsqcu
 lusid/api/identifier_definitions_api.py,sha256=Pr2umgLtmI4KzagyTPAvOa4-IZFnm9fqDVSA71zXEGo,64275
 lusid/api/instrument_event_types_api.py,sha256=3PpHxwJGVi--9-qjAAl_zzCh56jEPcmiEja29z1gKu4,80192
 lusid/api/instrument_events_api.py,sha256=bAGa16QgzUEXhu_A7yxQLMJ9ec2Cy-pSbo114e8zaA8,57884
-lusid/api/instruments_api.py,sha256=oclYKJZR6oaQ0f3u7Mu1Jx-2GJmYSibY3qysWrVnYcw,290789
+lusid/api/instruments_api.py,sha256=bJL1aCy4i0CjT_ZH4YNFca-77zBiwwWB-cNXuKSvezc,298953
 lusid/api/legacy_compliance_api.py,sha256=ismZoIrheOad5aMqFhmxcsMGkNVhO3HW_44s_oq0i7o,94059
 lusid/api/legal_entities_api.py,sha256=XpwZUhCr8h1tDDrC3yqbc9zizd4lWcQW32y-46flidk,257829
 lusid/api/order_graph_api.py,sha256=4eEfNfSNFJezD7WIHo9TXh-bCTt5w8rlaYIWKPVu8p0,44202
@@ -74,7 +74,7 @@ lusid/api/translation_api.py,sha256=xpRuTfwQvYBlWe6r_L2EI_uVpXqHFnEOim-i-kVQ85E,
 lusid/api/workspace_api.py,sha256=iVbWv-6OsouHkjUayyGnQAHXX0PKuxDUrarBo1bD94I,191226
 lusid/api_client.py,sha256=ewMTmf9SRurY8pYnUx9jy24RdldPCOa4US38pnrVxjA,31140
 lusid/api_response.py,sha256=6-gnhty6lu8MMAERt3_kTVD7UxQgWFfcjgpcq6iN5IU,855
-lusid/configuration.py,sha256=ZRNa0xjmYpy-rhB0s9kxoQ8dl3K_s_R4PiMFX6GCAAE,17972
+lusid/configuration.py,sha256=nc3ZFGC-HJ-KFa7fkVMD39THxdVoUgmcRe-cfBQn8lc,17972
 lusid/exceptions.py,sha256=HIQwgmQrszLlcVCLaqex8dO0laVuejUyOMz7U2ZWJ6s,5326
 lusid/extensions/__init__.py,sha256=dzDHEzpn-9smd2-_UMWQzeyX6Ha4jGf6fnqx7qxKxNI,630
 lusid/extensions/api_client.py,sha256=GzygWg_h603QK1QS2HvAijuE2R1TnvoF6-Yg0CeM3ug,30943
@@ -866,7 +866,7 @@ lusid/models/previous_nav.py,sha256=kZZrYY44Q0K03DQX7GX5HBdLJfIWBQ1nLaK7jR6pzwc,
 lusid/models/previous_share_class_breakdown.py,sha256=Q1szW58a2B5Awnj4jgjmflvlWE-zhzXuF3fXWH4SGks,3223
 lusid/models/pricing_context.py,sha256=cQRPDqxE5q3MB2ahV4zOpT3fIx8_MXRmkqjCb27He1o,8580
 lusid/models/pricing_model.py,sha256=HB-BQzn3dUQ5yJt7PqFTlYfTC9acenElFKNzwSBPjtk,1533
-lusid/models/pricing_options.py,sha256=vUlt17E7hIhp3mkxRWIDBbNSznYPsDBgXIqp8lc9Ysw,8690
+lusid/models/pricing_options.py,sha256=IR87Gr2wQ5m2M9wZqGEODmpygZhEW4045vsIJgc_8SA,8959
 lusid/models/processed_command.py,sha256=CqEkDhCprMS8DxwYCcTDdOx0ivoewyAipM-ThRllFyY,3215
 lusid/models/property_definition.py,sha256=NhH180p-EeMX3AY1WrB46CSKp-qPBEEuzQRdYG72bjw,18157
 lusid/models/property_definition_entity.py,sha256=IVNodIOY6oqK66eb9m1Qd5lT1XlYqdLTgsPM6iCUFMo,8072
@@ -1110,7 +1110,7 @@ lusid/models/touch.py,sha256=989spNJsiwn74GJE3GPr8GNaP0MPnkMsFIWO67Wd6FQ,2966
 lusid/models/trade_ticket.py,sha256=otvnj1o3UFYv2nAwcnz8W1BX1ld1gIPkOKLVciMCVaw,2553
 lusid/models/trade_ticket_type.py,sha256=j7f2bfiA_cxaFtjZpT3Natl4BoaGAaEXF6E0ltEzTWE,706
 lusid/models/trading_conventions.py,sha256=w_oFIB8faBhd6lPqbUwPbUhdLZuaIVgoZryKuUxRyBM,3211
-lusid/models/transaction.py,sha256=hydsR5vopwwuyH6DK_fMSuVWoQiEyBE5jzbn2xjn32Y,13941
+lusid/models/transaction.py,sha256=FyiVrss4HeTsC8tHys8HrWYylSHqs5ApwYI4t1mq-tE,14506
 lusid/models/transaction_configuration_data.py,sha256=0Gm-MXYMpoS_wz_td3U4gkP8CMjnY5E38JGQVdwjsqc,4550
 lusid/models/transaction_configuration_data_request.py,sha256=8fzgpawxQN4C07McluIUImNMqnB25YZBDGuCRgikqQw,4630
 lusid/models/transaction_configuration_movement_data.py,sha256=nL0Vcs6Su6Dc-16yUKX0N9DSAZCPUPykyTNMEMFyV14,7773
@@ -1283,6 +1283,6 @@ lusid/models/workspace_update_request.py,sha256=ihKnBY685hfgs9uoyAXQNt1w7iOF-6Jc
 lusid/models/yield_curve_data.py,sha256=eDxj1qjChju3anFaQzywjFOuchX5i0pOTh5N-zcvJzg,6540
 lusid/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lusid/rest.py,sha256=HQT__5LQEMu6_1sLKvYj-DI4FH1DJXBIPYfZCTTyrY4,13431
-lusid_sdk-2.1.726.dist-info/METADATA,sha256=CCCx7D1IrRxAiDtsjbEgFv-2YSOlWdXZjYHEAhB9OJk,219947
-lusid_sdk-2.1.726.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-lusid_sdk-2.1.726.dist-info/RECORD,,
+lusid_sdk-2.1.728.dist-info/METADATA,sha256=mDbuCpmMv7yW4ySdkHKVFA2bZXgW-oQg_w1xuqVdA18,219947
+lusid_sdk-2.1.728.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+lusid_sdk-2.1.728.dist-info/RECORD,,