lusid-sdk 2.1.721__py3-none-any.whl → 2.1.723__py3-none-any.whl

lusid/models/custom_data_model.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field
+from pydantic.v1 import StrictStr, Field, BaseModel, Field 
 from lusid.models.custom_data_model_criteria import CustomDataModelCriteria
 from lusid.models.data_model_summary import DataModelSummary
 

lusid/models/custom_data_model_criteria.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, StrictStr, conlist
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist 
 from lusid.models.alias import Alias
 from lusid.models.custom_data_model_identifier_type_specification_with_display_name import CustomDataModelIdentifierTypeSpecificationWithDisplayName
 from lusid.models.custom_data_model_property_specification_with_display_name import CustomDataModelPropertySpecificationWithDisplayName
@@ -29,7 +29,7 @@ class CustomDataModelCriteria(BaseModel):
     """
     CustomDataModelCriteria
     """
-    conditions: Optional[StrictStr] = Field(None, description="The conditions that the bound entity must meet to be valid.")
+    conditions:  Optional[StrictStr] = Field(None,alias="conditions", description="The conditions that the bound entity must meet to be valid.") 
     properties: Optional[conlist(CustomDataModelPropertySpecificationWithDisplayName)] = Field(None, description="The properties that are required or allowed on the bound entity.")
     identifier_types: Optional[conlist(CustomDataModelIdentifierTypeSpecificationWithDisplayName)] = Field(None, alias="identifierTypes", description="The identifier types that are required or allowed on the bound entity.")
     attribute_aliases: Optional[conlist(Alias)] = Field(None, alias="attributeAliases", description="The aliases for property keys, identifier types, and fields on the bound entity.")

lusid/models/custom_data_model_identifier_type_specification.py

@@ -19,13 +19,13 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictBool, StrictStr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool, StrictStr 
 
 class CustomDataModelIdentifierTypeSpecification(BaseModel):
     """
     CustomDataModelIdentifierTypeSpecification
     """
-    identifier_key: StrictStr = Field(..., alias="identifierKey", description="The identifier type that is required/allowed on the bound entity.")
+    identifier_key:  StrictStr = Field(...,alias="identifierKey", description="The identifier type that is required/allowed on the bound entity.") 
     required: Optional[StrictBool] = Field(None, description="Whether identifier type is required or allowed.")
     __properties = ["identifierKey", "required"]
 

lusid/models/custom_data_model_identifier_type_specification_with_display_name.py

@@ -19,14 +19,14 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictBool, StrictStr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool, StrictStr 
 
 class CustomDataModelIdentifierTypeSpecificationWithDisplayName(BaseModel):
     """
     CustomDataModelIdentifierTypeSpecificationWithDisplayName
     """
-    display_name: Optional[StrictStr] = Field(None, alias="displayName", description="The display name of the property definition.")
-    identifier_key: StrictStr = Field(..., alias="identifierKey", description="The identifier type that is required/allowed on the bound entity.")
+    display_name:  Optional[StrictStr] = Field(None,alias="displayName", description="The display name of the property definition.") 
+    identifier_key:  StrictStr = Field(...,alias="identifierKey", description="The identifier type that is required/allowed on the bound entity.") 
     required: Optional[StrictBool] = Field(None, description="Whether identifier type is required or allowed.")
     __properties = ["displayName", "identifierKey", "required"]
 

lusid/models/custom_data_model_property_specification.py

@@ -19,13 +19,13 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictBool, StrictStr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool, StrictStr 
 
 class CustomDataModelPropertySpecification(BaseModel):
     """
     CustomDataModelPropertySpecification
     """
-    property_key: StrictStr = Field(..., alias="propertyKey", description="The property key that is required/allowed on the bound entity.")
+    property_key:  StrictStr = Field(...,alias="propertyKey", description="The property key that is required/allowed on the bound entity.") 
     required: Optional[StrictBool] = Field(None, description="Whether property is required or allowed.")
     __properties = ["propertyKey", "required"]
 

lusid/models/custom_data_model_property_specification_with_display_name.py

@@ -19,14 +19,14 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictBool, StrictStr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool, StrictStr 
 
 class CustomDataModelPropertySpecificationWithDisplayName(BaseModel):
     """
     CustomDataModelPropertySpecificationWithDisplayName
     """
