lusid-sdk 2.1.991__py3-none-any.whl → 2.2.2__py3-none-any.whl

lusid/api/transfer_agency_api.py

@@ -19,11 +19,9 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from pydantic.v1 import Field
-
 from typing import Dict
-
+from typing_extensions import Annotated
 from lusid.models.calculate_order_dates_request import CalculateOrderDatesRequest
 from lusid.models.calculate_order_dates_response import CalculateOrderDatesResponse
 
@@ -54,15 +52,15 @@ class TransferAgencyApi:
 
 
     @overload
-    async def calculate_order_dates(self, request_body : Annotated[Dict[str, CalculateOrderDatesRequest], Field(..., description="The request containing the dates used for calculation")], **kwargs) -> CalculateOrderDatesResponse:  # noqa: E501
+    async def calculate_order_dates(self, request_body : Annotated[Dict[str, CalculateOrderDatesRequest], Field(description="The request containing the dates used for calculation")], **kwargs) -> CalculateOrderDatesResponse:  # noqa: E501
         ...
 
     @overload
-    def calculate_order_dates(self, request_body : Annotated[Dict[str, CalculateOrderDatesRequest], Field(..., description="The request containing the dates used for calculation")], async_req: Optional[bool]=True, **kwargs) -> CalculateOrderDatesResponse:  # noqa: E501
+    def calculate_order_dates(self, request_body : Annotated[Dict[str, CalculateOrderDatesRequest], Field(description="The request containing the dates used for calculation")], async_req: Optional[bool]=True, **kwargs) -> CalculateOrderDatesResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def calculate_order_dates(self, request_body : Annotated[Dict[str, CalculateOrderDatesRequest], Field(..., description="The request containing the dates used for calculation")], async_req: Optional[bool]=None, **kwargs) -> Union[CalculateOrderDatesResponse, Awaitable[CalculateOrderDatesResponse]]:  # noqa: E501
+    def calculate_order_dates(self, request_body : Annotated[Dict[str, CalculateOrderDatesRequest], Field(description="The request containing the dates used for calculation")], async_req: Optional[bool]=None, **kwargs) -> Union[CalculateOrderDatesResponse, Awaitable[CalculateOrderDatesResponse]]:  # noqa: E501
         """[EXPERIMENTAL] CalculateOrderDates: Calculate the key dates associated with transfer agency orders  # noqa: E501
 
         The response contains both the collection of successfully calculated dates and any failed calculations,  each in the form of a dictionary keyed by the request's keys.  For each failure, a reason is provided. It is important to check the failed set for unsuccessful results.  # noqa: E501
@@ -93,7 +91,7 @@ class TransferAgencyApi:
         return self.calculate_order_dates_with_http_info(request_body, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def calculate_order_dates_with_http_info(self, request_body : Annotated[Dict[str, CalculateOrderDatesRequest], Field(..., description="The request containing the dates used for calculation")], **kwargs) -> ApiResponse:  # noqa: E501
+    def calculate_order_dates_with_http_info(self, request_body : Annotated[Dict[str, CalculateOrderDatesRequest], Field(description="The request containing the dates used for calculation")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] CalculateOrderDates: Calculate the key dates associated with transfer agency orders  # noqa: E501
 
         The response contains both the collection of successfully calculated dates and any failed calculations,  each in the form of a dictionary keyed by the request's keys.  For each failure, a reason is provided. It is important to check the failed set for unsuccessful results.  # noqa: E501

lusid/api/translation_api.py

@@ -19,9 +19,8 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from pydantic.v1 import Field
-
+from typing_extensions import Annotated
 from lusid.models.translate_instrument_definitions_request import TranslateInstrumentDefinitionsRequest
 from lusid.models.translate_instrument_definitions_response import TranslateInstrumentDefinitionsResponse
 from lusid.models.translate_trade_ticket_request import TranslateTradeTicketRequest
@@ -54,15 +53,15 @@ class TranslationApi:
 
 
     @overload
-    async def translate_instrument_definitions(self, translate_instrument_definitions_request : Annotated[TranslateInstrumentDefinitionsRequest, Field(..., description="The definitions of the instruments to translate along with the target dialect.")], **kwargs) -> TranslateInstrumentDefinitionsResponse:  # noqa: E501
+    async def translate_instrument_definitions(self, translate_instrument_definitions_request : Annotated[TranslateInstrumentDefinitionsRequest, Field(description="The definitions of the instruments to translate along with the target dialect.")], **kwargs) -> TranslateInstrumentDefinitionsResponse:  # noqa: E501
         ...
 
     @overload
-    def translate_instrument_definitions(self, translate_instrument_definitions_request : Annotated[TranslateInstrumentDefinitionsRequest, Field(..., description="The definitions of the instruments to translate along with the target dialect.")], async_req: Optional[bool]=True, **kwargs) -> TranslateInstrumentDefinitionsResponse:  # noqa: E501
+    def translate_instrument_definitions(self, translate_instrument_definitions_request : Annotated[TranslateInstrumentDefinitionsRequest, Field(description="The definitions of the instruments to translate along with the target dialect.")], async_req: Optional[bool]=True, **kwargs) -> TranslateInstrumentDefinitionsResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def translate_instrument_definitions(self, translate_instrument_definitions_request : Annotated[TranslateInstrumentDefinitionsRequest, Field(..., description="The definitions of the instruments to translate along with the target dialect.")], async_req: Optional[bool]=None, **kwargs) -> Union[TranslateInstrumentDefinitionsResponse, Awaitable[TranslateInstrumentDefinitionsResponse]]:  # noqa: E501
+    def translate_instrument_definitions(self, translate_instrument_definitions_request : Annotated[TranslateInstrumentDefinitionsRequest, Field(description="The definitions of the instruments to translate along with the target dialect.")], async_req: Optional[bool]=None, **kwargs) -> Union[TranslateInstrumentDefinitionsResponse, Awaitable[TranslateInstrumentDefinitionsResponse]]:  # noqa: E501
         """[EXPERIMENTAL] TranslateInstrumentDefinitions: Translate instruments  # noqa: E501
 
         Translates one or more instruments into the given target dialect.                In the request each instrument definition should be keyed by a unique correlation id. This id is ephemeral  and is not stored by LUSID. It serves only as a way to easily identify each instrument in the response.                Any instrument that is not already in the LUSID dialect should be given as an ExoticInstrument.                The response will return both the collection of successfully translated instruments in the target dialect,  as well as those that failed.  For the failures a reason will be provided explaining why the instrument could not be updated or inserted.  # noqa: E501
