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

lusid/models/create_derived_transaction_portfolio_request.py

@@ -19,7 +19,7 @@ import json
 
 from datetime import datetime
 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.instrument_event_configuration import InstrumentEventConfiguration
 from lusid.models.resource_id import ResourceId
 
@@ -27,46 +27,22 @@ class CreateDerivedTransactionPortfolioRequest(BaseModel):
     """
     CreateDerivedTransactionPortfolioRequest
     """
-    display_name: constr(strict=True, max_length=512, min_length=1) = Field(..., alias="displayName", description="The name of the derived transaction portfolio.")
-    description: Optional[constr(strict=True, max_length=1024, min_length=0)] = Field(None, description="A description for the derived transaction portfolio.")
-    code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The code of the derived transaction portfolio. Together with the scope this uniquely identifies the derived transaction portfolio.")
+    display_name:  StrictStr = Field(...,alias="displayName", description="The name of the derived transaction portfolio.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A description for the derived transaction portfolio.") 
+    code:  StrictStr = Field(...,alias="code", description="The code of the derived transaction portfolio. Together with the scope this uniquely identifies the derived transaction portfolio.") 
     parent_portfolio_id: ResourceId = Field(..., alias="parentPortfolioId")
     created: Optional[datetime] = Field(None, description="This will be auto-populated to be the parent portfolio creation date.")
     corporate_action_source_id: Optional[ResourceId] = Field(None, alias="corporateActionSourceId")
-    accounting_method: Optional[StrictStr] = Field(None, alias="accountingMethod", description=". The available values are: Default, AverageCost, FirstInFirstOut, LastInFirstOut, HighestCostFirst, LowestCostFirst, ProRateByUnits, ProRateByCost, ProRateByCostPortfolioCurrency, IntraDayThenFirstInFirstOut, LongTermHighestCostFirst, LongTermHighestCostFirstPortfolioCurrency, HighestCostFirstPortfolioCurrency, LowestCostFirstPortfolioCurrency, MaximumLossMinimumGain, MaximumLossMinimumGainPortfolioCurrency")
+    accounting_method:  Optional[StrictStr] = Field(None,alias="accountingMethod", description=". The available values are: Default, AverageCost, FirstInFirstOut, LastInFirstOut, HighestCostFirst, LowestCostFirst, ProRateByUnits, ProRateByCost, ProRateByCostPortfolioCurrency, IntraDayThenFirstInFirstOut, LongTermHighestCostFirst, LongTermHighestCostFirstPortfolioCurrency, HighestCostFirstPortfolioCurrency, LowestCostFirstPortfolioCurrency, MaximumLossMinimumGain, MaximumLossMinimumGainPortfolioCurrency") 
     sub_holding_keys: Optional[conlist(StrictStr)] = Field(None, alias="subHoldingKeys", description="A set of unique transaction properties to group the derived transaction portfolio's holdings by, perhaps for strategy tagging. Each property must be from the 'Transaction' domain and identified by a key in the format {domain}/{scope}/{code}, for example 'Transaction/strategies/quantsignal'. See https://support.lusid.com/knowledgebase/article/KA-01879/en-us for more information.")
     instrument_scopes: Optional[conlist(StrictStr, max_items=1)] = Field(None, alias="instrumentScopes", description="The resolution strategy used to resolve instruments of transactions/holdings upserted to this derived portfolio.")