-    display_name: Optional[StrictStr] = Field(None, alias="displayName", description="The display name of the property definition.")
-    property_key: StrictStr = Field(..., alias="propertyKey", description="The property key that is required/allowed on the bound entity.")
+    display_name:  Optional[StrictStr] = Field(None,alias="displayName", description="The display name of the property definition.") 
+    property_key:  StrictStr = Field(...,alias="propertyKey", description="The property key that is required/allowed on the bound entity.") 
     required: Optional[StrictBool] = Field(None, description="Whether property is required or allowed.")
     __properties = ["displayName", "propertyKey", "required"]
 

lusid/models/custom_entity_definition.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, StrictStr, conlist, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist, constr 
 from lusid.models.custom_entity_field_definition import CustomEntityFieldDefinition
 from lusid.models.link import Link
 from lusid.models.version import Version
@@ -28,11 +28,11 @@ class CustomEntityDefinition(BaseModel):
     """
     Representation of Custom Entity Definition on LUSID API  # noqa: E501
     """
-    href: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.")
-    entity_type_name: constr(strict=True, min_length=1) = Field(..., alias="entityTypeName", description="The name provided when the custom entity type was created. This has been prefixed with “~” and returned as “entityType”, which is the identifier for the custom entity type.")
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="A display label for the custom entity type.")
-    description: Optional[StrictStr] = Field(None, description="A description for the custom entity type.")
-    entity_type: constr(strict=True, min_length=1) = Field(..., alias="entityType", description="The identifier for the custom entity type, derived from the “entityTypeName” provided on creation.")
+    href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
+    entity_type_name:  StrictStr = Field(...,alias="entityTypeName", description="The name provided when the custom entity type was created. This has been prefixed with “~” and returned as “entityType”, which is the identifier for the custom entity type.") 
+    display_name:  StrictStr = Field(...,alias="displayName", description="A display label for the custom entity type.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A description for the custom entity type.") 
+    entity_type:  StrictStr = Field(...,alias="entityType", description="The identifier for the custom entity type, derived from the “entityTypeName” provided on creation.") 
     field_schema: conlist(CustomEntityFieldDefinition) = Field(..., alias="fieldSchema", description="The description of the fields on the custom entity type.")
     version: Version = Field(...)
     links: Optional[conlist(Link)] = None

lusid/models/custom_entity_definition_request.py

@@ -19,33 +19,19 @@ import json
 
 
 from typing import Any, Dict, List
-from pydantic.v1 import BaseModel, Field, conlist, constr, validator
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, conlist, constr, validator 
 from lusid.models.custom_entity_field_definition import CustomEntityFieldDefinition
 
 class CustomEntityDefinitionRequest(BaseModel):
     """
     CustomEntityDefinitionRequest
     """
-    entity_type_name: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="entityTypeName", description="A name for the custom entity type. This will be prefixed with “~” and returned as “entityType”, which is the identifier for the custom entity type.")
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="A display label for the custom entity type.")
-    description: constr(strict=True, min_length=1) = Field(..., description="A description for the custom entity type.")
+    entity_type_name:  StrictStr = Field(...,alias="entityTypeName", description="A name for the custom entity type. This will be prefixed with “~” and returned as “entityType”, which is the identifier for the custom entity type.") 
+    display_name:  StrictStr = Field(...,alias="displayName", description="A display label for the custom entity type.") 
+    description:  StrictStr = Field(...,alias="description", description="A description for the custom entity type.") 
     field_schema: conlist(CustomEntityFieldDefinition) = Field(..., alias="fieldSchema", description="The description of the fields on the custom entity type.")
     __properties = ["entityTypeName", "displayName", "description", "fieldSchema"]
 
-    @validator('display_name')
-    def display_name_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if not re.match(r"^[\s\S]*$", value):
-            raise ValueError(r"must validate the regular expression /^[\s\S]*$/")
-        return value
-
-    @validator('description')
-    def description_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if not re.match(r"^[\s\S]*$", value):
-            raise ValueError(r"must validate the regular expression /^[\s\S]*$/")
-        return value
-
     class Config:
         """Pydantic configuration"""
         allow_population_by_field_name = True

lusid/models/custom_entity_entity.py

@@ -19,7 +19,7 @@ import json
 
 from datetime import datetime
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, StrictInt, StrictStr, conlist, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictInt, StrictStr, conlist, constr 
 from lusid.models.custom_entity_response import CustomEntityResponse
 from lusid.models.link import Link
 
