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

lusid/models/counterparty_agreement.py

@@ -19,7 +19,7 @@ import json
 
 from datetime import datetime
 from typing import Any, Dict
-from pydantic.v1 import BaseModel, Field, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, constr 
 from lusid.models.counterparty_signatory import CounterpartySignatory
 from lusid.models.resource_id import ResourceId
 
@@ -27,8 +27,8 @@ class CounterpartyAgreement(BaseModel):
     """
     Represents the legal agreement between two parties engaged in an OTC transaction.  A typical example would be a 2002 ISDA Master Agreement, signed by two legal entities on a given date.  # noqa: E501
     """
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="A user-defined display label for the Counterparty Agreement.")
-    agreement_type: constr(strict=True, max_length=256, min_length=0) = Field(..., alias="agreementType", description="A user-defined field to capture the type of agreement this represents. Examples might be \"ISDA 2002 Master Agreement\" or \"ISDA 1992 Master Agreement\".")
+    display_name:  StrictStr = Field(...,alias="displayName", description="A user-defined display label for the Counterparty Agreement.") 
+    agreement_type:  StrictStr = Field(...,alias="agreementType", description="A user-defined field to capture the type of agreement this represents. Examples might be \"ISDA 2002 Master Agreement\" or \"ISDA 1992 Master Agreement\".") 
     counterparty_signatory: CounterpartySignatory = Field(..., alias="counterpartySignatory")
     dated_as_of: datetime = Field(..., alias="datedAsOf", description="The date on which the CounterpartyAgreement was signed by both parties.")
     credit_support_annex_id: ResourceId = Field(..., alias="creditSupportAnnexId")

lusid/models/counterparty_risk_information.py

@@ -19,7 +19,7 @@ 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.credit_rating import CreditRating
 from lusid.models.industry_classifier import IndustryClassifier
 
@@ -27,18 +27,11 @@ class CounterpartyRiskInformation(BaseModel):
     """
     In the event that the legal entity is a counterparty to an OTC transaction  (as signatory to a counterparty agreement such as an ISDA 2002 Master Agreement),  this information would be needed for calculations  such as Credit-Valuation-Adjustments and Debit-Valuation-Adjustments (CVA, DVA, XVA etc).  # noqa: E501
     """
-    country_of_risk: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="countryOfRisk", description="The country to which one would naturally ascribe risk, typically the legal entity's country of registration. This can be used to infer funding currency and related market data in the absence of a specific preference.")
+    country_of_risk:  StrictStr = Field(...,alias="countryOfRisk", description="The country to which one would naturally ascribe risk, typically the legal entity's country of registration. This can be used to infer funding currency and related market data in the absence of a specific preference.") 
     credit_ratings: conlist(CreditRating) = Field(..., alias="creditRatings")
     industry_classifiers: conlist(IndustryClassifier) = Field(..., alias="industryClassifiers")
     __properties = ["countryOfRisk", "creditRatings", "industryClassifiers"]
 
-    @validator('country_of_risk')
-    def country_of_risk_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/counterparty_signatory.py

@@ -19,14 +19,14 @@ import json
 
 
 from typing import Any, Dict
-from pydantic.v1 import BaseModel, Field, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, constr 
 from lusid.models.typed_resource_id import TypedResourceId
 
 class CounterpartySignatory(BaseModel):
     """
     The counterpartyAgreement is signed by two parties, one of which is implicitly the LUSID user.  The CounterpartySignatory represents the 'other side' of the agreement.  It comprises a name and identifier for a Legal Entity in LUSID.  # noqa: E501
     """
-    name: constr(strict=True, min_length=1) = Field(..., description="A user-defined name or label for the counterparty signatory.  There is no requirement for this to match the \"displayName\" of the legal entity.")
+    name:  StrictStr = Field(...,alias="name", description="A user-defined name or label for the counterparty signatory.  There is no requirement for this to match the \"displayName\" of the legal entity.") 
     legal_entity_identifier: TypedResourceId = Field(..., alias="legalEntityIdentifier")
     __properties = ["name", "legalEntityIdentifier"]
 

lusid/models/create_address_key_definition_request.py

@@ -19,14 +19,14 @@ import json
 
 
 from typing import Any, Dict
-from pydantic.v1 import BaseModel, Field, StrictStr, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, constr 
 
 class CreateAddressKeyDefinitionRequest(BaseModel):
     """
     CreateAddressKeyDefinitionRequest
     """