-    amortisation_method: Optional[StrictStr] = Field(None, alias="amortisationMethod", description="The amortisation method used by the portfolio for the calculation. The available values are: NoAmortisation, StraightLine, EffectiveYield, StraightLineSettlementDate, EffectiveYieldSettlementDate")
-    transaction_type_scope: Optional[constr(strict=True, max_length=64, min_length=1)] = Field(None, alias="transactionTypeScope", description="The scope of the transaction types.")
-    cash_gain_loss_calculation_date: Optional[StrictStr] = Field(None, alias="cashGainLossCalculationDate", description="The option when the Cash Gain Loss to be calulated, TransactionDate/SettlementDate. Defaults to SettlementDate.")
+    amortisation_method:  Optional[StrictStr] = Field(None,alias="amortisationMethod", description="The amortisation method used by the portfolio for the calculation. The available values are: NoAmortisation, StraightLine, EffectiveYield, StraightLineSettlementDate, EffectiveYieldSettlementDate") 
+    transaction_type_scope:  Optional[StrictStr] = Field(None,alias="transactionTypeScope", description="The scope of the transaction types.") 
+    cash_gain_loss_calculation_date:  Optional[StrictStr] = Field(None,alias="cashGainLossCalculationDate", description="The option when the Cash Gain Loss to be calulated, TransactionDate/SettlementDate. Defaults to SettlementDate.") 
     amortisation_rule_set_id: Optional[ResourceId] = Field(None, alias="amortisationRuleSetId")
     instrument_event_configuration: Optional[InstrumentEventConfiguration] = Field(None, alias="instrumentEventConfiguration")
     __properties = ["displayName", "description", "code", "parentPortfolioId", "created", "corporateActionSourceId", "accountingMethod", "subHoldingKeys", "instrumentScopes", "amortisationMethod", "transactionTypeScope", "cashGainLossCalculationDate", "amortisationRuleSetId", "instrumentEventConfiguration"]
 
-    @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
-
-    @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('accounting_method')
     def accounting_method_validate_enum(cls, value):
         """Validates the enum"""
@@ -77,16 +53,6 @@ class CreateDerivedTransactionPortfolioRequest(BaseModel):
             raise ValueError("must be one of enum values ('Default', 'AverageCost', 'FirstInFirstOut', 'LastInFirstOut', 'HighestCostFirst', 'LowestCostFirst', 'ProRateByUnits', 'ProRateByCost', 'ProRateByCostPortfolioCurrency', 'IntraDayThenFirstInFirstOut', 'LongTermHighestCostFirst', 'LongTermHighestCostFirstPortfolioCurrency', 'HighestCostFirstPortfolioCurrency', 'LowestCostFirstPortfolioCurrency', 'MaximumLossMinimumGain', 'MaximumLossMinimumGainPortfolioCurrency')")
         return value
 
-    @validator('transaction_type_scope')
-    def transaction_type_scope_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_group_reconciliation_comparison_ruleset_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List
-from pydantic.v1 import BaseModel, Field, conlist, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, conlist, constr 
 from lusid.models.group_reconciliation_aggregate_attribute_rule import GroupReconciliationAggregateAttributeRule
 from lusid.models.group_reconciliation_core_attribute_rule import GroupReconciliationCoreAttributeRule
 from lusid.models.resource_id import ResourceId
@@ -29,8 +29,8 @@ class CreateGroupReconciliationComparisonRulesetRequest(BaseModel):
     CreateGroupReconciliationComparisonRulesetRequest
     """
     id: ResourceId = Field(...)
-    display_name: constr(strict=True, max_length=256, min_length=1) = Field(..., alias="displayName", description="The name of the ruleset")
-    reconciliation_type: constr(strict=True, min_length=1) = Field(..., alias="reconciliationType", description="The type of reconciliation to perform. \"Holding\" | \"Transaction\" | \"Valuation\"")
+    display_name:  StrictStr = Field(...,alias="displayName", description="The name of the ruleset") 
+    reconciliation_type:  StrictStr = Field(...,alias="reconciliationType", description="The type of reconciliation to perform. \"Holding\" | \"Transaction\" | \"Valuation\"") 
     core_attribute_rules: conlist(GroupReconciliationCoreAttributeRule, min_items=1) = Field(..., alias="coreAttributeRules", description="The core comparison rules")
     aggregate_attribute_rules: conlist(GroupReconciliationAggregateAttributeRule, min_items=1) = Field(..., alias="aggregateAttributeRules", description="The aggregate comparison rules")
     __properties = ["id", "displayName", "reconciliationType", "coreAttributeRules", "aggregateAttributeRules"]

lusid/models/create_group_reconciliation_definition_request.py

@@ -19,7 +19,7 @@ import json
 
 
 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.break_code_source import BreakCodeSource
 from lusid.models.group_reconciliation_definition_comparison_ruleset_ids import GroupReconciliationDefinitionComparisonRulesetIds
 from lusid.models.group_reconciliation_definition_currencies import GroupReconciliationDefinitionCurrencies
@@ -33,8 +33,8 @@ class CreateGroupReconciliationDefinitionRequest(BaseModel):
     CreateGroupReconciliationDefinitionRequest
     """
     id: Optional[ResourceId] = None
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="The name of the Group Reconciliation Definition")
-    description: constr(strict=True, min_length=1) = Field(..., description="The description of the Group Reconciliation Definition")
+    display_name:  StrictStr = Field(...,alias="displayName", description="The name of the Group Reconciliation Definition") 
+    description:  StrictStr = Field(...,alias="description", description="The description of the Group Reconciliation Definition") 
     portfolio_entity_ids: GroupReconciliationDefinitionPortfolioEntityIds = Field(..., alias="portfolioEntityIds")
     recipe_ids: Optional[GroupReconciliationDefinitionRecipeIds] = Field(None, alias="recipeIds")
     currencies: Optional[GroupReconciliationDefinitionCurrencies] = None

