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

lusid/api/reference_portfolio_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, conlist, constr, validator
-
-from typing import Optional
-
+from pydantic.v1 import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
 from lusid.models.create_reference_portfolio_request import CreateReferencePortfolioRequest
 from lusid.models.get_reference_portfolio_constituents_response import GetReferencePortfolioConstituentsResponse
 from lusid.models.portfolio import Portfolio
@@ -62,15 +59,15 @@ class ReferencePortfolioApi:
 
 
     @overload
-    async def create_reference_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the reference portfolio.")], create_reference_portfolio_request : Annotated[CreateReferencePortfolioRequest, Field(..., description="The definition of the reference portfolio.")], **kwargs) -> Portfolio:  # noqa: E501
+    async def create_reference_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the reference portfolio.")], create_reference_portfolio_request : Annotated[CreateReferencePortfolioRequest, Field(description="The definition of the reference portfolio.")], **kwargs) -> Portfolio:  # noqa: E501
         ...
 
     @overload
-    def create_reference_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the reference portfolio.")], create_reference_portfolio_request : Annotated[CreateReferencePortfolioRequest, Field(..., description="The definition of the reference portfolio.")], async_req: Optional[bool]=True, **kwargs) -> Portfolio:  # noqa: E501
+    def create_reference_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the reference portfolio.")], create_reference_portfolio_request : Annotated[CreateReferencePortfolioRequest, Field(description="The definition of the reference portfolio.")], async_req: Optional[bool]=True, **kwargs) -> Portfolio:  # noqa: E501
         ...
 
     @validate_arguments
-    def create_reference_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the reference portfolio.")], create_reference_portfolio_request : Annotated[CreateReferencePortfolioRequest, Field(..., description="The definition of the reference portfolio.")], async_req: Optional[bool]=None, **kwargs) -> Union[Portfolio, Awaitable[Portfolio]]:  # noqa: E501
+    def create_reference_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the reference portfolio.")], create_reference_portfolio_request : Annotated[CreateReferencePortfolioRequest, Field(description="The definition of the reference portfolio.")], async_req: Optional[bool]=None, **kwargs) -> Union[Portfolio, Awaitable[Portfolio]]:  # noqa: E501
         """CreateReferencePortfolio: Create reference portfolio  # noqa: E501
 
         Create a reference portfolio in a particular scope.  # noqa: E501
@@ -103,7 +100,7 @@ class ReferencePortfolioApi:
         return self.create_reference_portfolio_with_http_info(scope, create_reference_portfolio_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def create_reference_portfolio_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the reference portfolio.")], create_reference_portfolio_request : Annotated[CreateReferencePortfolioRequest, Field(..., description="The definition of the reference portfolio.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def create_reference_portfolio_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the reference portfolio.")], create_reference_portfolio_request : Annotated[CreateReferencePortfolioRequest, Field(description="The definition of the reference portfolio.")], **kwargs) -> ApiResponse:  # noqa: E501
         """CreateReferencePortfolio: Create reference portfolio  # noqa: E501
 
         Create a reference portfolio in a particular scope.  # noqa: E501
@@ -229,15 +226,15 @@ class ReferencePortfolioApi:
 
 
     @overload
-    async def get_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective date of the constituents to retrieve. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve constituents. Defaults to return the latest version              of each constituent if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Instrument' or 'ReferenceHolding' domain to decorate onto              constituents. These take the format {domain}/{scope}/{code} e.g. 'Instrument/system/Name' or              'ReferenceHolding/strategy/quantsignal'. Defaults to return all available instrument and reference holding properties if not specified.")] = None, **kwargs) -> GetReferencePortfolioConstituentsResponse:  # noqa: E501
+    async def get_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective date of the constituents to retrieve. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve constituents. Defaults to return the latest version              of each constituent if not specified.")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'Instrument' or 'ReferenceHolding' domain to decorate onto              constituents. These take the format {domain}/{scope}/{code} e.g. 'Instrument/system/Name' or              'ReferenceHolding/strategy/quantsignal'. Defaults to return all available instrument and reference holding properties if not specified.")] = None, **kwargs) -> GetReferencePortfolioConstituentsResponse:  # noqa: E501
         ...
 
     @overload