-    address_key: StrictStr = Field(..., alias="addressKey", description="The address key of the address key definition.")
-    type: constr(strict=True, min_length=1) = Field(..., description="The type of the address key definition")
+    address_key:  StrictStr = Field(...,alias="addressKey", description="The address key of the address key definition.") 
+    type:  StrictStr = Field(...,alias="type", description="The type of the address key definition") 
     __properties = ["addressKey", "type"]
 
     class Config:

lusid/models/create_amortisation_rule_set_request.py

@@ -19,41 +19,17 @@ 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 CreateAmortisationRuleSetRequest(BaseModel):
     """
     CreateAmortisationRuleSetRequest
     """
-    code: constr(strict=True, max_length=64, min_length=1) = Field(...)
-    display_name: constr(strict=True, max_length=256, min_length=1) = Field(..., alias="displayName")
-    description: Optional[constr(strict=True, max_length=1024, min_length=0)] = None
+    code:  StrictStr = Field(...,alias="code", description="") 
+    display_name:  StrictStr = Field(...,alias="displayName", description="") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="") 
     __properties = ["code", "displayName", "description"]
 
-    @validator('code')
-    def code_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('display_name')
-    def display_name_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if not re.match(r"^[^\\<>&\"]+$", value):
-            raise ValueError(r"must validate the regular expression /^[^\\<>&\"]+$/")
-        return value
-
-    @validator('description')
-    def description_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if value is None:
-            return value
-
-        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/create_calendar_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, conlist, constr, validator
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, conlist, constr, validator 
 from lusid.models.model_property import ModelProperty
 from lusid.models.resource_id import ResourceId
 from lusid.models.weekend_mask import WeekendMask
@@ -29,26 +29,12 @@ class CreateCalendarRequest(BaseModel):
     CreateCalendarRequest
     """
     calendar_id: ResourceId = Field(..., alias="calendarId")
-    calendar_type: constr(strict=True, max_length=256, min_length=1) = Field(..., alias="calendarType")
+    calendar_type:  StrictStr = Field(...,alias="calendarType") 
     weekend_mask: WeekendMask = Field(..., alias="weekendMask")
-    source_provider: constr(strict=True, max_length=50, min_length=0) = Field(..., alias="sourceProvider")
+    source_provider:  StrictStr = Field(...,alias="sourceProvider") 
     properties: Optional[conlist(ModelProperty)] = None
     __properties = ["calendarId", "calendarType", "weekendMask", "sourceProvider", "properties"]
 
-    @validator('calendar_type')
-    def calendar_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('source_provider')
-    def source_provider_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/create_closed_period_request.py

@@ -19,14 +19,14 @@ 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 
 from lusid.models.model_property import ModelProperty
 
 class CreateClosedPeriodRequest(BaseModel):
     """
     CreateClosedPeriodRequest
     """
-    closed_period_id: Optional[constr(strict=True, max_length=512, min_length=1)] = Field(None, alias="closedPeriodId", description="The unique Id of the Closed Period. The ClosedPeriodId, together with the Timeline Scope and Code, uniquely identifies a Closed Period")
+    closed_period_id:  Optional[StrictStr] = Field(None,alias="closedPeriodId", description="The unique Id of the Closed Period. The ClosedPeriodId, together with the Timeline Scope and Code, uniquely identifies a Closed Period") 
     effective_end: Optional[datetime] = Field(None, alias="effectiveEnd", description="The effective end of the Closed Period")
     properties: Optional[Dict[str, ModelProperty]] = Field(None, description="The Closed Periods properties. These will be from the 'ClosedPeriod' domain.")
     __properties = ["closedPeriodId", "effectiveEnd", "properties"]

lusid/models/create_compliance_template_request.py

@@ -19,32 +19,18 @@ 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.compliance_template_variation_request import ComplianceTemplateVariationRequest
 
 class CreateComplianceTemplateRequest(BaseModel):
     """
     CreateComplianceTemplateRequest
     """
-    code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The code given for the Compliance Template")
-    description: constr(strict=True, max_length=1024, min_length=0) = Field(..., description="The description of the Compliance Template")
+    code:  StrictStr = Field(...,alias="code", description="The code given for the Compliance Template") 
+    description:  StrictStr = Field(...,alias="description", description="The description of the Compliance Template") 
     variations: conlist(ComplianceTemplateVariationRequest) = Field(..., description="Variation details of a Compliance Template")
     __properties = ["code", "description", "variations"]
 
-    @validator('code')
-    def code_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('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/create_corporate_action_source_request.py

@@ -19,50 +19,19 @@ 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 
 
 class CreateCorporateActionSourceRequest(BaseModel):
     """
     CreateCorporateActionSourceRequest
     """
-    scope: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The scope of the corporate action source")
-    code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The code of the corporate action source")
-    display_name: constr(strict=True, max_length=512, min_length=1) = Field(..., alias="displayName", description="The name of the corporate action source")
-    description: Optional[constr(strict=True, max_length=1024, min_length=0)] = Field(None, description="The description of the corporate action source")
+    scope:  StrictStr = Field(...,alias="scope", description="The scope of the corporate action source") 
+    code:  StrictStr = Field(...,alias="code", description="The code of the corporate action source") 
+    display_name:  StrictStr = Field(...,alias="displayName", description="The name of the corporate action source") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="The description of the corporate action source") 
     instrument_scopes: Optional[conlist(StrictStr, max_items=1)] = Field(None, alias="instrumentScopes", description="The list of instrument scopes used as the scope resolution strategy when resolving instruments of upserted corporate actions.")
     __properties = ["scope", "code", "displayName", "description", "instrumentScopes"]
 
-    @validator('scope')
-    def 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('code')
-    def code_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('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 value is None:
-            return value
-
-        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/create_custom_data_model_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, Field, conlist, constr, validator
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, conlist, constr, validator 
 from lusid.models.alias import Alias
 from lusid.models.custom_data_model_identifier_type_specification import CustomDataModelIdentifierTypeSpecification
 from lusid.models.custom_data_model_property_specification import CustomDataModelPropertySpecification
@@ -31,40 +31,16 @@ class CreateCustomDataModelRequest(BaseModel):
     CreateCustomDataModelRequest
     """
     id: ResourceId = Field(...)