@@ -93,7 +92,7 @@ class TranslationApi:
         return self.translate_instrument_definitions_with_http_info(translate_instrument_definitions_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def translate_instrument_definitions_with_http_info(self, translate_instrument_definitions_request : Annotated[TranslateInstrumentDefinitionsRequest, Field(..., description="The definitions of the instruments to translate along with the target dialect.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def translate_instrument_definitions_with_http_info(self, translate_instrument_definitions_request : Annotated[TranslateInstrumentDefinitionsRequest, Field(description="The definitions of the instruments to translate along with the target dialect.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] TranslateInstrumentDefinitions: Translate instruments  # noqa: E501
 
         Translates one or more instruments into the given target dialect.                In the request each instrument definition should be keyed by a unique correlation id. This id is ephemeral  and is not stored by LUSID. It serves only as a way to easily identify each instrument in the response.                Any instrument that is not already in the LUSID dialect should be given as an ExoticInstrument.                The response will return both the collection of successfully translated instruments in the target dialect,  as well as those that failed.  For the failures a reason will be provided explaining why the instrument could not be updated or inserted.  # noqa: E501
@@ -213,15 +212,15 @@ class TranslationApi:
 
 
     @overload
-    async def translate_trade_tickets(self, translate_trade_ticket_request : Annotated[TranslateTradeTicketRequest, Field(..., description="The definitions of the trade ticket to translate along with the target dialect.")], **kwargs) -> TranslateTradeTicketsResponse:  # noqa: E501
+    async def translate_trade_tickets(self, translate_trade_ticket_request : Annotated[TranslateTradeTicketRequest, Field(description="The definitions of the trade ticket to translate along with the target dialect.")], **kwargs) -> TranslateTradeTicketsResponse:  # noqa: E501
         ...
 
     @overload
-    def translate_trade_tickets(self, translate_trade_ticket_request : Annotated[TranslateTradeTicketRequest, Field(..., description="The definitions of the trade ticket to translate along with the target dialect.")], async_req: Optional[bool]=True, **kwargs) -> TranslateTradeTicketsResponse:  # noqa: E501
+    def translate_trade_tickets(self, translate_trade_ticket_request : Annotated[TranslateTradeTicketRequest, Field(description="The definitions of the trade ticket to translate along with the target dialect.")], async_req: Optional[bool]=True, **kwargs) -> TranslateTradeTicketsResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def translate_trade_tickets(self, translate_trade_ticket_request : Annotated[TranslateTradeTicketRequest, Field(..., description="The definitions of the trade ticket to translate along with the target dialect.")], async_req: Optional[bool]=None, **kwargs) -> Union[TranslateTradeTicketsResponse, Awaitable[TranslateTradeTicketsResponse]]:  # noqa: E501
+    def translate_trade_tickets(self, translate_trade_ticket_request : Annotated[TranslateTradeTicketRequest, Field(description="The definitions of the trade ticket to translate along with the target dialect.")], async_req: Optional[bool]=None, **kwargs) -> Union[TranslateTradeTicketsResponse, Awaitable[TranslateTradeTicketsResponse]]:  # noqa: E501
         """[EXPERIMENTAL] TranslateTradeTickets: Translate trade ticket  # noqa: E501
 
         Translates one or more trade tickets into the given target dialect.                In the request each trade ticket definition should be keyed by a unique correlation id. This id is ephemeral  and is not stored by LUSID. It serves only as a way to easily identify each trade ticket in the response.                The response will return both the collection of successfully translated trade tickets in the target dialect,  as well as those that failed.  For the failures a reason will be provided explaining why the trade ticket could not be updated or inserted.  # noqa: E501
@@ -252,7 +251,7 @@ class TranslationApi:
         return self.translate_trade_tickets_with_http_info(translate_trade_ticket_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def translate_trade_tickets_with_http_info(self, translate_trade_ticket_request : Annotated[TranslateTradeTicketRequest, Field(..., description="The definitions of the trade ticket to translate along with the target dialect.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def translate_trade_tickets_with_http_info(self, translate_trade_ticket_request : Annotated[TranslateTradeTicketRequest, Field(description="The definitions of the trade ticket to translate along with the target dialect.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] TranslateTradeTickets: Translate trade ticket  # noqa: E501
 
         Translates one or more trade tickets into the given target dialect.                In the request each trade ticket definition should be keyed by a unique correlation id. This id is ephemeral  and is not stored by LUSID. It serves only as a way to easily identify each trade ticket in the response.                The response will return both the collection of successfully translated trade tickets in the target dialect,  as well as those that failed.  For the failures a reason will be provided explaining why the trade ticket could not be updated or inserted.  # noqa: E501

lusid/api/workspace_api.py

@@ -19,13 +19,10 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from datetime import datetime
-
-from pydantic.v1 import Field, StrictStr, conint, conlist, constr, validator
-
-from typing import Optional
-
+from pydantic.v1 import Field, StrictInt, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
 from lusid.models.deleted_entity_response import DeletedEntityResponse
 from lusid.models.paged_resource_list_of_item_and_workspace import PagedResourceListOfItemAndWorkspace
 from lusid.models.paged_resource_list_of_workspace import PagedResourceListOfWorkspace
@@ -1100,15 +1097,15 @@ class WorkspaceApi:
 
 
     @overload
-    async def list_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], workspace_name : Annotated[StrictStr, Field(..., description="The item's workspace name.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfWorkspaceItem:  # noqa: E501
+    async def list_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], workspace_name : Annotated[StrictStr, Field(..., description="The item's workspace name.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfWorkspaceItem:  # noqa: E501
         ...
 
     @overload
-    def list_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], workspace_name : Annotated[StrictStr, Field(..., description="The item's workspace name.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfWorkspaceItem:  # noqa: E501
+    def list_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], workspace_name : Annotated[StrictStr, Field(..., description="The item's workspace name.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfWorkspaceItem:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], workspace_name : Annotated[StrictStr, Field(..., description="The item's workspace name.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfWorkspaceItem, Awaitable[PagedResourceListOfWorkspaceItem]]:  # noqa: E501
+    def list_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], workspace_name : Annotated[StrictStr, Field(..., description="The item's workspace name.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfWorkspaceItem, Awaitable[PagedResourceListOfWorkspaceItem]]:  # noqa: E501
         """[EXPERIMENTAL] ListItems: List the items in a workspace.  # noqa: E501
 
         List the items in a workspace.  # noqa: E501
@@ -1151,7 +1148,7 @@ class WorkspaceApi:
         return self.list_items_with_http_info(visibility, workspace_name, as_at, page, sort_by, limit, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_items_with_http_info(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], workspace_name : Annotated[StrictStr, Field(..., description="The item's workspace name.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_items_with_http_info(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], workspace_name : Annotated[StrictStr, Field(..., description="The item's workspace name.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] ListItems: List the items in a workspace.  # noqa: E501
 
         List the items in a workspace.  # noqa: E501
@@ -1304,15 +1301,15 @@ class WorkspaceApi:
 
 
     @overload
-    async def list_workspaces(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the workspaces. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspaces. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces from a previous call to list workspaces.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfWorkspace:  # noqa: E501
+    async def list_workspaces(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the workspaces. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspaces. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces from a previous call to list workspaces.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfWorkspace:  # noqa: E501
         ...
 
     @overload
-    def list_workspaces(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the workspaces. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspaces. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces from a previous call to list workspaces.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfWorkspace:  # noqa: E501
+    def list_workspaces(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the workspaces. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspaces. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces from a previous call to list workspaces.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfWorkspace:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_workspaces(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the workspaces. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspaces. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces from a previous call to list workspaces.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfWorkspace, Awaitable[PagedResourceListOfWorkspace]]:  # noqa: E501
+    def list_workspaces(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the workspaces. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspaces. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces from a previous call to list workspaces.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfWorkspace, Awaitable[PagedResourceListOfWorkspace]]:  # noqa: E501
         """[EXPERIMENTAL] ListWorkspaces: List workspaces.  # noqa: E501
 
         List workspaces.  # noqa: E501
@@ -1353,7 +1350,7 @@ class WorkspaceApi:
         return self.list_workspaces_with_http_info(visibility, as_at, page, sort_by, limit, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_workspaces_with_http_info(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the workspaces. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspaces. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces from a previous call to list workspaces.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_workspaces_with_http_info(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the workspaces. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspaces. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces from a previous call to list workspaces.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] ListWorkspaces: List workspaces.  # noqa: E501
 
         List workspaces.  # noqa: E501
@@ -1500,15 +1497,15 @@ class WorkspaceApi:
 
 
     @overload
-    async def search_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfItemAndWorkspace:  # noqa: E501
+    async def search_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfItemAndWorkspace:  # noqa: E501
         ...
 
     @overload
-    def search_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfItemAndWorkspace:  # noqa: E501
+    def search_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfItemAndWorkspace:  # noqa: E501
         ...
 
     @validate_arguments
-    def search_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfItemAndWorkspace, Awaitable[PagedResourceListOfItemAndWorkspace]]:  # noqa: E501
+    def search_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfItemAndWorkspace, Awaitable[PagedResourceListOfItemAndWorkspace]]:  # noqa: E501
         """[EXPERIMENTAL] SearchItems: List items across all workspaces.  # noqa: E501
 
         List items across all workspaces.  # noqa: E501
@@ -1549,7 +1546,7 @@ class WorkspaceApi:
         return self.search_items_with_http_info(visibility, as_at, page, sort_by, limit, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def search_items_with_http_info(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def search_items_with_http_info(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] SearchItems: List items across all workspaces.  # noqa: E501
 
         List items across all workspaces.  # noqa: E501

lusid/api_client.py

@@ -226,7 +226,7 @@ class ApiClient:
                 _request_timeout=_request_timeout,
                 opts=opts)
         except ApiException as e:
-            if e.body:
+            if e.body and isinstance(e.body, bytes):
                 e.body = e.body.decode('utf-8')
             raise e
 

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.8409\n"\
+               "Version of the API: 0.11.8421\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 

lusid/exceptions.py

@@ -11,6 +11,8 @@
     Do not edit the class manually.
 """
 
+from typing import Any, Optional
+from typing_extensions import Self
 
 class OpenApiException(Exception):
     """The base exception class for all OpenAPIExceptions"""
@@ -101,17 +103,56 @@ class ApiKeyError(OpenApiException, KeyError):
 
 class ApiException(OpenApiException):
 
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
+    def __init__(
+        self, 
+        status=None, 
+        reason=None, 
+        http_resp=None,
+        *,
+        body: Optional[str] = None,
+        data: Optional[Any] = None,
+    ) -> None:
+        self.status = status
+        self.reason = reason
+        self.body = body
+        self.data = data
+        self.headers = None
+
         if http_resp:
-            self.status = http_resp.status
-            self.reason = http_resp.reason
-            self.body = http_resp.data
+            if self.status is None:
+                self.status = http_resp.status
+            if self.reason is None:
+                self.reason = http_resp.reason
+            if self.body is None:
+                try:
+                    self.body = http_resp.data.decode('utf-8')
+                except Exception:
+                    pass
             self.headers = http_resp.getheaders()
-        else:
-            self.status = status
-            self.reason = reason
-            self.body = None
-            self.headers = None
+
+    @classmethod
+    def from_response(
+        cls, 
+        *, 
+        http_resp, 
+        body: Optional[str], 
+        data: Optional[Any],
+    ) -> Self:
+        if http_resp.status == 400:
+            raise BadRequestException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 401:
+            raise UnauthorizedException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 403:
+            raise ForbiddenException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 404:
+            raise NotFoundException(http_resp=http_resp, body=body, data=data)
+
+        if 500 <= http_resp.status <= 599:
+            raise ServiceException(http_resp=http_resp, body=body, data=data)
+        raise ApiException(http_resp=http_resp, body=body, data=data)
 
     def __str__(self):
         """Custom error messages for exception"""
@@ -121,38 +162,30 @@ class ApiException(OpenApiException):
             error_message += "HTTP response headers: {0}\n".format(
                 self.headers)
 
-        if self.body:
-            error_message += "HTTP response body: {0}\n".format(self.body)
+        if self.data or self.body:
+            error_message += "HTTP response body: {0}\n".format(self.data or self.body)
 
         return error_message
 
+
 class BadRequestException(ApiException):
+    pass
 
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(BadRequestException, self).__init__(status, reason, http_resp)
 
 class NotFoundException(ApiException):
-
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(NotFoundException, self).__init__(status, reason, http_resp)
+    pass
 
 
 class UnauthorizedException(ApiException):
-
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(UnauthorizedException, self).__init__(status, reason, http_resp)
+    pass
 
 
 class ForbiddenException(ApiException):
-
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(ForbiddenException, self).__init__(status, reason, http_resp)
+    pass
 
 
 class ServiceException(ApiException):
-
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(ServiceException, self).__init__(status, reason, http_resp)
+    pass
 
 
 def render_path(path_to_item):

lusid/extensions/api_client.py

@@ -225,7 +225,7 @@ class SyncApiClient:
                 _request_timeout=_request_timeout,
                 opts=opts)
         except ApiException as e:
-            if e.body:
+            if e.body and isinstance(e.body, bytes):
                 e.body = e.body.decode('utf-8')
             raise e
 

lusid/models/a2_b_breakdown.py

@@ -18,16 +18,18 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional, Union
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictFloat, StrictInt, StrictStr 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 
 class A2BBreakdown(BaseModel):
     """
     A2B Breakdown - Shows the total, and each sub-element within an A2B Category  # noqa: E501
     """
-    total: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="The total value of all the components within this category.")
+    total: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The total value of all the components within this category.")
     currency:  Optional[StrictStr] = Field(None,alias="currency", description="The currency. Applies to the Total, as well as all the componenents.") 
-    components: Optional[Dict[str, Union[StrictFloat, StrictInt]]] = Field(None, description="The individual components that make up the category. For example, the Start category may have Cost, Unrealised gains and accrued interest components.")
+    components: Optional[Dict[str, Union[StrictFloat, StrictInt]]] = Field(default=None, description="The individual components that make up the category. For example, the Start category may have Cost, Unrealised gains and accrued interest components.")
     __properties = ["total", "currency", "components"]
 
     class Config:
@@ -89,3 +91,5 @@ class A2BBreakdown(BaseModel):
             "components": obj.get("components")
         })
         return _obj
+
+A2BBreakdown.update_forward_refs()

lusid/models/a2_b_category.py

@@ -18,16 +18,18 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.a2_b_breakdown import A2BBreakdown
 
 class A2BCategory(BaseModel):
     """
     A2B Category - one of the five major categories in the A2BDataRecord  # noqa: E501
     """
-    holding_currency: Optional[A2BBreakdown] = Field(None, alias="holdingCurrency")
-    portfolio_currency: Optional[A2BBreakdown] = Field(None, alias="portfolioCurrency")
+    holding_currency: Optional[A2BBreakdown] = Field(default=None, alias="holdingCurrency")
+    portfolio_currency: Optional[A2BBreakdown] = Field(default=None, alias="portfolioCurrency")
     __properties = ["holdingCurrency", "portfolioCurrency"]
 
     class Config:
@@ -84,3 +86,5 @@ class A2BCategory(BaseModel):
             "portfolio_currency": A2BBreakdown.from_dict(obj.get("portfolioCurrency")) if obj.get("portfolioCurrency") is not None else None
         })
         return _obj
+
+A2BCategory.update_forward_refs()

lusid/models/a2_b_data_record.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.a2_b_category import A2BCategory
 from lusid.models.model_property import ModelProperty
 from lusid.models.perpetual_property import PerpetualProperty
@@ -30,11 +32,11 @@ class A2BDataRecord(BaseModel):
     """
     A2B Record - shows values on, and changes between two dates: A and B  # noqa: E501
     """
-    portfolio_id: Optional[ResourceId] = Field(None, alias="portfolioId")
+    portfolio_id: Optional[ResourceId] = Field(default=None, alias="portfolioId")
     holding_type:  Optional[StrictStr] = Field(None,alias="holdingType", description="The code for the type of the holding e.g. P, B, C, R, F etc.") 
     instrument_scope:  Optional[StrictStr] = Field(None,alias="instrumentScope", description="The unique Lusid Instrument Id (LUID) of the instrument that the holding is in.") 
     instrument_uid:  Optional[StrictStr] = Field(None,alias="instrumentUid", description="The unique Lusid Instrument Id (LUID) of the instrument that the holding is in.") 
-    sub_holding_keys: Optional[Dict[str, PerpetualProperty]] = Field(None, alias="subHoldingKeys", description="The sub-holding properties which identify the holding. Each property will be from the 'Transaction' domain. These are configured on a transaction portfolio.")
+    sub_holding_keys: Optional[Dict[str, PerpetualProperty]] = Field(default=None, description="The sub-holding properties which identify the holding. Each property will be from the 'Transaction' domain. These are configured on a transaction portfolio.", alias="subHoldingKeys")
     currency:  Optional[StrictStr] = Field(None,alias="currency", description="The holding currency.") 
     transaction_id:  Optional[StrictStr] = Field(None,alias="transactionId", description="The unique identifier for the transaction.") 
     start: Optional[A2BCategory] = None
@@ -42,9 +44,9 @@ class A2BDataRecord(BaseModel):
     gains: Optional[A2BCategory] = None
     carry: Optional[A2BCategory] = None
     end: Optional[A2BCategory] = None
-    properties: Optional[Dict[str, ModelProperty]] = Field(None, description="The properties which have been requested to be decorated onto the holding. These will be from the 'Instrument' domain.")
+    properties: Optional[Dict[str, ModelProperty]] = Field(default=None, description="The properties which have been requested to be decorated onto the holding. These will be from the 'Instrument' domain.")
     group_id:  Optional[StrictStr] = Field(None,alias="groupId", description="Arbitrary string that can be used to cross reference an entry in the A2B report with activity in the A2B-Movements. This should be used purely as a token. The content should not be relied upon.") 
-    errors: Optional[conlist(ResponseMetaData)] = Field(None, description="Any errors with the record are reported here.")
+    errors: Optional[List[ResponseMetaData]] = Field(default=None, description="Any errors with the record are reported here.")
     __properties = ["portfolioId", "holdingType", "instrumentScope", "instrumentUid", "subHoldingKeys", "currency", "transactionId", "start", "flows", "gains", "carry", "end", "properties", "groupId", "errors"]
 
     class Config:
@@ -202,3 +204,5 @@ class A2BDataRecord(BaseModel):
             "errors": [ResponseMetaData.from_dict(_item) for _item in obj.get("errors")] if obj.get("errors") is not None else None
         })
         return _obj
+
+A2BDataRecord.update_forward_refs()

lusid/models/a2_b_movement_record.py

@@ -17,9 +17,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictFloat, StrictInt, StrictStr, conlist 
 from lusid.models.a2_b_category import A2BCategory
 from lusid.models.model_property import ModelProperty
 from lusid.models.perpetual_property import PerpetualProperty
@@ -30,24 +32,24 @@ class A2BMovementRecord(BaseModel):
     """
     A2B Movement Record - shows A2B category based changes relating to a specific movement  # noqa: E501
     """
-    portfolio_id: Optional[ResourceId] = Field(None, alias="portfolioId")
+    portfolio_id: Optional[ResourceId] = Field(default=None, alias="portfolioId")
     holding_type:  Optional[StrictStr] = Field(None,alias="holdingType", description="The code for the type of the holding e.g. P, B, C, R, F etc.") 
     instrument_scope:  Optional[StrictStr] = Field(None,alias="instrumentScope", description="The unique Lusid Instrument Id (LUID) of the instrument that the holding is in.") 
     instrument_uid:  Optional[StrictStr] = Field(None,alias="instrumentUid", description="The unique Lusid Instrument Id (LUID) of the instrument that the holding is in.") 
-    sub_holding_keys: Optional[Dict[str, PerpetualProperty]] = Field(None, alias="subHoldingKeys", description="The sub-holding properties which identify the holding. Each property will be from the 'Transaction' domain. These are configured on a transaction portfolio.")
+    sub_holding_keys: Optional[Dict[str, PerpetualProperty]] = Field(default=None, description="The sub-holding properties which identify the holding. Each property will be from the 'Transaction' domain. These are configured on a transaction portfolio.", alias="subHoldingKeys")
     currency:  Optional[StrictStr] = Field(None,alias="currency", description="The holding currency.") 
     transaction_id:  Optional[StrictStr] = Field(None,alias="transactionId", description="The unique identifier for the transaction.") 
     movement_name:  Optional[StrictStr] = Field(None,alias="movementName", description="The name of the movement.") 
-    effective_date: Optional[datetime] = Field(None, alias="effectiveDate", description="The date of the movement.")
-    units: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="The number of units of the instrument that are affected by the movement.")
+    effective_date: Optional[datetime] = Field(default=None, description="The date of the movement.", alias="effectiveDate")
+    units: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The number of units of the instrument that are affected by the movement.")
     start: Optional[A2BCategory] = None
     flows: Optional[A2BCategory] = None
     gains: Optional[A2BCategory] = None
     carry: Optional[A2BCategory] = None
     end: Optional[A2BCategory] = None
-    properties: Optional[Dict[str, ModelProperty]] = Field(None, description="The properties which have been requested to be decorated onto the holding. These will be from the 'Instrument' domain.")
+    properties: Optional[Dict[str, ModelProperty]] = Field(default=None, description="The properties which have been requested to be decorated onto the holding. These will be from the 'Instrument' domain.")
     group_id:  Optional[StrictStr] = Field(None,alias="groupId", description="Arbitrary string that can be used to cross reference an entry in the A2B report with activity in the A2B-Movements. This should be used purely as a token. The content should not be relied upon.") 
-    errors: Optional[conlist(ResponseMetaData)] = Field(None, description="Any errors with the record are reported here.")
+    errors: Optional[List[ResponseMetaData]] = Field(default=None, description="Any errors with the record are reported here.")
     __properties = ["portfolioId", "holdingType", "instrumentScope", "instrumentUid", "subHoldingKeys", "currency", "transactionId", "movementName", "effectiveDate", "units", "start", "flows", "gains", "carry", "end", "properties", "groupId", "errors"]
 
     class Config:
@@ -213,3 +215,5 @@ class A2BMovementRecord(BaseModel):
             "errors": [ResponseMetaData.from_dict(_item) for _item in obj.get("errors")] if obj.get("errors") is not None else None
         })
         return _obj
+
+A2BMovementRecord.update_forward_refs()