lusid/models/create_identifier_definition_request.py

@@ -19,21 +19,21 @@ 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.model_property import ModelProperty
 
 class CreateIdentifierDefinitionRequest(BaseModel):
     """
     CreateIdentifierDefinitionRequest
     """
-    domain: StrictStr = Field(..., description="The type of entity to which the identifier can be attached. Supported values are \"Instrument\", \"Person\", \"LegalEntity\"and \"CustomEntity\". 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")
-    identifier_scope: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="identifierScope", description="The scope that the identifier definition exists in.")
-    identifier_type: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="identifierType", description="What the identifier represents. Together with \"domain\" and \"identifierScope\" this uniquely identifies the identifier definition.")
-    life_time: StrictStr = Field(..., alias="lifeTime", description="Describes whether an identifier value is associated with an entity for all effective dates (“Perpetual”) or applies within a specified effective date range (“TimeVariant”). The available values are: Perpetual, TimeVariant")
-    hierarchy_usage: Optional[StrictStr] = Field(None, alias="hierarchyUsage", description="Nullable, defaults to \"MasterIdentifier\" if no value provided. \"MasterIdentifier\" (aka unique) An entity can have one value for this identifier definition on a given effective date. A value for this identifier definition can only be associated with one entity (in a given scope) on a given effective date. \"ParentIdentifier\" (aka non-unique) An entity can have one value for this identifier definition on a given effective date. A value for this identifier definition can be associated with many entities (in a given scope) on a given effective date.")
-    hierarchy_level: Optional[constr(strict=True, max_length=512, min_length=1)] = Field(None, alias="hierarchyLevel", description="Optional metadata associated with the identifier definition.")
-    display_name: Optional[constr(strict=True, max_length=256, min_length=1)] = Field(None, alias="displayName", description="A display name for the identifier. E.g. Figi.")
-    description: Optional[constr(strict=True, max_length=1024, min_length=0)] = Field(None, description="An optional description for the identifier.")
+    domain:  StrictStr = Field(...,alias="domain", description="The type of entity to which the identifier can be attached. Supported values are \"Instrument\", \"Person\", \"LegalEntity\"and \"CustomEntity\". 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") 
+    identifier_scope:  StrictStr = Field(...,alias="identifierScope", description="The scope that the identifier definition exists in.") 
+    identifier_type:  StrictStr = Field(...,alias="identifierType", description="What the identifier represents. Together with \"domain\" and \"identifierScope\" this uniquely identifies the identifier definition.") 
+    life_time:  StrictStr = Field(...,alias="lifeTime", description="Describes whether an identifier value is associated with an entity for all effective dates (“Perpetual”) or applies within a specified effective date range (“TimeVariant”). The available values are: Perpetual, TimeVariant") 
+    hierarchy_usage:  Optional[StrictStr] = Field(None,alias="hierarchyUsage", description="Nullable, defaults to \"MasterIdentifier\" if no value provided. \"MasterIdentifier\" (aka unique) An entity can have one value for this identifier definition on a given effective date. A value for this identifier definition can only be associated with one entity (in a given scope) on a given effective date. \"ParentIdentifier\" (aka non-unique) An entity can have one value for this identifier definition on a given effective date. A value for this identifier definition can be associated with many entities (in a given scope) on a given effective date.") 
+    hierarchy_level:  Optional[StrictStr] = Field(None,alias="hierarchyLevel", description="Optional metadata associated with the identifier definition.") 
+    display_name:  Optional[StrictStr] = Field(None,alias="displayName", description="A display name for the identifier. E.g. Figi.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="An optional description for the identifier.") 
     properties: Optional[Dict[str, ModelProperty]] = Field(None, description="A set of properties for the identifier definition.")
     __properties = ["domain", "identifierScope", "identifierType", "lifeTime", "hierarchyUsage", "hierarchyLevel", "displayName", "description", "properties"]
 
@@ -44,20 +44,6 @@ class CreateIdentifierDefinitionRequest(BaseModel):
             raise ValueError("must be one of enum values ('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')")
         return value
 
-    @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('life_time')
     def life_time_validate_enum(cls, value):
         """Validates the enum"""
@@ -65,36 +51,6 @@ class CreateIdentifierDefinitionRequest(BaseModel):
             raise ValueError("must be one of enum values ('Perpetual', 'TimeVariant')")
         return value
 
-    @validator('hierarchy_level')
-    def hierarchy_level_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
-
-    @validator('display_name')
-    def display_name_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if value is None:
-            return value
-
-        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_portfolio_details.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.resource_id import ResourceId
 
 class CreatePortfolioDetails(BaseModel):

lusid/models/create_portfolio_group_request.py

@@ -19,7 +19,7 @@ import json
 
 from datetime import datetime
 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.model_property import ModelProperty
 from lusid.models.resource_id import ResourceId
 
@@ -27,13 +27,13 @@ class CreatePortfolioGroupRequest(BaseModel):
     """
     CreatePortfolioGroupRequest
     """
-    code: StrictStr = Field(..., description="The code that the portfolio group will be created with. Together with the scope this uniquely identifies the portfolio group.")
+    code:  StrictStr = Field(...,alias="code", description="The code that the portfolio group will be created with. Together with the scope this uniquely identifies the portfolio group.") 
     created: Optional[datetime] = Field(None, description="The effective datetime at which the portfolio group was created. Defaults to the current LUSID system datetime if not specified.")
     values: Optional[conlist(ResourceId)] = Field(None, description="The resource identifiers of the portfolios to be contained within the portfolio group.")
     sub_groups: Optional[conlist(ResourceId)] = Field(None, alias="subGroups", description="The resource identifiers of the portfolio groups to be contained within the portfolio group as sub groups.")
     properties: Optional[Dict[str, ModelProperty]] = Field(None, description="A set of unique group properties to add to the portfolio group. Each property must be from the 'PortfolioGroup' domain and should be identified by its key which has the format {domain}/{scope}/{code}, e.g. 'PortfolioGroup/Manager/Id'. These properties must be pre-defined.")
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="The name of the portfolio group.")
-    description: Optional[StrictStr] = Field(None, description="A long form description of the portfolio group.")
+    display_name:  StrictStr = Field(...,alias="displayName", description="The name of the portfolio group.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A long form description of the portfolio group.") 
     __properties = ["code", "created", "values", "subGroups", "properties", "displayName", "description"]
 
     class Config:

lusid/models/create_property_definition_request.py

@@ -19,23 +19,23 @@ 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 CreatePropertyDefinitionRequest(BaseModel):
     """
     CreatePropertyDefinitionRequest
     """
-    domain: StrictStr = Field(..., description="The domain that the property exists in. 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.")
+    domain:  StrictStr = Field(...,alias="domain", description="The domain that the property exists in. 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.") 
     value_required: Optional[StrictBool] = Field(None, alias="valueRequired", description="This field is not implemented and should be disregarded.")
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="The display name of the property.")
+    display_name:  StrictStr = Field(...,alias="displayName", description="The display name of the property.") 
     data_type_id: ResourceId = Field(..., alias="dataTypeId")
-    life_time: Optional[StrictStr] = Field(None, alias="lifeTime", description="Describes how the property's values can change over time. The available values are: Perpetual, TimeVariant")
-    constraint_style: Optional[StrictStr] = Field(None, alias="constraintStyle", description="Describes the uniqueness and cardinality of the property for entity objects under the property domain specified in Key. Defaults to \"Property\" if not specified. Valid values for this field are: Property, Collection or Identifier.")
-    property_description: Optional[constr(strict=True, max_length=512)] = Field(None, alias="propertyDescription", description="Describes the property")
-    collection_type: Optional[StrictStr] = Field(None, alias="collectionType", description="Describes whether a collection property should behave as a set or as an array.")
+    life_time:  Optional[StrictStr] = Field(None,alias="lifeTime", description="Describes how the property's values can change over time. The available values are: Perpetual, TimeVariant") 
+    constraint_style:  Optional[StrictStr] = Field(None,alias="constraintStyle", description="Describes the uniqueness and cardinality of the property for entity objects under the property domain specified in Key. Defaults to \"Property\" if not specified. Valid values for this field are: Property, Collection or Identifier.") 
+    property_description:  Optional[StrictStr] = Field(None,alias="propertyDescription", description="Describes the property") 
+    collection_type:  Optional[StrictStr] = Field(None,alias="collectionType", description="Describes whether a collection property should behave as a set or as an array.") 
     __properties = ["domain", "scope", "code", "valueRequired", "displayName", "dataTypeId", "lifeTime", "constraintStyle", "propertyDescription", "collectionType"]
 
     @validator('domain')