@@ -27,17 +27,17 @@ class CustomEntityEntity(BaseModel):
     """
     CustomEntityEntity
     """
-    href: StrictStr = Field(..., description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.")
-    entity_unique_id: constr(strict=True, min_length=1) = Field(..., alias="entityUniqueId", description="The unique id of the entity.")
+    href:  StrictStr = Field(...,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
+    entity_unique_id:  StrictStr = Field(...,alias="entityUniqueId", description="The unique id of the entity.") 
     as_at_version_number: Optional[StrictInt] = Field(None, alias="asAtVersionNumber", description="The integer version number for the entity (the entity was created at version 1)")
-    status: constr(strict=True, min_length=1) = Field(..., description="The status of the entity at the current time.")
+    status:  StrictStr = Field(...,alias="status", description="The status of the entity at the current time.") 
     as_at_deleted: Optional[datetime] = Field(None, alias="asAtDeleted", description="The asAt datetime at which the entity was deleted.")
-    user_id_deleted: Optional[StrictStr] = Field(None, alias="userIdDeleted", description="The unique id of the user who deleted the entity.")
-    request_id_deleted: Optional[StrictStr] = Field(None, alias="requestIdDeleted", description="The unique request id of the command that deleted the entity.")
+    user_id_deleted:  Optional[StrictStr] = Field(None,alias="userIdDeleted", description="The unique id of the user who deleted the entity.") 
+    request_id_deleted:  Optional[StrictStr] = Field(None,alias="requestIdDeleted", description="The unique request id of the command that deleted the entity.") 
     effective_at_created: Optional[datetime] = Field(None, alias="effectiveAtCreated", description="The EffectiveAt this Entity is created, if entity does not currently exist in EffectiveAt.")
     prevailing_custom_entity: Optional[CustomEntityResponse] = Field(None, alias="prevailingCustomEntity")
     deleted_custom_entity: Optional[CustomEntityResponse] = Field(None, alias="deletedCustomEntity")
-    previewed_status: Optional[StrictStr] = Field(None, alias="previewedStatus", description="The status of the previewed entity.")
+    previewed_status:  Optional[StrictStr] = Field(None,alias="previewedStatus", description="The status of the previewed entity.") 
     previewed_custom_entity: Optional[CustomEntityResponse] = Field(None, alias="previewedCustomEntity")
     links: Optional[conlist(Link)] = None
     __properties = ["href", "entityUniqueId", "asAtVersionNumber", "status", "asAtDeleted", "userIdDeleted", "requestIdDeleted", "effectiveAtCreated", "prevailingCustomEntity", "deletedCustomEntity", "previewedStatus", "previewedCustomEntity", "links"]

lusid/models/custom_entity_field.py

@@ -19,13 +19,13 @@ import json
 
 from datetime import datetime
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, constr 
 
 class CustomEntityField(BaseModel):
     """
     CustomEntityField
     """
-    name: constr(strict=True, min_length=1) = Field(..., description="The name of the field in the custom entity type definition.")
+    name:  StrictStr = Field(...,alias="name", description="The name of the field in the custom entity type definition.") 
     value: Optional[Any] = Field(None, description="The value for the field.")
     effective_from: Optional[datetime] = Field(None, alias="effectiveFrom", description="The effective datetime from which the field's value is valid. For timeVariant fields, this defaults to the beginning of time.")
     effective_until: Optional[datetime] = Field(None, alias="effectiveUntil", description="The effective datetime until which the field's value is valid. If not supplied, the value will be valid indefinitely or until the next “effectiveFrom” date of the field.")

lusid/models/custom_entity_field_definition.py

@@ -19,18 +19,18 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictBool, StrictStr, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool, StrictStr, constr 
 
 class CustomEntityFieldDefinition(BaseModel):
     """
     CustomEntityFieldDefinition
     """
-    name: constr(strict=True, min_length=1) = Field(..., description="The name of the field.")
-    lifetime: constr(strict=True, min_length=1) = Field(..., description="Describes how the field’s values can change over time. The available values are: “Perpetual”, “TimeVariant”.")
-    type: constr(strict=True, min_length=1) = Field(..., description="The value type for the field. Available values are: “String”, “Boolean”, “DateTime”, “Decimal”.")
-    collection_type: Optional[StrictStr] = Field(None, alias="collectionType", description="The collection type for the field. Available values are: “Single”, “Array”. Null value defaults to “Single”")
+    name:  StrictStr = Field(...,alias="name", description="The name of the field.") 
+    lifetime:  StrictStr = Field(...,alias="lifetime", description="Describes how the field’s values can change over time. The available values are: “Perpetual”, “TimeVariant”.") 
+    type:  StrictStr = Field(...,alias="type", description="The value type for the field. Available values are: “String”, “Boolean”, “DateTime”, “Decimal”.") 
+    collection_type:  Optional[StrictStr] = Field(None,alias="collectionType", description="The collection type for the field. Available values are: “Single”, “Array”. Null value defaults to “Single”") 
     required: StrictBool = Field(..., description="Whether the field is required or not.")
-    description: Optional[constr(strict=True, max_length=512)] = Field(None, description="An optional description for the field.")
+    description:  Optional[StrictStr] = Field(None,alias="description", description="An optional description for the field.") 
     __properties = ["name", "lifetime", "type", "collectionType", "required", "description"]
 
     class Config:

lusid/models/custom_entity_id.py

@@ -19,40 +19,19 @@ import json
 
 from datetime import datetime
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, constr, validator
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, constr, validator 
 
 class CustomEntityId(BaseModel):
     """
     CustomEntityId
     """
-    identifier_scope: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="identifierScope", description="The scope the identifier resides in (the scope of the identifier property definition).")
-    identifier_type: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="identifierType", description="What the identifier represents (the code of the identifier property definition).")
-    identifier_value: constr(strict=True, max_length=1024, min_length=1) = Field(..., alias="identifierValue", description="The value of the identifier for this entity.")
+    identifier_scope:  StrictStr = Field(...,alias="identifierScope", description="The scope the identifier resides in (the scope of the identifier property definition).") 
+    identifier_type:  StrictStr = Field(...,alias="identifierType", description="What the identifier represents (the code of the identifier property definition).") 
+    identifier_value:  StrictStr = Field(...,alias="identifierValue", description="The value of the identifier for this entity.") 
     effective_from: Optional[datetime] = Field(None, alias="effectiveFrom", description="The effective datetime from which the identifier is valid.")
     effective_until: Optional[datetime] = Field(None, alias="effectiveUntil", description="The effective datetime until which the identifier is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveFrom' datetime of the identifier.")
     __properties = ["identifierScope", "identifierType", "identifierValue", "effectiveFrom", "effectiveUntil"]
 