-    display_name: constr(strict=True, max_length=512, min_length=0) = Field(..., alias="displayName", description="The name of the Custom Data Model.")
-    description: constr(strict=True, max_length=512, min_length=0) = Field(..., description="A description for the Custom Data Model.")
+    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.") 
     parent_data_model: Optional[ResourceId] = Field(None, alias="parentDataModel")
-    conditions: Optional[constr(strict=True, max_length=16384, min_length=0)] = 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(CustomDataModelPropertySpecification)] = Field(None, description="The properties that are required or allowed on the bound entity.")
     identifier_types: Optional[conlist(CustomDataModelIdentifierTypeSpecification)] = 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.")
     recommended_sort_by: Optional[conlist(RecommendedSortBy)] = Field(None, alias="recommendedSortBy", description="The preferred default sorting instructions.")
     __properties = ["id", "displayName", "description", "parentDataModel", "conditions", "properties", "identifierTypes", "attributeAliases", "recommendedSortBy"]
 
-    @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
-
-    @validator('conditions')
-    def conditions_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if value is None:
-            return value
-
-        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/create_custom_entity_type_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 CreateCustomEntityTypeRequest(BaseModel):
     """
     CreateCustomEntityTypeRequest
     """
-    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/create_cut_label_definition_request.py

@@ -19,37 +19,20 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictStr, constr, validator
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, constr, validator 
 from lusid.models.cut_local_time import CutLocalTime
 
 class CreateCutLabelDefinitionRequest(BaseModel):
     """
     This request specifies a new Cut Label Definition  # noqa: E501
     """
-    code: StrictStr = Field(...)
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName")
-    description: Optional[constr(strict=True)] = None
+    code:  StrictStr = Field(...,alias="code") 
+    display_name:  StrictStr = Field(...,alias="displayName") 
+    description:  Optional[StrictStr] = Field(None,alias="description") 
     cut_local_time: CutLocalTime = Field(..., alias="cutLocalTime")
-    time_zone: constr(strict=True, min_length=1) = Field(..., alias="timeZone")
+    time_zone:  StrictStr = Field(...,alias="timeZone") 
     __properties = ["code", "displayName", "description", "cutLocalTime", "timeZone"]
 
-    @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 value is None:
-            return value
-
-        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/create_data_map_request.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.data_map_key import DataMapKey
 from lusid.models.data_mapping import DataMapping
 

lusid/models/create_data_type_request.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.create_unit_definition import CreateUnitDefinition
 from lusid.models.reference_data import ReferenceData
 
@@ -27,32 +27,18 @@ class CreateDataTypeRequest(BaseModel):
     """
     CreateDataTypeRequest
     """
