lusid-sdk 2.1.897__py3-none-any.whl → 2.1.899__py3-none-any.whl

lusid/__init__.py

@@ -510,6 +510,7 @@ from lusid.models.flexible_loan import FlexibleLoan
 from lusid.models.flexible_repo import FlexibleRepo
 from lusid.models.flexible_repo_cash_flow_event import FlexibleRepoCashFlowEvent
 from lusid.models.flexible_repo_collateral_event import FlexibleRepoCollateralEvent
+from lusid.models.flexible_repo_full_closure_event import FlexibleRepoFullClosureEvent
 from lusid.models.flexible_repo_interest_payment_event import FlexibleRepoInterestPaymentEvent
 from lusid.models.flexible_repo_partial_closure_event import FlexibleRepoPartialClosureEvent
 from lusid.models.float_schedule import FloatSchedule
@@ -535,6 +536,8 @@ from lusid.models.fund_properties import FundProperties
 from lusid.models.fund_request import FundRequest
 from lusid.models.fund_share_class import FundShareClass
 from lusid.models.fund_valuation_point_data import FundValuationPointData
+from lusid.models.fund_valuation_request import FundValuationRequest
+from lusid.models.fund_valuation_schedule import FundValuationSchedule
 from lusid.models.funding_leg import FundingLeg
 from lusid.models.funding_leg_options import FundingLegOptions
 from lusid.models.future import Future
@@ -919,6 +922,7 @@ from lusid.models.portfolio_reconciliation_request import PortfolioReconciliatio
 from lusid.models.portfolio_result_data_key_rule import PortfolioResultDataKeyRule
 from lusid.models.portfolio_return_breakdown import PortfolioReturnBreakdown
 from lusid.models.portfolio_search_result import PortfolioSearchResult
+from lusid.models.portfolio_settlement_configuration import PortfolioSettlementConfiguration
 from lusid.models.portfolio_trade_ticket import PortfolioTradeTicket
 from lusid.models.portfolio_type import PortfolioType
 from lusid.models.portfolio_without_href import PortfolioWithoutHref
@@ -1134,6 +1138,7 @@ from lusid.models.set_person_properties_request import SetPersonPropertiesReques
 from lusid.models.set_share_class_instruments_request import SetShareClassInstrumentsRequest
 from lusid.models.set_transaction_configuration_alias import SetTransactionConfigurationAlias
 from lusid.models.set_transaction_configuration_source_request import SetTransactionConfigurationSourceRequest
+from lusid.models.settlement_configuration_category import SettlementConfigurationCategory
 from lusid.models.settlement_cycle import SettlementCycle
 from lusid.models.settlement_instruction_request import SettlementInstructionRequest
 from lusid.models.settlement_schedule import SettlementSchedule
@@ -1340,6 +1345,7 @@ from lusid.models.user import User
 from lusid.models.valuation_point_data_query_parameters import ValuationPointDataQueryParameters
 from lusid.models.valuation_point_data_request import ValuationPointDataRequest
 from lusid.models.valuation_point_data_response import ValuationPointDataResponse
+from lusid.models.valuation_point_fund_calendar_entry import ValuationPointFundCalendarEntry
 from lusid.models.valuation_point_overview import ValuationPointOverview
 from lusid.models.valuation_point_resource_list_of_accounted_transaction import ValuationPointResourceListOfAccountedTransaction
 from lusid.models.valuation_point_resource_list_of_fund_journal_entry_line import ValuationPointResourceListOfFundJournalEntryLine