-    @validator('identifier_scope')
-    def identifier_scope_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
-            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
-        return value
-
-    @validator('identifier_type')
-    def identifier_type_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
-            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
-        return value
-
-    @validator('identifier_value')
-    def identifier_value_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
-            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
-        return value
-
     class Config:
         """Pydantic configuration"""
         allow_population_by_field_name = True

lusid/models/custom_entity_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, conlist, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, conlist, constr 
 from lusid.models.custom_entity_field import CustomEntityField
 from lusid.models.custom_entity_id import CustomEntityId
 
@@ -27,8 +27,8 @@ class CustomEntityRequest(BaseModel):
     """
     CustomEntityRequest
     """
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="A display label for the custom entity.")
-    description: constr(strict=True, min_length=1) = Field(..., description="A description of the custom entity.")
+    display_name:  StrictStr = Field(...,alias="displayName", description="A display label for the custom entity.") 
+    description:  StrictStr = Field(...,alias="description", description="A description of the custom entity.") 
     identifiers: conlist(CustomEntityId) = Field(..., description="The identifiers the custom entity will be upserted with.")
     fields: Optional[conlist(CustomEntityField)] = Field(None, description="The fields that decorate the custom entity.")
     __properties = ["displayName", "description", "identifiers", "fields"]

lusid/models/custom_entity_response.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, StrictStr, conlist, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist, constr 
 from lusid.models.custom_entity_field import CustomEntityField
 from lusid.models.custom_entity_id import CustomEntityId
 from lusid.models.link import Link
@@ -31,12 +31,12 @@ class CustomEntityResponse(BaseModel):
     """
     CustomEntityResponse
     """