-    scope: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The scope that the data type will be created in.")
-    code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The code of the data type. Together with the scope this uniquely defines the data type.")
-    type_value_range: StrictStr = Field(..., alias="typeValueRange", description="Indicates the range of data acceptable by a data type. The available values are: Open, Closed")
-    display_name: constr(strict=True, max_length=512, min_length=1) = Field(..., alias="displayName", description="The display name of the data type.")
-    description: constr(strict=True, max_length=1024, min_length=0) = Field(..., description="The description of the data type.")
-    value_type: StrictStr = Field(..., alias="valueType", description="The expected type of the values. 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")
+    scope:  StrictStr = Field(...,alias="scope", description="The scope that the data type will be created in.") 
+    code:  StrictStr = Field(...,alias="code", description="The code of the data type. Together with the scope this uniquely defines the data type.") 
+    type_value_range:  StrictStr = Field(...,alias="typeValueRange", description="Indicates the range of data acceptable by a data type. The available values are: Open, Closed") 
+    display_name:  StrictStr = Field(...,alias="displayName", description="The display name of the data type.") 
+    description:  StrictStr = Field(...,alias="description", description="The description of the data type.") 
+    value_type:  StrictStr = Field(...,alias="valueType", description="The expected type of the values. 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", description="The acceptable set of values for this data type. Only applies to 'open' value type range.")
-    unit_schema: Optional[StrictStr] = Field(None, alias="unitSchema", description="The schema of the data type's units. The available values are: NoUnits, Basic, Iso4217Currency")
+    unit_schema:  Optional[StrictStr] = Field(None,alias="unitSchema", description="The schema of the data type's units. The available values are: NoUnits, Basic, Iso4217Currency") 
     acceptable_units: Optional[conlist(CreateUnitDefinition)] = Field(None, alias="acceptableUnits", description="The definitions of the acceptable units.")
     reference_data: Optional[ReferenceData] = Field(None, alias="referenceData")
     __properties = ["scope", "code", "typeValueRange", "displayName", "description", "valueType", "acceptableValues", "unitSchema", "acceptableUnits", "referenceData"]
 
-    @validator('scope')
-    def 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('code')
-    def code_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('type_value_range')
     def type_value_range_validate_enum(cls, value):
         """Validates the enum"""
@@ -60,20 +46,6 @@ class CreateDataTypeRequest(BaseModel):
             raise ValueError("must be one of enum values ('Open', 'Closed')")
         return value
 
-    @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
-
     @validator('value_type')
     def value_type_validate_enum(cls, value):
         """Validates the enum"""

lusid/models/create_date_request.py

@@ -19,54 +19,23 @@ import json
 
 from datetime import datetime
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictStr, constr, validator
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, constr, validator 
 from lusid.models.date_attributes import DateAttributes
 
 class CreateDateRequest(BaseModel):
     """
     CreateDateRequest
     """
-    date_id: constr(strict=True, max_length=256, min_length=1) = Field(..., alias="dateId")
+    date_id:  StrictStr = Field(...,alias="dateId") 
     from_utc: datetime = Field(..., alias="fromUtc")
     to_utc: datetime = Field(..., alias="toUtc")
-    time_zone: constr(strict=True, max_length=5, min_length=0) = Field(..., alias="timeZone")
-    description: constr(strict=True, max_length=100, min_length=0) = Field(...)
-    type: Optional[constr(strict=True, max_length=10, min_length=0)] = None
+    time_zone:  StrictStr = Field(...,alias="timeZone") 
+    description:  StrictStr = Field(...,alias="description") 
+    type:  Optional[StrictStr] = Field(None,alias="type") 
     attributes: Optional[DateAttributes] = None
     source_data: Optional[Dict[str, StrictStr]] = Field(None, alias="sourceData")
     __properties = ["dateId", "fromUtc", "toUtc", "timeZone", "description", "type", "attributes", "sourceData"]
 