lusid/models/create_recipe_request.py

@@ -19,7 +19,7 @@ import json
 
 from datetime import datetime
 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.configuration_recipe import ConfigurationRecipe
 from lusid.models.resource_id import ResourceId
 
@@ -31,7 +31,7 @@ class CreateRecipeRequest(BaseModel):
     recipe_id: Optional[ResourceId] = Field(None, alias="recipeId")
     inline_recipe: Optional[ConfigurationRecipe] = Field(None, alias="inlineRecipe")
     as_at: Optional[datetime] = Field(None, alias="asAt", description="The asAt date to use")
-    effective_at: constr(strict=True, min_length=1) = Field(..., alias="effectiveAt", description="The market data time, i.e. the recipe generated will look for rules with this effectiveAt.")
+    effective_at:  StrictStr = Field(...,alias="effectiveAt", description="The market data time, i.e. the recipe generated will look for rules with this effectiveAt.") 
     __properties = ["recipeCreationMarketDataScopes", "recipeId", "inlineRecipe", "asAt", "effectiveAt"]
 
     class Config:

lusid/models/create_reconciliation_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictBool, constr, validator
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool, constr, validator 
 from lusid.models.model_property import ModelProperty
 from lusid.models.reconciliation_configuration import ReconciliationConfiguration
 from lusid.models.reconciliation_transactions import ReconciliationTransactions
@@ -29,9 +29,9 @@ class CreateReconciliationRequest(BaseModel):
     """
     CreateReconciliationRequest
     """
-    code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The unique identifier associated with the reconciliation")
-    name: Optional[constr(strict=True, max_length=512, min_length=1)] = Field(None, description="The name of the scheduled reconciliation")
-    description: Optional[constr(strict=True, max_length=1024, min_length=0)] = Field(None, description="A description of the scheduled reconciliation")
+    code:  StrictStr = Field(...,alias="code", description="The unique identifier associated with the reconciliation") 
+    name:  Optional[StrictStr] = Field(None,alias="name", description="The name of the scheduled reconciliation") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A description of the scheduled reconciliation") 
     is_portfolio_group: Optional[StrictBool] = Field(None, alias="isPortfolioGroup", description="Specifies whether reconciliation is between portfolios or portfolio groups")
     left: Optional[ResourceId] = None
     right: Optional[ResourceId] = None