-    href: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.")
-    entity_type: constr(strict=True, min_length=1) = Field(..., alias="entityType", description="The type of custom entity this is.")
+    href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
+    entity_type:  StrictStr = Field(...,alias="entityType", description="The type of custom entity this is.") 
     version: Version = Field(...)
     staged_modifications: Optional[StagedModificationsInfo] = Field(None, alias="stagedModifications")
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="A display label for the custom entity.")
-    description: Optional[StrictStr] = Field(None, description="A description of the custom entity.")
+    display_name:  StrictStr = Field(...,alias="displayName", description="A display label for the custom entity.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A description of the custom entity.") 
     identifiers: conlist(CustomEntityId) = Field(..., description="The identifiers the custom entity will be upserted with.")
     fields: conlist(CustomEntityField) = Field(..., description="The fields that decorate the custom entity.")
     relationships: conlist(Relationship) = Field(..., description="A set of relationships associated to the custom entity.")

lusid/models/custom_entity_type.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, StrictStr, conlist, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist, constr 
 from lusid.models.custom_entity_field_definition import CustomEntityFieldDefinition
 from lusid.models.link import Link
 from lusid.models.version import Version
@@ -28,11 +28,11 @@ class CustomEntityType(BaseModel):
     """
     Representation of a Custom Entity Type on the LUSID API  # noqa: E501
     """
-    href: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.")
-    entity_type_name: constr(strict=True, min_length=1) = Field(..., alias="entityTypeName", description="The name provided when the custom entity type was created. This has been prefixed with “~” and returned as “entityType”, which is the identifier for the custom entity type.")
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="A display label for the custom entity type.")
-    description: Optional[StrictStr] = Field(None, description="A description for the custom entity type.")
-    entity_type: constr(strict=True, min_length=1) = Field(..., alias="entityType", description="The identifier for the custom entity type, derived from the “entityTypeName” provided on creation.")
+    href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
+    entity_type_name:  StrictStr = Field(...,alias="entityTypeName", description="The name provided when the custom entity type was created. This has been prefixed with “~” and returned as “entityType”, which is the identifier for the custom entity type.") 
+    display_name:  StrictStr = Field(...,alias="displayName", description="A display label for the custom entity type.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A description for the custom entity type.") 
+    entity_type:  StrictStr = Field(...,alias="entityType", description="The identifier for the custom entity type, derived from the “entityTypeName” provided on creation.") 
     field_schema: conlist(CustomEntityFieldDefinition) = Field(..., alias="fieldSchema", description="The description of the fields on the custom entity type.")
     version: Version = Field(...)
     links: Optional[conlist(Link)] = None

lusid/models/cut_label_definition.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, StrictStr, conlist
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist 
 from lusid.models.cut_local_time import CutLocalTime
 from lusid.models.link import Link
 from lusid.models.version import Version
@@ -28,12 +28,12 @@ class CutLabelDefinition(BaseModel):
     """
     CutLabelDefinition
     """
-    code: Optional[StrictStr] = None
-    display_name: Optional[StrictStr] = Field(None, alias="displayName")
-    description: Optional[StrictStr] = None
+    code:  Optional[StrictStr] = Field(None,alias="code", description="") 
+    display_name:  Optional[StrictStr] = Field(None,alias="displayName", description="") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="") 
     cut_local_time: Optional[CutLocalTime] = Field(None, alias="cutLocalTime")
-    time_zone: Optional[StrictStr] = Field(None, alias="timeZone")
-    href: Optional[StrictStr] = None
+    time_zone:  Optional[StrictStr] = Field(None,alias="timeZone", description="") 
+    href:  Optional[StrictStr] = Field(None,alias="href") 
     version: Optional[Version] = None
     links: Optional[conlist(Link)] = None
     __properties = ["code", "displayName", "description", "cutLocalTime", "timeZone", "href", "version", "links"]