-    def get_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective date of the constituents to retrieve. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve constituents. Defaults to return the latest version              of each constituent if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Instrument' or 'ReferenceHolding' domain to decorate onto              constituents. These take the format {domain}/{scope}/{code} e.g. 'Instrument/system/Name' or              'ReferenceHolding/strategy/quantsignal'. Defaults to return all available instrument and reference holding properties if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> GetReferencePortfolioConstituentsResponse:  # noqa: E501
+    def get_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective date of the constituents to retrieve. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve constituents. Defaults to return the latest version              of each constituent if not specified.")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'Instrument' or 'ReferenceHolding' domain to decorate onto              constituents. These take the format {domain}/{scope}/{code} e.g. 'Instrument/system/Name' or              'ReferenceHolding/strategy/quantsignal'. Defaults to return all available instrument and reference holding properties if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> GetReferencePortfolioConstituentsResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective date of the constituents to retrieve. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve constituents. Defaults to return the latest version              of each constituent if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Instrument' or 'ReferenceHolding' domain to decorate onto              constituents. These take the format {domain}/{scope}/{code} e.g. 'Instrument/system/Name' or              'ReferenceHolding/strategy/quantsignal'. Defaults to return all available instrument and reference holding properties if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[GetReferencePortfolioConstituentsResponse, Awaitable[GetReferencePortfolioConstituentsResponse]]:  # noqa: E501
+    def get_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective date of the constituents to retrieve. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve constituents. Defaults to return the latest version              of each constituent if not specified.")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'Instrument' or 'ReferenceHolding' domain to decorate onto              constituents. These take the format {domain}/{scope}/{code} e.g. 'Instrument/system/Name' or              'ReferenceHolding/strategy/quantsignal'. Defaults to return all available instrument and reference holding properties if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[GetReferencePortfolioConstituentsResponse, Awaitable[GetReferencePortfolioConstituentsResponse]]:  # noqa: E501
         """GetReferencePortfolioConstituents: Get reference portfolio constituents  # noqa: E501
 
         Get constituents from a reference portfolio at a particular effective time.  # noqa: E501
@@ -276,7 +273,7 @@ class ReferencePortfolioApi:
         return self.get_reference_portfolio_constituents_with_http_info(scope, code, effective_at, as_at, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_reference_portfolio_constituents_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective date of the constituents to retrieve. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve constituents. Defaults to return the latest version              of each constituent if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Instrument' or 'ReferenceHolding' domain to decorate onto              constituents. These take the format {domain}/{scope}/{code} e.g. 'Instrument/system/Name' or              'ReferenceHolding/strategy/quantsignal'. Defaults to return all available instrument and reference holding properties if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_reference_portfolio_constituents_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective date of the constituents to retrieve. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve constituents. Defaults to return the latest version              of each constituent if not specified.")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'Instrument' or 'ReferenceHolding' domain to decorate onto              constituents. These take the format {domain}/{scope}/{code} e.g. 'Instrument/system/Name' or              'ReferenceHolding/strategy/quantsignal'. Defaults to return all available instrument and reference holding properties if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetReferencePortfolioConstituents: Get reference portfolio constituents  # noqa: E501
 
         Get constituents from a reference portfolio at a particular effective time.  # noqa: E501
@@ -604,15 +601,15 @@ class ReferencePortfolioApi:
 
 
     @overload
-    async def upsert_reference_portfolio_constituent_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(..., description="The request to modify properties for the constituent.")], **kwargs) -> UpsertReferencePortfolioConstituentPropertiesResponse:  # noqa: E501
+    async def upsert_reference_portfolio_constituent_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(description="The request to modify properties for the constituent.")], **kwargs) -> UpsertReferencePortfolioConstituentPropertiesResponse:  # noqa: E501
         ...
 
     @overload
-    def upsert_reference_portfolio_constituent_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(..., description="The request to modify properties for the constituent.")], async_req: Optional[bool]=True, **kwargs) -> UpsertReferencePortfolioConstituentPropertiesResponse:  # noqa: E501
+    def upsert_reference_portfolio_constituent_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(description="The request to modify properties for the constituent.")], async_req: Optional[bool]=True, **kwargs) -> UpsertReferencePortfolioConstituentPropertiesResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_reference_portfolio_constituent_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(..., description="The request to modify properties for the constituent.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertReferencePortfolioConstituentPropertiesResponse, Awaitable[UpsertReferencePortfolioConstituentPropertiesResponse]]:  # noqa: E501
+    def upsert_reference_portfolio_constituent_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(description="The request to modify properties for the constituent.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertReferencePortfolioConstituentPropertiesResponse, Awaitable[UpsertReferencePortfolioConstituentPropertiesResponse]]:  # noqa: E501
         """[EARLY ACCESS] UpsertReferencePortfolioConstituentProperties: Upsert constituent properties  # noqa: E501
 
         Create or update one or more constituent properties for a single constituent in the reference portfolio.  Each property will be updated if it already exists, created if it does not and deleted if value is null.  Both constituent and portfolio must exist at the time when properties are created or updated.  # noqa: E501