@@ -41,13 +41,6 @@ class CreateReconciliationRequest(BaseModel):
     properties: Optional[Dict[str, ModelProperty]] = Field(None, description="Reconciliation properties")
     __properties = ["code", "name", "description", "isPortfolioGroup", "left", "right", "transactions", "positions", "valuations", "properties"]
 
-    @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
-
     class Config:
         """Pydantic configuration"""
         allow_population_by_field_name = True

lusid/models/create_reference_portfolio_request.py

@@ -19,20 +19,20 @@ import json
 
 from datetime import datetime
 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.model_property import ModelProperty
 
 class CreateReferencePortfolioRequest(BaseModel):
     """
     CreateReferencePortfolioRequest
     """
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="The name of the reference portfolio.")
-    description: Optional[StrictStr] = Field(None, description="A long form text description of the portfolio.")
-    code: StrictStr = Field(..., description="Unique identifier for the portfolio.")
+    display_name:  StrictStr = Field(...,alias="displayName", description="The name of the reference portfolio.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A long form text description of the portfolio.") 
+    code:  StrictStr = Field(...,alias="code", description="Unique identifier for the portfolio.") 
     created: Optional[datetime] = Field(None, description="The original creation date, defaults to today if not specified when creating a portfolio.")
     properties: Optional[Dict[str, ModelProperty]] = Field(None, description="Portfolio properties to add to the portfolio.")
     instrument_scopes: Optional[conlist(StrictStr, max_items=1)] = Field(None, alias="instrumentScopes", description="Instrument Scopes.")
-    base_currency: Optional[StrictStr] = Field(None, alias="baseCurrency", description="The base currency of the transaction portfolio in ISO 4217 currency code format.")
+    base_currency:  Optional[StrictStr] = Field(None,alias="baseCurrency", description="The base currency of the transaction portfolio in ISO 4217 currency code format.") 
     __properties = ["displayName", "description", "code", "created", "properties", "instrumentScopes", "baseCurrency"]
 
     class Config:

lusid/models/create_relation_definition_request.py

@@ -19,21 +19,21 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictStr, constr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, constr 
 
 class CreateRelationDefinitionRequest(BaseModel):
     """
     CreateRelationDefinitionRequest
     """
-    scope: StrictStr = Field(..., description="The scope that the relation exists in.")
-    code: StrictStr = Field(..., description="The code of the relation. Together with the scope this uniquely defines the relation.")
-    source_entity_domain: constr(strict=True, min_length=1) = Field(..., alias="sourceEntityDomain", description="The entity domain of the source entity object must be, allowed values are \"Portfolio\" and \"Person\"")
-    target_entity_domain: constr(strict=True, min_length=1) = Field(..., alias="targetEntityDomain", description="The entity domain of the target entity object must be, allowed values are \"Portfolio\" and \"Person\"")
-    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="The display name of the relation.")
-    outward_description: constr(strict=True, min_length=1) = Field(..., alias="outwardDescription", description="The description to relate source entity object and target entity object.")
-    inward_description: constr(strict=True, min_length=1) = Field(..., alias="inwardDescription", description="The description to relate target entity object and source entity object.")
-    life_time: Optional[StrictStr] = Field(None, alias="lifeTime", description="Describes how the relations can change over time, allowed values are \"Perpetual\" and \"TimeVariant\"")
-    constraint_style: Optional[StrictStr] = Field(None, alias="constraintStyle", description="Describes the uniqueness and cardinality for relations with a specific source entity object and relations under this definition. Allowed values are \"Property\" and \"Collection\", defaults to \"Collection\" if not specified.")
+    scope:  StrictStr = Field(...,alias="scope", description="The scope that the relation exists in.") 
+    code:  StrictStr = Field(...,alias="code", description="The code of the relation. Together with the scope this uniquely defines the relation.") 
+    source_entity_domain:  StrictStr = Field(...,alias="sourceEntityDomain", description="The entity domain of the source entity object must be, allowed values are \"Portfolio\" and \"Person\"") 
+    target_entity_domain:  StrictStr = Field(...,alias="targetEntityDomain", description="The entity domain of the target entity object must be, allowed values are \"Portfolio\" and \"Person\"") 
+    display_name:  StrictStr = Field(...,alias="displayName", description="The display name of the relation.") 
+    outward_description:  StrictStr = Field(...,alias="outwardDescription", description="The description to relate source entity object and target entity object.") 
+    inward_description:  StrictStr = Field(...,alias="inwardDescription", description="The description to relate target entity object and source entity object.") 
+    life_time:  Optional[StrictStr] = Field(None,alias="lifeTime", description="Describes how the relations can change over time, allowed values are \"Perpetual\" and \"TimeVariant\"") 
+    constraint_style:  Optional[StrictStr] = Field(None,alias="constraintStyle", description="Describes the uniqueness and cardinality for relations with a specific source entity object and relations under this definition. Allowed values are \"Property\" and \"Collection\", defaults to \"Collection\" if not specified.") 
     __properties = ["scope", "code", "sourceEntityDomain", "targetEntityDomain", "displayName", "outwardDescription", "inwardDescription", "lifeTime", "constraintStyle"]
 
     class Config:

lusid/models/create_relation_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict
-from pydantic.v1 import BaseModel, Field, StrictStr
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr 
 
 class CreateRelationRequest(BaseModel):
     """

lusid/models/create_relationship_definition_request.py

@@ -19,58 +19,23 @@ 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 
 
 class CreateRelationshipDefinitionRequest(BaseModel):
     """
     CreateRelationshipDefinitionRequest
     """
-    scope: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The scope that the relationship definition exists in.")
-    code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The code of the relationship definition. Together with the scope this uniquely defines the relationship definition.")
-    source_entity_type: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="sourceEntityType", description="The entity type of the source entity object. Allowed values are 'Portfolio', 'PortfolioGroup', 'Person', 'LegalEntity', 'Instrument' or a custom entity type prefixed with '~'.")
-    target_entity_type: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="targetEntityType", description="The entity type of the target entity object. Allowed values are 'Portfolio', 'PortfolioGroup', 'Person', 'LegalEntity', 'Instrument' or a custom entity type prefixed with '~'.")
-    display_name: constr(strict=True, max_length=512, min_length=1) = Field(..., alias="displayName", description="The display name of the relationship definition.")
-    outward_description: constr(strict=True, max_length=512, min_length=1) = Field(..., alias="outwardDescription", description="The description to relate source entity object and target entity object.")
-    inward_description: constr(strict=True, max_length=512, min_length=1) = Field(..., alias="inwardDescription", description="The description to relate target entity object and source entity object.")
-    life_time: Optional[StrictStr] = Field(None, alias="lifeTime", description="Describes how the relationships can change over time. Allowed values are 'Perpetual' and 'TimeVariant', defaults to 'Perpetual' if not specified.")
-    relationship_cardinality: Optional[StrictStr] = Field(None, alias="relationshipCardinality", description="Describes the cardinality of the relationship with a specific source entity object and relationships under this definition. Allowed values are 'ManyToMany' and 'ManyToOne', defaults to 'ManyToMany' if not specified.")
+    scope:  StrictStr = Field(...,alias="scope", description="The scope that the relationship definition exists in.") 
+    code:  StrictStr = Field(...,alias="code", description="The code of the relationship definition. Together with the scope this uniquely defines the relationship definition.") 
+    source_entity_type:  StrictStr = Field(...,alias="sourceEntityType", description="The entity type of the source entity object. Allowed values are 'Portfolio', 'PortfolioGroup', 'Person', 'LegalEntity', 'Instrument' or a custom entity type prefixed with '~'.") 
+    target_entity_type:  StrictStr = Field(...,alias="targetEntityType", description="The entity type of the target entity object. Allowed values are 'Portfolio', 'PortfolioGroup', 'Person', 'LegalEntity', 'Instrument' or a custom entity type prefixed with '~'.") 
+    display_name:  StrictStr = Field(...,alias="displayName", description="The display name of the relationship definition.") 
+    outward_description:  StrictStr = Field(...,alias="outwardDescription", description="The description to relate source entity object and target entity object.") 
+    inward_description:  StrictStr = Field(...,alias="inwardDescription", description="The description to relate target entity object and source entity object.") 
+    life_time:  Optional[StrictStr] = Field(None,alias="lifeTime", description="Describes how the relationships can change over time. Allowed values are 'Perpetual' and 'TimeVariant', defaults to 'Perpetual' if not specified.") 
+    relationship_cardinality:  Optional[StrictStr] = Field(None,alias="relationshipCardinality", description="Describes the cardinality of the relationship with a specific source entity object and relationships under this definition. Allowed values are 'ManyToMany' and 'ManyToOne', defaults to 'ManyToMany' if not specified.") 
     __properties = ["scope", "code", "sourceEntityType", "targetEntityType", "displayName", "outwardDescription", "inwardDescription", "lifeTime", "relationshipCardinality"]
 
-    @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('outward_description')
-    def outward_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('inward_description')
-    def inward_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_relationship_request.py

@@ -19,7 +19,7 @@ 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 
 
 class CreateRelationshipRequest(BaseModel):
     """