lusid/models/cut_local_time.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional, Union
-from pydantic.v1 import BaseModel, StrictFloat, StrictInt
+from pydantic.v1 import StrictStr, Field, BaseModel, StrictFloat, StrictInt 
 
 class CutLocalTime(BaseModel):
     """

lusid/models/data_definition.py

@@ -19,30 +19,20 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictBool, StrictStr, constr, validator
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool, StrictStr, constr, validator 
 
 class DataDefinition(BaseModel):
     """
     When importing data from an external data source, in order for it to be reliable queryable, LUSID needs to know something about it.  A data definition tells LUSID, what a given external data item is, what type it is and whether it in some way identifies items of data.  Consider presenting LUSID with a list of dictionaries where each dictionary contains the same set of keys (names). Each data item pointed to by  a key would be expected to be of the same type (integer, string, decimal etc.). To identify a particular dictionary from the list, a tuple of  one or more of the items in the dictionary would make it unique. If only a single item is required then the  # noqa: E501
     """
-    address: StrictStr = Field(..., description="The internal address (LUSID native) of the unit in the provided data itself and corresponds to the external name of the data item")
-    name: Optional[constr(strict=True, max_length=256, min_length=1)] = Field(None, description="The name of the data item. This is the name that will appear")
-    data_type: Optional[constr(strict=True, max_length=128, min_length=0)] = Field(None, alias="dataType", description="A member of the set of possible data types, that all data passed under that key is expected to be of.  Currently limited to one of [string, integer, decimal, result0d].")
-    key_type: Optional[constr(strict=True, max_length=128, min_length=0)] = Field(None, alias="keyType", description="Is the item either a unique key for the dictionary, i.e. does it identify a unique index or conceptual 'row' within the list of dictionaries,  or a partial key or is it simply a data item within that dictionary. Must be one of [Unique,PartOfUnique,Leaf, CompositeLeaf]")
+    address:  StrictStr = Field(...,alias="address", description="The internal address (LUSID native) of the unit in the provided data itself and corresponds to the external name of the data item") 
+    name:  Optional[StrictStr] = Field(None,alias="name", description="The name of the data item. This is the name that will appear") 
+    data_type:  Optional[StrictStr] = Field(None,alias="dataType", description="A member of the set of possible data types, that all data passed under that key is expected to be of.  Currently limited to one of [string, integer, decimal, result0d].") 
+    key_type:  Optional[StrictStr] = Field(None,alias="keyType", description="Is the item either a unique key for the dictionary, i.e. does it identify a unique index or conceptual 'row' within the list of dictionaries,  or a partial key or is it simply a data item within that dictionary. Must be one of [Unique,PartOfUnique,Leaf, CompositeLeaf]") 
     allow_null: Optional[StrictBool] = Field(None, alias="allowNull", description="The path to the field must exist (unless AllowMissing is true) but the actual value is allowed to be null.")
     allow_missing: Optional[StrictBool] = Field(None, alias="allowMissing", description="The path (or column) is allowed to be missing but if it is present it is not allowed to be null unless AllowNull is true.")
     __properties = ["address", "name", "dataType", "keyType", "allowNull", "allowMissing"]
 
-    @validator('name')
-    def name_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if value is None:
-            return value
-
-        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
-            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
-        return value
-
     class Config:
         """Pydantic configuration"""
         allow_population_by_field_name = True

lusid/models/data_map_key.py

@@ -19,36 +19,16 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, constr, validator
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, constr, validator 
 
 class DataMapKey(BaseModel):
     """
     DataMapKey
     """
-    version: Optional[constr(strict=True, max_length=32, min_length=0)] = Field(None, description="The version of the mappings. It is possible that a client will wish to update mappings over time. The version identifies the MAJOR.MINOR.PATCH version  of the mappings that the client assigns it.")
-    code: Optional[constr(strict=True, max_length=256, min_length=1)] = Field(None, description="A unique name to semantically identify the mapping set.")
+    version:  Optional[StrictStr] = Field(None,alias="version", description="The version of the mappings. It is possible that a client will wish to update mappings over time. The version identifies the MAJOR.MINOR.PATCH version  of the mappings that the client assigns it.") 
+    code:  Optional[StrictStr] = Field(None,alias="code", description="A unique name to semantically identify the mapping set.") 
     __properties = ["version", "code"]
 
-    @validator('version')
-    def version_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if value is None:
-            return value
-
-        if not re.match(r"^\d+\.\d+(\.\d+)?(-[a-zA-Z0-9\.-]{1,30})?$", value):
-            raise ValueError(r"must validate the regular expression /^\d+\.\d+(\.\d+)?(-[a-zA-Z0-9\.-]{1,30})?$/")
-        return value
-
-    @validator('code')
-    def code_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if value is None:
-            return value
-
-        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
-            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
-        return value
-
     class Config:
         """Pydantic configuration"""
         allow_population_by_field_name = True

lusid/models/data_mapping.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, conlist
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, conlist 
 from lusid.models.data_definition import DataDefinition
 
 class DataMapping(BaseModel):

lusid/models/data_model_membership.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, conlist
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, conlist 
 from lusid.models.membership import Membership
 from lusid.models.membership_and_status import MembershipAndStatus
 

lusid/models/data_model_summary.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List
-from pydantic.v1 import BaseModel, Field, StrictInt, conlist, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictInt, conlist, constr 
 from lusid.models.resource_id import ResourceId
 
 class DataModelSummary(BaseModel):
@@ -27,10 +27,10 @@ class DataModelSummary(BaseModel):
     DataModelSummary
     """
     id: ResourceId = Field(...)
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="The name of the Custom Data Model.")
-    description: constr(strict=True, min_length=1) = Field(..., description="A description for the Custom Data Model.")
-    entity_type: constr(strict=True, min_length=1) = Field(..., alias="entityType", description="The entity type that the Custom Data Model binds to.")
-    type: constr(strict=True, min_length=1) = Field(..., description="Either Root or Leaf or Intermediate.")
+    display_name:  StrictStr = Field(...,alias="displayName", description="The name of the Custom Data Model.") 
+    description:  StrictStr = Field(...,alias="description", description="A description for the Custom Data Model.") 
+    entity_type:  StrictStr = Field(...,alias="entityType", description="The entity type that the Custom Data Model binds to.") 
+    type:  StrictStr = Field(...,alias="type", description="Either Root or Leaf or Intermediate.") 
     precedence: StrictInt = Field(..., description="Where in the hierarchy this model sits.")
     children: conlist(DataModelSummary) = Field(..., description="Child Custom Data Models that will inherit from this data model.")
     __properties = ["id", "displayName", "description", "entityType", "type", "precedence", "children"]