@@ -647,7 +644,7 @@ class ReferencePortfolioApi:
         return self.upsert_reference_portfolio_constituent_properties_with_http_info(scope, code, upsert_reference_portfolio_constituent_properties_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_reference_portfolio_constituent_properties_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(..., description="The request to modify properties for the constituent.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_reference_portfolio_constituent_properties_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(description="The request to modify properties for the constituent.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] UpsertReferencePortfolioConstituentProperties: Upsert constituent properties  # noqa: E501
 
         Create or update one or more constituent properties for a single constituent in the reference portfolio.  Each property will be updated if it already exists, created if it does not and deleted if value is null.  Both constituent and portfolio must exist at the time when properties are created or updated.  # noqa: E501
@@ -779,15 +776,15 @@ class ReferencePortfolioApi:
 
 
     @overload
-    async def upsert_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituents_request : Annotated[UpsertReferencePortfolioConstituentsRequest, Field(..., description="The constituents to upload to the reference portfolio.")], **kwargs) -> UpsertReferencePortfolioConstituentsResponse:  # noqa: E501
+    async def upsert_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituents_request : Annotated[UpsertReferencePortfolioConstituentsRequest, Field(description="The constituents to upload to the reference portfolio.")], **kwargs) -> UpsertReferencePortfolioConstituentsResponse:  # noqa: E501
         ...
 
     @overload