@@ -27,30 +27,10 @@ class CreateRelationshipRequest(BaseModel):
     """
     source_entity_id: Dict[str, StrictStr] = Field(..., alias="sourceEntityId", description="The identifier of the source entity.")
     target_entity_id: Dict[str, StrictStr] = Field(..., alias="targetEntityId", description="The identifier of the target entity.")
-    effective_from: Optional[constr(strict=True, max_length=256, min_length=0)] = Field(None, alias="effectiveFrom", description="The effective date of the relationship to be created")
-    effective_until: Optional[constr(strict=True, max_length=256, min_length=0)] = Field(None, alias="effectiveUntil", description="The effective datetime until which the relationship is valid. If not supplied this will be valid indefinitely.")
+    effective_from:  Optional[StrictStr] = Field(None,alias="effectiveFrom", description="The effective date of the relationship to be created") 
+    effective_until:  Optional[StrictStr] = Field(None,alias="effectiveUntil", description="The effective datetime until which the relationship is valid. If not supplied this will be valid indefinitely.") 
     __properties = ["sourceEntityId", "targetEntityId", "effectiveFrom", "effectiveUntil"]
 
-    @validator('effective_from')
-    def effective_from_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
-
-    @validator('effective_until')
-    def effective_until_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_sequence_request.py

@@ -19,38 +19,21 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictBool, StrictInt, constr, validator
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool, StrictInt, constr, validator 
 
 class CreateSequenceRequest(BaseModel):
     """
     CreateSequenceRequest
     """
-    code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The code of the sequence definition to create")
+    code:  StrictStr = Field(...,alias="code", description="The code of the sequence definition to create") 
     increment: Optional[StrictInt] = Field(None, description="The value to increment between each value in the sequence")
     min_value: Optional[StrictInt] = Field(None, alias="minValue", description="The minimum value of the sequence")
     max_value: Optional[StrictInt] = Field(None, alias="maxValue", description="The maximum value of the sequence")
     start: Optional[StrictInt] = Field(None, description="The start value of the sequence")
     cycle: Optional[StrictBool] = Field(None, description="Set to true to start the sequence over again when it reaches the end. Defaults to false if not provided.")
-    pattern: Optional[constr(strict=True, max_length=44, min_length=1)] = Field(None, description="The pattern to be used to generate next values in the sequence. Defaults to null if not provided.")
+    pattern:  Optional[StrictStr] = Field(None,alias="pattern", description="The pattern to be used to generate next values in the sequence. Defaults to null if not provided.") 
     __properties = ["code", "increment", "minValue", "maxValue", "start", "cycle", "pattern"]
 
-    @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('pattern')
-    def pattern_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if value is None:
-            return value
-
-        if not re.match(r"^[A-Za-z0-9_-]*\{\{seqValue\}\}[A-Za-z0-9_-]*$", value):
-            raise ValueError(r"must validate the regular expression /^[A-Za-z0-9_-]*\{\{seqValue\}\}[A-Za-z0-9_-]*$/")
-        return value
-
     class Config:
         """Pydantic configuration"""
         allow_population_by_field_name = True