@@ -1878,6 +1884,7 @@ __all__ = [
     "FlexibleRepo",
     "FlexibleRepoCashFlowEvent",
     "FlexibleRepoCollateralEvent",
+    "FlexibleRepoFullClosureEvent",
     "FlexibleRepoInterestPaymentEvent",
     "FlexibleRepoPartialClosureEvent",
     "FloatSchedule",
@@ -1903,6 +1910,8 @@ __all__ = [
     "FundRequest",
     "FundShareClass",
     "FundValuationPointData",
+    "FundValuationRequest",
+    "FundValuationSchedule",
     "FundingLeg",
     "FundingLegOptions",
     "Future",
@@ -2287,6 +2296,7 @@ __all__ = [
     "PortfolioResultDataKeyRule",
     "PortfolioReturnBreakdown",
     "PortfolioSearchResult",
+    "PortfolioSettlementConfiguration",
     "PortfolioTradeTicket",
     "PortfolioType",
     "PortfolioWithoutHref",
@@ -2502,6 +2512,7 @@ __all__ = [
     "SetShareClassInstrumentsRequest",
     "SetTransactionConfigurationAlias",
     "SetTransactionConfigurationSourceRequest",
+    "SettlementConfigurationCategory",
     "SettlementCycle",
     "SettlementInstructionRequest",
     "SettlementSchedule",
@@ -2708,6 +2719,7 @@ __all__ = [
     "ValuationPointDataQueryParameters",
     "ValuationPointDataRequest",
     "ValuationPointDataResponse",
+    "ValuationPointFundCalendarEntry",
     "ValuationPointOverview",
     "ValuationPointResourceListOfAccountedTransaction",
     "ValuationPointResourceListOfFundJournalEntryLine",

lusid/api/funds_api.py

@@ -36,6 +36,8 @@ from lusid.models.fund import Fund
 from lusid.models.fund_definition_request import FundDefinitionRequest
 from lusid.models.fund_properties import FundProperties
 from lusid.models.fund_request import FundRequest
+from lusid.models.fund_valuation_request import FundValuationRequest
+from lusid.models.list_aggregation_response import ListAggregationResponse
 from lusid.models.model_property import ModelProperty
 from lusid.models.operation import Operation
 from lusid.models.paged_resource_list_of_fee import PagedResourceListOfFee
@@ -2444,6 +2446,189 @@ class FundsApi:
             _request_auth=_params.get('_request_auth'))
 
 
+    @overload
+    async def get_valuation_for_fund(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund")], code : Annotated[StrictStr, Field(..., description="The code of the Fund")], nav_type_code : Annotated[Optional[StrictStr], Field( description="When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.")] = None, fund_valuation_request : Annotated[Optional[FundValuationRequest], Field(description="The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics")] = None, **kwargs) -> ListAggregationResponse:  # noqa: E501
+        ...
+
+    @overload
+    def get_valuation_for_fund(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund")], code : Annotated[StrictStr, Field(..., description="The code of the Fund")], nav_type_code : Annotated[Optional[StrictStr], Field( description="When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.")] = None, fund_valuation_request : Annotated[Optional[FundValuationRequest], Field(description="The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics")] = None, async_req: Optional[bool]=True, **kwargs) -> ListAggregationResponse:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def get_valuation_for_fund(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund")], code : Annotated[StrictStr, Field(..., description="The code of the Fund")], nav_type_code : Annotated[Optional[StrictStr], Field( description="When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.")] = None, fund_valuation_request : Annotated[Optional[FundValuationRequest], Field(description="The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ListAggregationResponse, Awaitable[ListAggregationResponse]]:  # noqa: E501
+        """[EXPERIMENTAL] GetValuationForFund: Perform valuation for a Fund  # noqa: E501
+
+        Perform valuation on a specified Fund.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_valuation_for_fund(scope, code, nav_type_code, fund_valuation_request, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope of the Fund (required)
+        :type scope: str
+        :param code: The code of the Fund (required)
+        :type code: str
+        :param nav_type_code: When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.
+        :type nav_type_code: str
+        :param fund_valuation_request: The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics
+        :type fund_valuation_request: FundValuationRequest
+        :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
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: ListAggregationResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the get_valuation_for_fund_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.get_valuation_for_fund_with_http_info(scope, code, nav_type_code, fund_valuation_request, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def get_valuation_for_fund_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund")], code : Annotated[StrictStr, Field(..., description="The code of the Fund")], nav_type_code : Annotated[Optional[StrictStr], Field( description="When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.")] = None, fund_valuation_request : Annotated[Optional[FundValuationRequest], Field(description="The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """[EXPERIMENTAL] GetValuationForFund: Perform valuation for a Fund  # noqa: E501
+
+        Perform valuation on a specified Fund.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_valuation_for_fund_with_http_info(scope, code, nav_type_code, fund_valuation_request, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope of the Fund (required)
+        :type scope: str
+        :param code: The code of the Fund (required)
+        :type code: str
+        :param nav_type_code: When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.
+        :type nav_type_code: str
+        :param fund_valuation_request: The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics
+        :type fund_valuation_request: FundValuationRequest
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(ListAggregationResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'code',
+            'nav_type_code',
+            'fund_valuation_request'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_valuation_for_fund" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+        if _params['code']:
+            _path_params['code'] = _params['code']
+
+
+        # process the query parameters
+        _query_params = []
+        if _params.get('nav_type_code') is not None:  # noqa: E501
+            _query_params.append(('navTypeCode', _params['nav_type_code']))
+
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['fund_valuation_request'] is not None:
+            _body_params = _params['fund_valuation_request']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "ListAggregationResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/funds/{scope}/{code}/$valuation', 'POST',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+
     @overload
     async def get_valuation_point_data(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund.")], code : Annotated[StrictStr, Field(..., description="The code of the Fund. Together with the scope this uniquely identifies the Fund.")], valuation_point_data_query_parameters : Annotated[ValuationPointDataQueryParameters, Field(..., description="The arguments to use for querying the Valuation Point data")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Fund definition. Defaults to returning the latest version of the Fund definition if not specified.")] = None, nav_type_code : Annotated[Optional[StrictStr], Field( description="When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.")] = None, **kwargs) -> ValuationPointDataResponse:  # noqa: E501
         ...
@@ -4606,7 +4791,7 @@ class FundsApi:
     def patch_fund(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund.")], code : Annotated[StrictStr, Field(..., description="The code of the Fund. Together with the scope this uniquely identifies the Fund.")], operation : Annotated[conlist(Operation), Field(..., description="The json patch document. For more information see: https://datatracker.ietf.org/doc/html/rfc6902.")], async_req: Optional[bool]=None, **kwargs) -> Union[Fund, Awaitable[Fund]]:  # noqa: E501
         """[EXPERIMENTAL] PatchFund: Patch a Fund.  # noqa: E501
 
-        Update fields on a Fund.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: DisplayName, Description, BaseCurrency, PortfolioIds, FundConfigurationId, ShareClassInstrumentScopes, ShareClassInstruments, Type, InceptionDate, DecimalPlaces, PrimaryNavType, AdditionalNavTypes, AborId, YearEndDate.  # noqa: E501
+        Update fields on a Fund.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: DisplayName, Description, PortfolioIds, FundConfigurationId, ShareClassInstruments, Type, InceptionDate, DecimalPlaces, PrimaryNavType, AdditionalNavTypes, AborId, YearEndDate.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -4641,7 +4826,7 @@ class FundsApi:
     def patch_fund_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund.")], code : Annotated[StrictStr, Field(..., description="The code of the Fund. Together with the scope this uniquely identifies the Fund.")], operation : Annotated[conlist(Operation), Field(..., description="The json patch document. For more information see: https://datatracker.ietf.org/doc/html/rfc6902.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] PatchFund: Patch a Fund.  # noqa: E501
 
-        Update fields on a Fund.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: DisplayName, Description, BaseCurrency, PortfolioIds, FundConfigurationId, ShareClassInstrumentScopes, ShareClassInstruments, Type, InceptionDate, DecimalPlaces, PrimaryNavType, AdditionalNavTypes, AborId, YearEndDate.  # noqa: E501
+        Update fields on a Fund.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: DisplayName, Description, PortfolioIds, FundConfigurationId, ShareClassInstruments, Type, InceptionDate, DecimalPlaces, PrimaryNavType, AdditionalNavTypes, AborId, YearEndDate.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 

lusid/api/transaction_portfolios_api.py

@@ -101,22 +101,22 @@ class TransactionPortfoliosApi:
 
 
     @overload
-    async def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, **kwargs) -> AdjustHolding:  # noqa: E501
+    async def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, **kwargs) -> AdjustHolding:  # noqa: E501
         ...
 
     @overload
-    def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, async_req: Optional[bool]=True, **kwargs) -> AdjustHolding:  # noqa: E501
+    def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, async_req: Optional[bool]=True, **kwargs) -> AdjustHolding:  # noqa: E501
         ...
 
     @validate_arguments
-    def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[AdjustHolding, Awaitable[AdjustHolding]]:  # noqa: E501
+    def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[AdjustHolding, Awaitable[AdjustHolding]]:  # noqa: E501
         """AdjustHoldings: Adjust holdings  # noqa: E501
 
         Adjust one or more holdings of the specified transaction portfolio to the provided targets. LUSID will  automatically construct adjustment transactions to ensure that the holdings which have been adjusted are  always set to the provided targets for the specified effective datetime. Read more about the difference between  adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.adjust_holdings(scope, code, effective_at, adjust_holding_request, reconciliation_methods, async_req=True)
+        >>> thread = api.adjust_holdings(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the transaction portfolio. (required)
@@ -129,6 +129,10 @@ class TransactionPortfoliosApi:
         :type adjust_holding_request: List[AdjustHoldingRequest]
         :param reconciliation_methods: Optional parameter for specifying a reconciliation method: e.g. FxForward.
         :type reconciliation_methods: List[str]
+        :param override_movement_name: Optional parameter to override movement name for the set holdings.
+        :type override_movement_name: str
+        :param override_offset_movement_name: Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl
+        :type override_offset_movement_name: 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
@@ -145,17 +149,17 @@ class TransactionPortfoliosApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.adjust_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, **kwargs)  # noqa: E501
+        return self.adjust_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def adjust_holdings_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def adjust_holdings_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """AdjustHoldings: Adjust holdings  # noqa: E501
 
         Adjust one or more holdings of the specified transaction portfolio to the provided targets. LUSID will  automatically construct adjustment transactions to ensure that the holdings which have been adjusted are  always set to the provided targets for the specified effective datetime. Read more about the difference between  adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.adjust_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, async_req=True)
+        >>> thread = api.adjust_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the transaction portfolio. (required)
@@ -168,6 +172,10 @@ class TransactionPortfoliosApi:
         :type adjust_holding_request: List[AdjustHoldingRequest]
         :param reconciliation_methods: Optional parameter for specifying a reconciliation method: e.g. FxForward.
         :type reconciliation_methods: List[str]
+        :param override_movement_name: Optional parameter to override movement name for the set holdings.
+        :type override_movement_name: str
+        :param override_offset_movement_name: Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl
+        :type override_offset_movement_name: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -199,7 +207,9 @@ class TransactionPortfoliosApi:
             'code',
             'effective_at',
             'adjust_holding_request',
-            'reconciliation_methods'
+            'reconciliation_methods',
+            'override_movement_name',
+            'override_offset_movement_name'
         ]
         _all_params.extend(
             [
@@ -244,6 +254,12 @@ class TransactionPortfoliosApi:
             _query_params.append(('reconciliationMethods', _params['reconciliation_methods']))
             _collection_formats['reconciliationMethods'] = 'multi'
 
+        if _params.get('override_movement_name') is not None:  # noqa: E501
+            _query_params.append(('overrideMovementName', _params['override_movement_name']))
+
+        if _params.get('override_offset_movement_name') is not None:  # noqa: E501
+            _query_params.append(('overrideOffsetMovementName', _params['override_offset_movement_name']))
+
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters
@@ -6734,7 +6750,7 @@ class TransactionPortfoliosApi:
     def patch_portfolio_details(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the              scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal entities in the request, but will not be used for any perpetual entities.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PortfolioDetails, Awaitable[PortfolioDetails]]:  # noqa: E501
         """PatchPortfolioDetails: Patch portfolio details  # noqa: E501
 
-        Create or update certain details for a particular transaction portfolio.  Note that not all elements of a transaction portfolio definition are  modifiable once it has been created due to the potential implications for data already stored.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: BaseCurrency, SubHoldingKeys, AmortisationMethod, TransactionTypeScope, CashGainLossCalculationDate, InstrumentEventConfiguration, AmortisationRuleSetId, TaxRuleSetScope.  # noqa: E501
+        Create or update certain details for a particular transaction portfolio.  Note that not all elements of a transaction portfolio definition are  modifiable once it has been created due to the potential implications for data already stored.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: BaseCurrency, SubHoldingKeys, AmortisationMethod, TransactionTypeScope, CashGainLossCalculationDate, InstrumentEventConfiguration, AmortisationRuleSetId, TaxRuleSetScope, SettlementConfiguration.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -6771,7 +6787,7 @@ class TransactionPortfoliosApi:
     def patch_portfolio_details_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the              scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal entities in the request, but will not be used for any perpetual entities.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """PatchPortfolioDetails: Patch portfolio details  # noqa: E501
 
-        Create or update certain details for a particular transaction portfolio.  Note that not all elements of a transaction portfolio definition are  modifiable once it has been created due to the potential implications for data already stored.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: BaseCurrency, SubHoldingKeys, AmortisationMethod, TransactionTypeScope, CashGainLossCalculationDate, InstrumentEventConfiguration, AmortisationRuleSetId, TaxRuleSetScope.  # noqa: E501
+        Create or update certain details for a particular transaction portfolio.  Note that not all elements of a transaction portfolio definition are  modifiable once it has been created due to the potential implications for data already stored.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: BaseCurrency, SubHoldingKeys, AmortisationMethod, TransactionTypeScope, CashGainLossCalculationDate, InstrumentEventConfiguration, AmortisationRuleSetId, TaxRuleSetScope, SettlementConfiguration.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -7313,22 +7329,22 @@ class TransactionPortfoliosApi:
 
 
     @overload
-    async def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, **kwargs) -> AdjustHolding:  # noqa: E501
+    async def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, **kwargs) -> AdjustHolding:  # noqa: E501
         ...
 
     @overload
-    def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, async_req: Optional[bool]=True, **kwargs) -> AdjustHolding:  # noqa: E501
+    def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, async_req: Optional[bool]=True, **kwargs) -> AdjustHolding:  # noqa: E501
         ...
 
     @validate_arguments
-    def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[AdjustHolding, Awaitable[AdjustHolding]]:  # noqa: E501
+    def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[AdjustHolding, Awaitable[AdjustHolding]]:  # noqa: E501
         """SetHoldings: Set holdings  # noqa: E501
 
         Set the holdings of the specified transaction portfolio to the provided targets. LUSID will automatically  construct adjustment transactions to ensure that the entire set of holdings for the transaction portfolio  are always set to the provided targets for the specified effective datetime. Read more about the difference between  adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.set_holdings(scope, code, effective_at, adjust_holding_request, reconciliation_methods, async_req=True)
+        >>> thread = api.set_holdings(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the transaction portfolio. (required)
@@ -7341,6 +7357,10 @@ class TransactionPortfoliosApi:
         :type adjust_holding_request: List[AdjustHoldingRequest]
         :param reconciliation_methods: Optional parameter for specifying a reconciliation method: e.g. FxForward.
         :type reconciliation_methods: List[str]
+        :param override_movement_name: Optional parameter to override movement name for the set holdings.
+        :type override_movement_name: str
+        :param override_offset_movement_name: Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl
+        :type override_offset_movement_name: 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
@@ -7357,17 +7377,17 @@ class TransactionPortfoliosApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.set_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, **kwargs)  # noqa: E501
+        return self.set_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def set_holdings_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def set_holdings_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """SetHoldings: Set holdings  # noqa: E501
 
         Set the holdings of the specified transaction portfolio to the provided targets. LUSID will automatically  construct adjustment transactions to ensure that the entire set of holdings for the transaction portfolio  are always set to the provided targets for the specified effective datetime. Read more about the difference between  adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.set_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, async_req=True)
+        >>> thread = api.set_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the transaction portfolio. (required)
@@ -7380,6 +7400,10 @@ class TransactionPortfoliosApi:
         :type adjust_holding_request: List[AdjustHoldingRequest]
         :param reconciliation_methods: Optional parameter for specifying a reconciliation method: e.g. FxForward.
         :type reconciliation_methods: List[str]
+        :param override_movement_name: Optional parameter to override movement name for the set holdings.
+        :type override_movement_name: str
+        :param override_offset_movement_name: Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl
+        :type override_offset_movement_name: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -7411,7 +7435,9 @@ class TransactionPortfoliosApi:
             'code',
             'effective_at',
             'adjust_holding_request',
-            'reconciliation_methods'
+            'reconciliation_methods',
+            'override_movement_name',
+            'override_offset_movement_name'
         ]
         _all_params.extend(
             [
@@ -7456,6 +7482,12 @@ class TransactionPortfoliosApi:
             _query_params.append(('reconciliationMethods', _params['reconciliation_methods']))
             _collection_formats['reconciliationMethods'] = 'multi'
 
+        if _params.get('override_movement_name') is not None:  # noqa: E501
+            _query_params.append(('overrideMovementName', _params['override_movement_name']))
+
+        if _params.get('override_offset_movement_name') is not None:  # noqa: E501
+            _query_params.append(('overrideOffsetMovementName', _params['override_offset_movement_name']))
+
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters

lusid/configuration.py

@@ -128,7 +128,7 @@ class Configuration:
                  rate_limit_retries=DEFAULT_RATE_LIMIT_RETRIES) -> None:
         """Constructor
         """
-        self._base_path = "https://www.lusid.com/api" if host is None else host
+        self._base_path = "https://fbn-prd.lusid.com/api" if host is None else host
         """Default Base url
         """
         self.server_index = 0 if server_index is None and host is None else server_index
@@ -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.8126\n"\
+               "Version of the API: 0.11.8138\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 
@@ -456,7 +456,7 @@ class Configuration:
         """
         return [
             {
-                'url': "https://www.lusid.com/api",
+                'url': "https://fbn-prd.lusid.com/api",
                 'description': "No description provided",
             }
         ]