-    def upsert_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituents_request : Annotated[UpsertReferencePortfolioConstituentsRequest, Field(..., description="The constituents to upload to the reference portfolio.")], async_req: Optional[bool]=True, **kwargs) -> UpsertReferencePortfolioConstituentsResponse:  # noqa: E501
+    def upsert_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituents_request : Annotated[UpsertReferencePortfolioConstituentsRequest, Field(description="The constituents to upload to the reference portfolio.")], async_req: Optional[bool]=True, **kwargs) -> UpsertReferencePortfolioConstituentsResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituents_request : Annotated[UpsertReferencePortfolioConstituentsRequest, Field(..., description="The constituents to upload to the reference portfolio.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertReferencePortfolioConstituentsResponse, Awaitable[UpsertReferencePortfolioConstituentsResponse]]:  # noqa: E501
+    def upsert_reference_portfolio_constituents(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituents_request : Annotated[UpsertReferencePortfolioConstituentsRequest, Field(description="The constituents to upload to the reference portfolio.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertReferencePortfolioConstituentsResponse, Awaitable[UpsertReferencePortfolioConstituentsResponse]]:  # noqa: E501
         """UpsertReferencePortfolioConstituents: Upsert reference portfolio constituents  # noqa: E501
 
         Add constituents to a reference portfolio.  # noqa: E501
@@ -822,7 +819,7 @@ class ReferencePortfolioApi:
         return self.upsert_reference_portfolio_constituents_with_http_info(scope, code, upsert_reference_portfolio_constituents_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_reference_portfolio_constituents_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituents_request : Annotated[UpsertReferencePortfolioConstituentsRequest, Field(..., description="The constituents to upload to the reference portfolio.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_reference_portfolio_constituents_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the reference portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituents_request : Annotated[UpsertReferencePortfolioConstituentsRequest, Field(description="The constituents to upload to the reference portfolio.")], **kwargs) -> ApiResponse:  # noqa: E501
         """UpsertReferencePortfolioConstituents: Upsert reference portfolio constituents  # noqa: E501
 
         Add constituents to a reference portfolio.  # noqa: E501

lusid/api/relation_definitions_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, constr, validator
-
+from pydantic.v1 import Field
 from typing import Optional
-
+from typing_extensions import Annotated
 from lusid.models.create_relation_definition_request import CreateRelationDefinitionRequest
 from lusid.models.deleted_entity_response import DeletedEntityResponse
 from lusid.models.relation_definition import RelationDefinition
@@ -57,15 +54,15 @@ class RelationDefinitionsApi:
 
 
     @overload
-    async def create_relation_definition(self, create_relation_definition_request : Annotated[CreateRelationDefinitionRequest, Field(..., description="The definition of the new relation.")], **kwargs) -> RelationDefinition:  # noqa: E501
+    async def create_relation_definition(self, create_relation_definition_request : Annotated[CreateRelationDefinitionRequest, Field(description="The definition of the new relation.")], **kwargs) -> RelationDefinition:  # noqa: E501
         ...
 
     @overload
-    def create_relation_definition(self, create_relation_definition_request : Annotated[CreateRelationDefinitionRequest, Field(..., description="The definition of the new relation.")], async_req: Optional[bool]=True, **kwargs) -> RelationDefinition:  # noqa: E501
+    def create_relation_definition(self, create_relation_definition_request : Annotated[CreateRelationDefinitionRequest, Field(description="The definition of the new relation.")], async_req: Optional[bool]=True, **kwargs) -> RelationDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def create_relation_definition(self, create_relation_definition_request : Annotated[CreateRelationDefinitionRequest, Field(..., description="The definition of the new relation.")], async_req: Optional[bool]=None, **kwargs) -> Union[RelationDefinition, Awaitable[RelationDefinition]]:  # noqa: E501
+    def create_relation_definition(self, create_relation_definition_request : Annotated[CreateRelationDefinitionRequest, Field(description="The definition of the new relation.")], async_req: Optional[bool]=None, **kwargs) -> Union[RelationDefinition, Awaitable[RelationDefinition]]:  # noqa: E501
         """[EXPERIMENTAL] CreateRelationDefinition: Create a relation definition  # noqa: E501
 
         Define a new relation.  # noqa: E501
@@ -96,7 +93,7 @@ class RelationDefinitionsApi:
         return self.create_relation_definition_with_http_info(create_relation_definition_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def create_relation_definition_with_http_info(self, create_relation_definition_request : Annotated[CreateRelationDefinitionRequest, Field(..., description="The definition of the new relation.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def create_relation_definition_with_http_info(self, create_relation_definition_request : Annotated[CreateRelationDefinitionRequest, Field(description="The definition of the new relation.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] CreateRelationDefinition: Create a relation definition  # noqa: E501
 
         Define a new relation.  # noqa: E501

lusid/api/relational_dataset_definition_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.create_relational_dataset_definition_request import CreateRelationalDatasetDefinitionRequest
 from lusid.models.deleted_entity_response import DeletedEntityResponse
 from lusid.models.paged_resource_list_of_relational_dataset_definition import PagedResourceListOfRelationalDatasetDefinition
@@ -59,15 +56,15 @@ class RelationalDatasetDefinitionApi:
 
 
     @overload
-    async def create_relational_dataset_definition(self, create_relational_dataset_definition_request : Annotated[CreateRelationalDatasetDefinitionRequest, Field(..., description="The relational dataset definition to create.")], **kwargs) -> RelationalDatasetDefinition:  # noqa: E501
+    async def create_relational_dataset_definition(self, create_relational_dataset_definition_request : Annotated[CreateRelationalDatasetDefinitionRequest, Field(description="The relational dataset definition to create.")], **kwargs) -> RelationalDatasetDefinition:  # noqa: E501
         ...
 
     @overload
-    def create_relational_dataset_definition(self, create_relational_dataset_definition_request : Annotated[CreateRelationalDatasetDefinitionRequest, Field(..., description="The relational dataset definition to create.")], async_req: Optional[bool]=True, **kwargs) -> RelationalDatasetDefinition:  # noqa: E501
+    def create_relational_dataset_definition(self, create_relational_dataset_definition_request : Annotated[CreateRelationalDatasetDefinitionRequest, Field(description="The relational dataset definition to create.")], async_req: Optional[bool]=True, **kwargs) -> RelationalDatasetDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def create_relational_dataset_definition(self, create_relational_dataset_definition_request : Annotated[CreateRelationalDatasetDefinitionRequest, Field(..., description="The relational dataset definition to create.")], async_req: Optional[bool]=None, **kwargs) -> Union[RelationalDatasetDefinition, Awaitable[RelationalDatasetDefinition]]:  # noqa: E501
+    def create_relational_dataset_definition(self, create_relational_dataset_definition_request : Annotated[CreateRelationalDatasetDefinitionRequest, Field(description="The relational dataset definition to create.")], async_req: Optional[bool]=None, **kwargs) -> Union[RelationalDatasetDefinition, Awaitable[RelationalDatasetDefinition]]:  # noqa: E501
         """[EARLY ACCESS] CreateRelationalDatasetDefinition: Create a Relational Dataset Definition  # noqa: E501
 
         Create a new relational dataset definition.  # noqa: E501
@@ -98,7 +95,7 @@ class RelationalDatasetDefinitionApi:
         return self.create_relational_dataset_definition_with_http_info(create_relational_dataset_definition_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def create_relational_dataset_definition_with_http_info(self, create_relational_dataset_definition_request : Annotated[CreateRelationalDatasetDefinitionRequest, Field(..., description="The relational dataset definition to create.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def create_relational_dataset_definition_with_http_info(self, create_relational_dataset_definition_request : Annotated[CreateRelationalDatasetDefinitionRequest, Field(description="The relational dataset definition to create.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] CreateRelationalDatasetDefinition: Create a Relational Dataset Definition  # noqa: E501
 
         Create a new relational dataset definition.  # noqa: E501
@@ -549,15 +546,15 @@ class RelationalDatasetDefinitionApi:
 
 
     @overload
-    async def list_relational_dataset_definitions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the relational dataset definitions. Defaults to return the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing relational dataset definitions from a previous call to list relational dataset definitions.")] = 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.")] = None, **kwargs) -> PagedResourceListOfRelationalDatasetDefinition:  # noqa: E501
+    async def list_relational_dataset_definitions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the relational dataset definitions. Defaults to return the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing relational dataset definitions from a previous call to list relational dataset definitions.")] = 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.")] = None, **kwargs) -> PagedResourceListOfRelationalDatasetDefinition:  # noqa: E501
         ...
 
     @overload
-    def list_relational_dataset_definitions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the relational dataset definitions. Defaults to return the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing relational dataset definitions from a previous call to list relational dataset definitions.")] = 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.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfRelationalDatasetDefinition:  # noqa: E501
+    def list_relational_dataset_definitions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the relational dataset definitions. Defaults to return the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing relational dataset definitions from a previous call to list relational dataset definitions.")] = 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.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfRelationalDatasetDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_relational_dataset_definitions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the relational dataset definitions. Defaults to return the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing relational dataset definitions from a previous call to list relational dataset definitions.")] = 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.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfRelationalDatasetDefinition, Awaitable[PagedResourceListOfRelationalDatasetDefinition]]:  # noqa: E501
+    def list_relational_dataset_definitions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the relational dataset definitions. Defaults to return the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing relational dataset definitions from a previous call to list relational dataset definitions.")] = 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.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfRelationalDatasetDefinition, Awaitable[PagedResourceListOfRelationalDatasetDefinition]]:  # noqa: E501
         """[EARLY ACCESS] ListRelationalDatasetDefinitions: List Relational Dataset Definitions  # noqa: E501
 
         List all relational dataset definitions matching particular criteria.  # noqa: E501
@@ -596,7 +593,7 @@ class RelationalDatasetDefinitionApi:
         return self.list_relational_dataset_definitions_with_http_info(as_at, page, sort_by, limit, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_relational_dataset_definitions_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the relational dataset definitions. Defaults to return the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing relational dataset definitions from a previous call to list relational dataset definitions.")] = 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.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_relational_dataset_definitions_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the relational dataset definitions. Defaults to return the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing relational dataset definitions from a previous call to list relational dataset definitions.")] = 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.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] ListRelationalDatasetDefinitions: List Relational Dataset Definitions  # noqa: E501
 
         List all relational dataset definitions matching particular criteria.  # noqa: E501

lusid/api/relational_datasets_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, conint, constr, validator
-
+from pydantic.v1 import Field, StrictInt, StrictStr
 from typing import Dict, Optional
-
+from typing_extensions import Annotated
 from lusid.models.batch_upsert_relational_datasets_response import BatchUpsertRelationalDatasetsResponse
 from lusid.models.paged_resource_list_of_relational_data_point_response import PagedResourceListOfRelationalDataPointResponse
 from lusid.models.query_relational_dataset_request import QueryRelationalDatasetRequest
@@ -58,15 +55,15 @@ class RelationalDatasetsApi:
 
 
     @overload
-    async def batch_upsert_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], request_body : Annotated[Dict[str, UpsertRelationalDataPointRequest], Field(..., description="The DataPoints to upsert.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.              Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code.")] = None, **kwargs) -> BatchUpsertRelationalDatasetsResponse:  # noqa: E501
+    async def batch_upsert_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], request_body : Annotated[Dict[str, UpsertRelationalDataPointRequest], Field(description="The DataPoints to upsert.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.              Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code.")] = None, **kwargs) -> BatchUpsertRelationalDatasetsResponse:  # noqa: E501
         ...
 
     @overload
-    def batch_upsert_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], request_body : Annotated[Dict[str, UpsertRelationalDataPointRequest], Field(..., description="The DataPoints to upsert.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.              Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code.")] = None, async_req: Optional[bool]=True, **kwargs) -> BatchUpsertRelationalDatasetsResponse:  # noqa: E501
+    def batch_upsert_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], request_body : Annotated[Dict[str, UpsertRelationalDataPointRequest], Field(description="The DataPoints to upsert.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.              Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code.")] = None, async_req: Optional[bool]=True, **kwargs) -> BatchUpsertRelationalDatasetsResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def batch_upsert_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], request_body : Annotated[Dict[str, UpsertRelationalDataPointRequest], Field(..., description="The DataPoints to upsert.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.              Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpsertRelationalDatasetsResponse, Awaitable[BatchUpsertRelationalDatasetsResponse]]:  # noqa: E501
+    def batch_upsert_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], request_body : Annotated[Dict[str, UpsertRelationalDataPointRequest], Field(description="The DataPoints to upsert.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.              Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpsertRelationalDatasetsResponse, Awaitable[BatchUpsertRelationalDatasetsResponse]]:  # noqa: E501
         """[EXPERIMENTAL] BatchUpsertRelationalData: Batch Upsert Relational Data Points for a given Relational Dataset Definition.  # noqa: E501
 
         Batch Upsert Relational Data Points for a given Relational Dataset Definition.  # noqa: E501