-    @validator('date_id')
-    def date_id_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('time_zone')
-    def time_zone_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('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
-
-    @validator('type')
-    def type_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/create_derived_property_definition_request.py

@@ -19,20 +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 
 from lusid.models.resource_id import ResourceId
 
 class CreateDerivedPropertyDefinitionRequest(BaseModel):
     """
     CreateDerivedPropertyDefinitionRequest
     """
-    domain: StrictStr = Field(..., description="The domain that the property exists in. Not all available values are currently supported, please check the documentation: https://support.lusid.com/knowledgebase/article/KA-01719/. The available values are: NotDefined, Transaction, Portfolio, Holding, ReferenceHolding, TransactionConfiguration, Instrument, CutLabelDefinition, Analytic, PortfolioGroup, Person, AccessMetadata, Order, UnitResult, MarketData, ConfigurationRecipe, Allocation, Calendar, LegalEntity, Placement, Execution, Block, Participation, Package, OrderInstruction, NextBestAction, CustomEntity, InstrumentEvent, Account, ChartOfAccounts, CustodianAccount, Abor, AborConfiguration, Fund, FundConfiguration, Fee, Reconciliation, PropertyDefinition, Compliance, DiaryEntry, Leg, DerivedValuation, Timeline, ClosedPeriod, AddressKeyDefinition, AmortisationRuleSet, AnalyticsSetInventory, AtomUnitResult, CleardownModule, ComplexMarketData, ComplianceRunSummary, ComplianceRule, ComplianceRunInfo, CorporateActionSource, CounterpartyAgreement, CustomEntityDefinition, DataType, Dialect, EventHandler, GeneralLedgerProfile, PostingModule, Quote, RecipeComposer, ReconciliationRunBreak, ReferenceList, RelationDefinition, ReturnBlockIndex, SRSDocument, SRSIndex, TransactionTemplate, TransactionTemplateScope, TransactionType, TransactionTypeConfig, TranslationScript, TaskDefinition, TaskInstance, Worker, StagingRuleSet, IdentifierDefinition")
-    scope: StrictStr = Field(..., description="The scope that the property exists in.")
-    code: StrictStr = Field(..., description="The code of the property. Together with the domain and scope this uniquely identifies the property.")
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="The display name of the property.")
+    domain:  StrictStr = Field(...,alias="domain", description="The domain that the property exists in. Not all available values are currently supported, please check the documentation: https://support.lusid.com/knowledgebase/article/KA-01719/. The available values are: NotDefined, Transaction, Portfolio, Holding, ReferenceHolding, TransactionConfiguration, Instrument, CutLabelDefinition, Analytic, PortfolioGroup, Person, AccessMetadata, Order, UnitResult, MarketData, ConfigurationRecipe, Allocation, Calendar, LegalEntity, Placement, Execution, Block, Participation, Package, OrderInstruction, NextBestAction, CustomEntity, InstrumentEvent, Account, ChartOfAccounts, CustodianAccount, Abor, AborConfiguration, Fund, FundConfiguration, Fee, Reconciliation, PropertyDefinition, Compliance, DiaryEntry, Leg, DerivedValuation, Timeline, ClosedPeriod, AddressKeyDefinition, AmortisationRuleSet, AnalyticsSetInventory, AtomUnitResult, CleardownModule, ComplexMarketData, ComplianceRunSummary, ComplianceRule, ComplianceRunInfo, CorporateActionSource, CounterpartyAgreement, CustomEntityDefinition, DataType, Dialect, EventHandler, GeneralLedgerProfile, PostingModule, Quote, RecipeComposer, ReconciliationRunBreak, ReferenceList, RelationDefinition, ReturnBlockIndex, SRSDocument, SRSIndex, TransactionTemplate, TransactionTemplateScope, TransactionType, TransactionTypeConfig, TranslationScript, TaskDefinition, TaskInstance, Worker, StagingRuleSet, IdentifierDefinition") 
+    scope:  StrictStr = Field(...,alias="scope", description="The scope that the property exists in.") 
+    code:  StrictStr = Field(...,alias="code", description="The code of the property. Together with the domain and scope this uniquely identifies the property.") 
+    display_name:  StrictStr = Field(...,alias="displayName", description="The display name of the property.") 
     data_type_id: ResourceId = Field(..., alias="dataTypeId")
-    property_description: Optional[constr(strict=True, max_length=512)] = Field(None, alias="propertyDescription", description="Describes the property")
-    derivation_formula: constr(strict=True, min_length=1) = Field(..., alias="derivationFormula", description="The rule that defines how data is composed for a derived property.")
+    property_description:  Optional[StrictStr] = Field(None,alias="propertyDescription", description="Describes the property") 
+    derivation_formula:  StrictStr = Field(...,alias="derivationFormula", description="The rule that defines how data is composed for a derived property.") 
     is_filterable: StrictBool = Field(..., alias="isFilterable", description="Bool indicating whether the values of this property are fitlerable, this is true for all non-derived property defintions.  For a derived definition this must be set true to enable filtering.")
     __properties = ["domain", "scope", "code", "displayName", "dataTypeId", "propertyDescription", "derivationFormula", "isFilterable"]