lusid/models/data_scope.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, StrictStr
+from pydantic.v1 import StrictStr, Field, BaseModel, StrictStr 
 from lusid.models.client import Client
 
 class DataScope(BaseModel):
@@ -27,7 +27,7 @@ class DataScope(BaseModel):
     DataScope
     """
     client: Optional[Client] = None
-    scope: Optional[StrictStr] = None
+    scope:  Optional[StrictStr] = Field(None,alias="scope") 
     __properties = ["client", "scope"]
 
     class Config:

lusid/models/data_type.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, StrictStr, conlist, constr, validator
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist, constr, validator 
 from lusid.models.i_unit_definition_dto import IUnitDefinitionDto
 from lusid.models.link import Link
 from lusid.models.reference_data import ReferenceData
@@ -31,17 +31,17 @@ class DataType(BaseModel):
     """
     DataType
     """
-    type_value_range: StrictStr = Field(..., alias="typeValueRange", description="The available values are: Open, Closed")
+    type_value_range:  StrictStr = Field(...,alias="typeValueRange", description="The available values are: Open, Closed") 
     id: ResourceId = Field(...)
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName")
-    description: constr(strict=True, min_length=1) = Field(...)
-    value_type: StrictStr = Field(..., alias="valueType", description="The available values are: String, Int, Decimal, DateTime, Boolean, Map, List, PropertyArray, Percentage, Code, Id, Uri, CurrencyAndAmount, TradePrice, Currency, MetricValue, ResourceId, ResultValue, CutLocalTime, DateOrCutLabel, UnindexedText")
+    display_name:  StrictStr = Field(...,alias="displayName") 
+    description:  StrictStr = Field(...,alias="description") 
+    value_type:  StrictStr = Field(...,alias="valueType", description="The available values are: String, Int, Decimal, DateTime, Boolean, Map, List, PropertyArray, Percentage, Code, Id, Uri, CurrencyAndAmount, TradePrice, Currency, MetricValue, ResourceId, ResultValue, CutLocalTime, DateOrCutLabel, UnindexedText") 
     acceptable_values: Optional[conlist(StrictStr)] = Field(None, alias="acceptableValues")
-    unit_schema: Optional[StrictStr] = Field(None, alias="unitSchema", description="The available values are: NoUnits, Basic, Iso4217Currency")
+    unit_schema:  Optional[StrictStr] = Field(None,alias="unitSchema", description="The available values are: NoUnits, Basic, Iso4217Currency") 
     acceptable_units: Optional[conlist(IUnitDefinitionDto)] = Field(None, alias="acceptableUnits")
     reference_data: Optional[ReferenceData] = Field(None, alias="referenceData")
     version: Optional[Version] = None
-    href: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.")
+    href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
     staged_modifications: Optional[StagedModificationsInfo] = Field(None, alias="stagedModifications")
     links: Optional[conlist(Link)] = None
     __properties = ["typeValueRange", "id", "displayName", "description", "valueType", "acceptableValues", "unitSchema", "acceptableUnits", "referenceData", "version", "href", "stagedModifications", "links"]