@@ -103,7 +100,7 @@ class RelationalDatasetsApi:
         return self.batch_upsert_relational_data_with_http_info(relational_dataset_definition_scope, relational_dataset_definition_code, request_body, success_mode, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def batch_upsert_relational_data_with_http_info(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], request_body : Annotated[Dict[str, UpsertRelationalDataPointRequest], Field(..., description="The DataPoints to upsert.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.              Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def batch_upsert_relational_data_with_http_info(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], request_body : Annotated[Dict[str, UpsertRelationalDataPointRequest], Field(description="The DataPoints to upsert.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.              Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] BatchUpsertRelationalData: Batch Upsert Relational Data Points for a given Relational Dataset Definition.  # noqa: E501
 
         Batch Upsert Relational Data Points for a given Relational Dataset Definition.  # noqa: E501
@@ -241,15 +238,15 @@ class RelationalDatasetsApi:
 
 
     @overload
-    async def query_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], query_relational_dataset_request : Annotated[QueryRelationalDatasetRequest, Field(..., description="The query request.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dataset(s). Defaults to returning the latest version of each dataset if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to query the datasets.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue query datasets. This value is returned from the previous call.              If a pagination token is provided, the filter, customSortBy, effectiveAt and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, **kwargs) -> PagedResourceListOfRelationalDataPointResponse:  # noqa: E501
+    async def query_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], query_relational_dataset_request : Annotated[QueryRelationalDatasetRequest, Field(description="The query request.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dataset(s). Defaults to returning the latest version of each dataset if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to query the datasets.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue query datasets. This value is returned from the previous call.              If a pagination token is provided, the filter, customSortBy, effectiveAt and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, **kwargs) -> PagedResourceListOfRelationalDataPointResponse:  # noqa: E501
         ...
 
     @overload
-    def query_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], query_relational_dataset_request : Annotated[QueryRelationalDatasetRequest, Field(..., description="The query request.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dataset(s). Defaults to returning the latest version of each dataset if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to query the datasets.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue query datasets. This value is returned from the previous call.              If a pagination token is provided, the filter, customSortBy, effectiveAt and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfRelationalDataPointResponse:  # noqa: E501
+    def query_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], query_relational_dataset_request : Annotated[QueryRelationalDatasetRequest, Field(description="The query request.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dataset(s). Defaults to returning the latest version of each dataset if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to query the datasets.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue query datasets. This value is returned from the previous call.              If a pagination token is provided, the filter, customSortBy, effectiveAt and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfRelationalDataPointResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def query_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], query_relational_dataset_request : Annotated[QueryRelationalDatasetRequest, Field(..., description="The query request.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dataset(s). Defaults to returning the latest version of each dataset if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to query the datasets.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue query datasets. This value is returned from the previous call.              If a pagination token is provided, the filter, customSortBy, effectiveAt and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfRelationalDataPointResponse, Awaitable[PagedResourceListOfRelationalDataPointResponse]]:  # noqa: E501
+    def query_relational_data(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], query_relational_dataset_request : Annotated[QueryRelationalDatasetRequest, Field(description="The query request.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dataset(s). Defaults to returning the latest version of each dataset if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to query the datasets.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue query datasets. This value is returned from the previous call.              If a pagination token is provided, the filter, customSortBy, effectiveAt and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfRelationalDataPointResponse, Awaitable[PagedResourceListOfRelationalDataPointResponse]]:  # noqa: E501
         """[EXPERIMENTAL] QueryRelationalData: Query Relational Data Points for a given Relational Dataset Definition.  # noqa: E501
 
         Query Relational Data Points for a given Relational Dataset Definition.  # noqa: E501
@@ -292,7 +289,7 @@ class RelationalDatasetsApi:
         return self.query_relational_data_with_http_info(relational_dataset_definition_scope, relational_dataset_definition_code, query_relational_dataset_request, as_at, effective_at, page, limit, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def query_relational_data_with_http_info(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], query_relational_dataset_request : Annotated[QueryRelationalDatasetRequest, Field(..., description="The query request.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dataset(s). Defaults to returning the latest version of each dataset if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to query the datasets.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue query datasets. This value is returned from the previous call.              If a pagination token is provided, the filter, customSortBy, effectiveAt and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def query_relational_data_with_http_info(self, relational_dataset_definition_scope : Annotated[StrictStr, Field(..., description="The Scope of the relational dataset definition.")], relational_dataset_definition_code : Annotated[StrictStr, Field(..., description="The Code of the relational dataset definition.")], query_relational_dataset_request : Annotated[QueryRelationalDatasetRequest, Field(description="The query request.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dataset(s). Defaults to returning the latest version of each dataset if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to query the datasets.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue query datasets. This value is returned from the previous call.              If a pagination token is provided, the filter, customSortBy, effectiveAt and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] QueryRelationalData: Query Relational Data Points for a given Relational Dataset Definition.  # noqa: E501
 
         Query Relational Data Points for a given Relational Dataset Definition.  # noqa: E501

lusid/api/relations_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, StrictStr, constr, validator
-
+from pydantic.v1 import Field, StrictStr
 from typing import Optional
-
+from typing_extensions import Annotated
 from lusid.models.complete_relation import CompleteRelation
 from lusid.models.create_relation_request import CreateRelationRequest
 from lusid.models.delete_relation_request import DeleteRelationRequest
@@ -56,15 +54,15 @@ class RelationsApi:
 
 
     @overload
-    async def create_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], create_relation_request : Annotated[CreateRelationRequest, Field(..., description="The details of the relation to create.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> CompleteRelation:  # noqa: E501
+    async def create_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], create_relation_request : Annotated[CreateRelationRequest, Field(description="The details of the relation to create.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> CompleteRelation:  # noqa: E501
         ...
 
     @overload
-    def create_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], create_relation_request : Annotated[CreateRelationRequest, Field(..., description="The details of the relation to create.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> CompleteRelation:  # noqa: E501
+    def create_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], create_relation_request : Annotated[CreateRelationRequest, Field(description="The details of the relation to create.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> CompleteRelation:  # noqa: E501
         ...
 
     @validate_arguments
-    def create_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], create_relation_request : Annotated[CreateRelationRequest, Field(..., description="The details of the relation to create.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[CompleteRelation, Awaitable[CompleteRelation]]:  # noqa: E501
+    def create_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], create_relation_request : Annotated[CreateRelationRequest, Field(description="The details of the relation to create.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[CompleteRelation, Awaitable[CompleteRelation]]:  # noqa: E501
         """[EXPERIMENTAL] CreateRelation: Create Relation  # noqa: E501
 
         Create a relation between two entity objects by their identifiers  # noqa: E501
@@ -101,7 +99,7 @@ class RelationsApi:
         return self.create_relation_with_http_info(scope, code, create_relation_request, effective_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def create_relation_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], create_relation_request : Annotated[CreateRelationRequest, Field(..., description="The details of the relation to create.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def create_relation_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], create_relation_request : Annotated[CreateRelationRequest, Field(description="The details of the relation to create.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] CreateRelation: Create Relation  # noqa: E501
 
         Create a relation between two entity objects by their identifiers  # noqa: E501
@@ -239,15 +237,15 @@ class RelationsApi:
 
 
     @overload
-    async def delete_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], delete_relation_request : Annotated[DeleteRelationRequest, Field(..., description="The details of the relation to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should the deletion be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    async def delete_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], delete_relation_request : Annotated[DeleteRelationRequest, Field(description="The details of the relation to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should the deletion be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @overload
-    def delete_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], delete_relation_request : Annotated[DeleteRelationRequest, Field(..., description="The details of the relation to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should the deletion be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    def delete_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], delete_relation_request : Annotated[DeleteRelationRequest, Field(description="The details of the relation to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should the deletion be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def delete_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], delete_relation_request : Annotated[DeleteRelationRequest, Field(..., description="The details of the relation to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should the deletion be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
+    def delete_relation(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], delete_relation_request : Annotated[DeleteRelationRequest, Field(description="The details of the relation to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should the deletion be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
         """[EXPERIMENTAL] DeleteRelation: Delete a relation  # noqa: E501
 
         Delete a relation between two entity objects represented by their identifiers  # noqa: E501
@@ -284,7 +282,7 @@ class RelationsApi:
         return self.delete_relation_with_http_info(scope, code, delete_relation_request, effective_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def delete_relation_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], delete_relation_request : Annotated[DeleteRelationRequest, Field(..., description="The details of the relation to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should the deletion be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def delete_relation_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the relation definition")], code : Annotated[StrictStr, Field(..., description="The code of the relation definition")], delete_relation_request : Annotated[DeleteRelationRequest, Field(description="The details of the relation to delete.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the relation should the deletion be effective from. Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] DeleteRelation: Delete a relation  # noqa: E501
 
         Delete a relation between two entity objects represented by their identifiers  # noqa: E501