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

lusid/models/adjust_holding_request.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.perpetual_property import PerpetualProperty
 from lusid.models.resource_id import ResourceId
 from lusid.models.target_tax_lot_request import TargetTaxLotRequest
@@ -28,12 +30,12 @@ class AdjustHoldingRequest(BaseModel):
     """
     This request specifies target holdings. i.e. holding data that the  system should match. When processed by the movement  engine, it will create 'true-up' adjustments on the fly.  # noqa: E501
     """
-    instrument_identifiers: Dict[str, StrictStr] = Field(..., alias="instrumentIdentifiers", description="A set of instrument identifiers that can resolve the holding adjustment to a unique instrument.")
-    sub_holding_keys: Optional[Dict[str, PerpetualProperty]] = Field(None, alias="subHoldingKeys", description="Set of unique transaction properties and associated values to store with the holding adjustment transaction automatically created by LUSID. Each property must be from the 'Transaction' domain.")
-    properties: Optional[Dict[str, PerpetualProperty]] = Field(None, description="Set of unique holding properties and associated values to store with the target holding. Each property must be from the 'Holding' domain.")
-    tax_lots: conlist(TargetTaxLotRequest) = Field(..., alias="taxLots", description="The tax-lots that together make up the target holding.")
+    instrument_identifiers: Dict[str, Optional[StrictStr]] = Field(description="A set of instrument identifiers that can resolve the holding adjustment to a unique instrument.", alias="instrumentIdentifiers")
+    sub_holding_keys: Optional[Dict[str, PerpetualProperty]] = Field(default=None, description="Set of unique transaction properties and associated values to store with the holding adjustment transaction automatically created by LUSID. Each property must be from the 'Transaction' domain.", alias="subHoldingKeys")
+    properties: Optional[Dict[str, PerpetualProperty]] = Field(default=None, description="Set of unique holding properties and associated values to store with the target holding. Each property must be from the 'Holding' domain.")
+    tax_lots: List[TargetTaxLotRequest] = Field(description="The tax-lots that together make up the target holding.", alias="taxLots")
     currency:  Optional[StrictStr] = Field(None,alias="currency", description="The Holding currency. This needs to be equal with the one on the TaxLot -> cost if one is specified") 
-    custodian_account_id: Optional[ResourceId] = Field(None, alias="custodianAccountId")
+    custodian_account_id: Optional[ResourceId] = Field(default=None, alias="custodianAccountId")
     __properties = ["instrumentIdentifiers", "subHoldingKeys", "properties", "taxLots", "currency", "custodianAccountId"]
 
     class Config:
@@ -137,3 +139,5 @@ class AdjustHoldingRequest(BaseModel):
             "custodian_account_id": ResourceId.from_dict(obj.get("custodianAccountId")) if obj.get("custodianAccountId") is not None else None
         })
         return _obj
+
+AdjustHoldingRequest.update_forward_refs()

lusid/models/aggregate_spec.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, validator 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 
 class AggregateSpec(BaseModel):
     """
@@ -27,7 +29,7 @@ class AggregateSpec(BaseModel):
     """
     key:  StrictStr = Field(...,alias="key", description="The key that uniquely identifies a queryable address in Lusid.") 
     op:  StrictStr = Field(...,alias="op", description="The available values are: Sum, DefaultSum, Proportion, Average, Count, Min, Max, Value, SumOfPositiveValues, SumOfNegativeValues, SumOfAbsoluteValues, ProportionOfAbsoluteValues, SumCumulativeInAdvance, SumCumulativeInArrears") 
-    options: Optional[Dict[str, Any]] = Field(None, description="Additional options to apply when performing computations. Options that do not apply to the Key will be  ignored. Option values can be boolean, numeric, string or date-time.")
+    options: Optional[Dict[str, Any]] = Field(default=None, description="Additional options to apply when performing computations. Options that do not apply to the Key will be  ignored. Option values can be boolean, numeric, string or date-time.")
     __properties = ["key", "op", "options"]
 
     @validator('op')
@@ -80,14 +82,19 @@ class AggregateSpec(BaseModel):
                                     'SchedulerJobResponse', 
                                     'SleepResponse',
                                     'Library',
-                                    'LibraryResponse']:
+                                    'LibraryResponse',
+                                    'DayRegularity',
+                                    'RelativeMonthRegularity',
+                                    'SpecificMonthRegularity',
+                                    'WeekRegularity',
+                                    'YearRegularity']:
            return value
         
         # Only validate the 'type' property of the class
         if "op" != "type":
             return value
 
-        if value not in ('Sum', 'DefaultSum', 'Proportion', 'Average', 'Count', 'Min', 'Max', 'Value', 'SumOfPositiveValues', 'SumOfNegativeValues', 'SumOfAbsoluteValues', 'ProportionOfAbsoluteValues', 'SumCumulativeInAdvance', 'SumCumulativeInArrears'):
+        if value not in ['Sum', 'DefaultSum', 'Proportion', 'Average', 'Count', 'Min', 'Max', 'Value', 'SumOfPositiveValues', 'SumOfNegativeValues', 'SumOfAbsoluteValues', 'ProportionOfAbsoluteValues', 'SumCumulativeInAdvance', 'SumCumulativeInArrears']:
             raise ValueError("must be one of enum values ('Sum', 'DefaultSum', 'Proportion', 'Average', 'Count', 'Min', 'Max', 'Value', 'SumOfPositiveValues', 'SumOfNegativeValues', 'SumOfAbsoluteValues', 'ProportionOfAbsoluteValues', 'SumCumulativeInAdvance', 'SumCumulativeInArrears')")
         return value
 
@@ -145,3 +152,5 @@ class AggregateSpec(BaseModel):
             "options": obj.get("options")
         })
         return _obj
+
+AggregateSpec.update_forward_refs()

lusid/models/aggregated_return.py

@@ -17,24 +17,26 @@ import pprint
 import re  # noqa: F401
 import json
 
+
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictFloat, StrictInt, StrictStr, conlist 
 from lusid.models.resource_id import ResourceId
 
 class AggregatedReturn(BaseModel):
     """
     A list of Aggregated Returns.  # noqa: E501
     """
-    effective_at: datetime = Field(..., alias="effectiveAt", description="The effectiveAt for the return.")
-    end_of_period: datetime = Field(..., alias="endOfPeriod", description="The end of period date. For the monthly period this will be the Month End Date.")
-    opening_market_value: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="openingMarketValue", description="The opening market value.")
-    closing_market_value: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="closingMarketValue", description="The closing market value.")
-    metrics_value: Dict[str, Union[StrictFloat, StrictInt]] = Field(..., alias="metricsValue", description="The value for the specified metric.")
+    effective_at: datetime = Field(description="The effectiveAt for the return.", alias="effectiveAt")
+    end_of_period: datetime = Field(description="The end of period date. For the monthly period this will be the Month End Date.", alias="endOfPeriod")
+    opening_market_value: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The opening market value.", alias="openingMarketValue")
+    closing_market_value: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The closing market value.", alias="closingMarketValue")
+    metrics_value: Dict[str, Union[StrictFloat, StrictInt]] = Field(description="The value for the specified metric.", alias="metricsValue")
     frequency:  Optional[StrictStr] = Field(None,alias="frequency", description="Show the aggregated output returns on a Daily or Monthly period.") 
-    composite_members: Optional[StrictInt] = Field(None, alias="compositeMembers", description="The number of members in the Composite on the given day.")
-    composite_members_without_return: Optional[conlist(ResourceId)] = Field(None, alias="compositeMembersWithoutReturn", description="List containing Composite members which post no return on the given day.")
-    warnings: Optional[conlist(StrictStr)] = Field(None, description="List of the warnings about the calculation of the aggregated return.")
+    composite_members: Optional[StrictInt] = Field(default=None, description="The number of members in the Composite on the given day.", alias="compositeMembers")
+    composite_members_without_return: Optional[List[ResourceId]] = Field(default=None, description="List containing Composite members which post no return on the given day.", alias="compositeMembersWithoutReturn")
+    warnings: Optional[List[StrictStr]] = Field(default=None, description="List of the warnings about the calculation of the aggregated return.")
     __properties = ["effectiveAt", "endOfPeriod", "openingMarketValue", "closingMarketValue", "metricsValue", "frequency", "compositeMembers", "compositeMembersWithoutReturn", "warnings"]
 
     class Config:
@@ -129,3 +131,5 @@ class AggregatedReturn(BaseModel):
             "warnings": obj.get("warnings")
         })
         return _obj
+
+AggregatedReturn.update_forward_refs()

lusid/models/aggregated_returns_dispersion_request.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictInt, StrictStr, conlist, constr, validator 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.resource_id import ResourceId
 
 class AggregatedReturnsDispersionRequest(BaseModel):
@@ -27,9 +29,9 @@ class AggregatedReturnsDispersionRequest(BaseModel):
     The request used in the AggregatedReturnsDispersionMetric.  # noqa: E501
     """
     to_effective_at:  Optional[StrictStr] = Field(None,alias="toEffectiveAt", description="The end date for when the you want the dispersion to be calculated.") 
-    years_count: Optional[StrictInt] = Field(None, alias="yearsCount", description="For how many years to calculate the dispersion. Default to 10.")
-    return_ids: Optional[conlist(ResourceId)] = Field(None, alias="returnIds", description="The Scope and code of the returns.")
-    recipe_id: Optional[ResourceId] = Field(None, alias="recipeId")
+    years_count: Optional[StrictInt] = Field(default=None, description="For how many years to calculate the dispersion. Default to 10.", alias="yearsCount")
+    return_ids: Optional[List[ResourceId]] = Field(default=None, description="The Scope and code of the returns.", alias="returnIds")
+    recipe_id: Optional[ResourceId] = Field(default=None, alias="recipeId")
     composite_method:  Optional[StrictStr] = Field(None,alias="compositeMethod", description="The method used to calculate the Portfolio performance: Equal/Asset.") 
     alternative_inception_date:  Optional[StrictStr] = Field(None,alias="alternativeInceptionDate", description="Optional - either a date, or the key for a portfolio property containing a date. If provided, the given date will override the inception date for this request.") 
     __properties = ["toEffectiveAt", "yearsCount", "returnIds", "recipeId", "compositeMethod", "alternativeInceptionDate"]
@@ -116,3 +118,5 @@ class AggregatedReturnsDispersionRequest(BaseModel):
             "alternative_inception_date": obj.get("alternativeInceptionDate")
         })
         return _obj
+
+AggregatedReturnsDispersionRequest.update_forward_refs()

lusid/models/aggregated_returns_request.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist, constr 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.performance_returns_metric import PerformanceReturnsMetric
 from lusid.models.resource_id import ResourceId
 
@@ -27,14 +29,14 @@ class AggregatedReturnsRequest(BaseModel):
     """
     The request used in the AggregatedReturns.  # noqa: E501
     """
-    metrics: conlist(PerformanceReturnsMetric) = Field(..., description="A list of metrics to calculate in the AggregatedReturns.")
-    return_ids: Optional[conlist(ResourceId)] = Field(None, alias="returnIds", description="The Scope and code of the returns.")
-    recipe_id: Optional[ResourceId] = Field(None, alias="recipeId")
+    metrics: List[PerformanceReturnsMetric] = Field(description="A list of metrics to calculate in the AggregatedReturns.")
+    return_ids: Optional[List[ResourceId]] = Field(default=None, description="The Scope and code of the returns.", alias="returnIds")
+    recipe_id: Optional[ResourceId] = Field(default=None, alias="recipeId")
     composite_method:  Optional[StrictStr] = Field(None,alias="compositeMethod", description="The method used to calculate the Portfolio performance: Equal/Asset.") 
     period:  Optional[StrictStr] = Field(None,alias="period", description="The type of the returns used to calculate the aggregation result: Daily/Monthly.") 
     output_frequency:  Optional[StrictStr] = Field(None,alias="outputFrequency", description="The type of calculated output: Daily/Weekly/Monthly/Quarterly/Half-Yearly/Yearly.") 
     alternative_inception_date:  Optional[StrictStr] = Field(None,alias="alternativeInceptionDate", description="Optional - either a date, or the key for a portfolio property containing a date. If provided, the given date will override the inception date for this request.") 
-    holiday_calendars: Optional[conlist(StrictStr)] = Field(None, alias="holidayCalendars", description="The holiday calendar(s) that should be used in determining the date schedule. Holiday calendar(s) are supplied by their codes, for example, 'CoppClark'. Note that when the calendars are not available (e.g. when the user has insufficient permissions), a recipe setting will be used to determine whether the whole batch should then fail or whether the calendar not being available should simply be ignored.")
+    holiday_calendars: Optional[List[StrictStr]] = Field(default=None, description="The holiday calendar(s) that should be used in determining the date schedule. Holiday calendar(s) are supplied by their codes, for example, 'CoppClark'. Note that when the calendars are not available (e.g. when the user has insufficient permissions), a recipe setting will be used to determine whether the whole batch should then fail or whether the calendar not being available should simply be ignored.", alias="holidayCalendars")
     currency:  Optional[StrictStr] = Field(None,alias="currency", description="Optional - either a string or a property. If provided, the results will be converted to the specified currency") 
     run_mode:  Optional[StrictStr] = Field(None,alias="runMode", description="The dates the AggregatedReturns output will be calculated: ReturnData/WeekDays/AllDays/MonthEnd. Defaults to ReturnData.") 
     __properties = ["metrics", "returnIds", "recipeId", "compositeMethod", "period", "outputFrequency", "alternativeInceptionDate", "holidayCalendars", "currency", "runMode"]
@@ -152,3 +154,5 @@ class AggregatedReturnsRequest(BaseModel):
             "run_mode": obj.get("runMode")
         })
         return _obj
+
+AggregatedReturnsRequest.update_forward_refs()

lusid/models/aggregated_returns_response.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.aggregated_return import AggregatedReturn
 from lusid.models.link import Link
 
@@ -28,8 +30,8 @@ class AggregatedReturnsResponse(BaseModel):
     AggregatedReturnsResponse
     """
     href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
-    results: Optional[Dict[str, conlist(AggregatedReturn)]] = Field(None, description="Aggregated returns grouped by ReturnId")
-    links: Optional[conlist(Link)] = None
+    results: Optional[Dict[str, Optional[List[AggregatedReturn]]]] = Field(default=None, description="Aggregated returns grouped by ReturnId")
+    links: Optional[List[Link]] = None
     __properties = ["href", "results", "links"]
 
     class Config:
@@ -119,3 +121,5 @@ class AggregatedReturnsResponse(BaseModel):
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj
+
+AggregatedReturnsResponse.update_forward_refs()

lusid/models/aggregated_transactions_request.py

@@ -17,9 +17,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
 from datetime import datetime
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist 
 from lusid.models.aggregate_spec import AggregateSpec
 from lusid.models.order_by_spec import OrderBySpec
 from lusid.models.portfolio_entity_id import PortfolioEntityId
@@ -30,15 +32,15 @@ class AggregatedTransactionsRequest(BaseModel):
     """
     AggregatedTransactionsRequest
     """
-    from_transaction_date: datetime = Field(..., alias="fromTransactionDate")
-    to_transaction_date: datetime = Field(..., alias="toTransactionDate")
-    portfolio_id: Optional[ResourceId] = Field(None, alias="portfolioId")
-    portfolio_entity_ids: Optional[conlist(PortfolioEntityId)] = Field(None, alias="portfolioEntityIds", description="The set of portfolio or portfolio group identifiers containing the relevant transactions.")
-    as_at: Optional[datetime] = Field(None, alias="asAt")
-    metrics: conlist(AggregateSpec) = Field(...)
-    group_by: Optional[conlist(StrictStr)] = Field(None, alias="groupBy")
-    filters: Optional[conlist(PropertyFilter)] = None
-    sort: Optional[conlist(OrderBySpec)] = None
+    from_transaction_date: datetime = Field(alias="fromTransactionDate")
+    to_transaction_date: datetime = Field(alias="toTransactionDate")
+    portfolio_id: Optional[ResourceId] = Field(default=None, alias="portfolioId")
+    portfolio_entity_ids: Optional[List[PortfolioEntityId]] = Field(default=None, description="The set of portfolio or portfolio group identifiers containing the relevant transactions.", alias="portfolioEntityIds")
+    as_at: Optional[datetime] = Field(default=None, alias="asAt")
+    metrics: List[AggregateSpec]
+    group_by: Optional[List[StrictStr]] = Field(default=None, alias="groupBy")
+    filters: Optional[List[PropertyFilter]] = None
+    sort: Optional[List[OrderBySpec]] = None
     __properties = ["fromTransactionDate", "toTransactionDate", "portfolioId", "portfolioEntityIds", "asAt", "metrics", "groupBy", "filters", "sort"]
 
     class Config:
@@ -152,3 +154,5 @@ class AggregatedTransactionsRequest(BaseModel):
             "sort": [OrderBySpec.from_dict(_item) for _item in obj.get("sort")] if obj.get("sort") is not None else None
         })
         return _obj
+
+AggregatedTransactionsRequest.update_forward_refs()

lusid/models/aggregation_context.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.aggregation_options import AggregationOptions
 
 class AggregationContext(BaseModel):
@@ -79,3 +81,5 @@ class AggregationContext(BaseModel):
             "options": AggregationOptions.from_dict(obj.get("options")) if obj.get("options") is not None else None
         })
         return _obj
+
+AggregationContext.update_forward_refs()

lusid/models/aggregation_measure_failure_detail.py

@@ -17,16 +17,18 @@ import pprint
 import re  # noqa: F401
 import json
 
+
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
 from datetime import datetime
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr 
 
 class AggregationMeasureFailureDetail(BaseModel):
     """
     AggregationMeasureFailureDetail
     """
     id:  Optional[StrictStr] = Field(None,alias="id") 
-    effective_at: Optional[datetime] = Field(None, alias="effectiveAt")
+    effective_at: Optional[datetime] = Field(default=None, alias="effectiveAt")
     measure:  Optional[StrictStr] = Field(None,alias="measure") 
     reason:  Optional[StrictStr] = Field(None,alias="reason") 
     detail:  Optional[StrictStr] = Field(None,alias="detail") 
@@ -103,3 +105,5 @@ class AggregationMeasureFailureDetail(BaseModel):
             "detail": obj.get("detail")
         })
         return _obj
+
+AggregationMeasureFailureDetail.update_forward_refs()

lusid/models/aggregation_op.py

@@ -17,8 +17,10 @@ import pprint
 import re  # noqa: F401
 from aenum import Enum, no_arg
 
-
-
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 
 
 class AggregationOp(str, Enum):

lusid/models/aggregation_options.py

@@ -18,16 +18,18 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 
 class AggregationOptions(BaseModel):
     """
     Options for controlling the default aspects and behaviour of the aggregation.  # noqa: E501
     """
-    use_ansi_like_syntax: Optional[StrictBool] = Field(None, alias="useAnsiLikeSyntax", description="Should the aggregation behave like ANSI Sql or MySql with respect to a conceptual request which is equivalent to \"select a,sum(a) from results\";  ANSI Sql would report an error if a was not unique where MySql would simply view a,suma(a) as equivalent to firstof(a),sum(a).")
-    allow_partial_entitlement_success: Optional[StrictBool] = Field(None, alias="allowPartialEntitlementSuccess", description="In the case of valuing a portfolio group where some, but not all entitlements fail, should the aggregation return the valuations  applied only to those portfolios where entitlements checks succeeded.")
-    apply_iso4217_rounding: Optional[StrictBool] = Field(None, alias="applyIso4217Rounding", description="Various results that are units of currency might need to be rounded.  This will round according to the ISO4217 standard number of decimal places for a currency.")
+    use_ansi_like_syntax: Optional[StrictBool] = Field(default=None, description="Should the aggregation behave like ANSI Sql or MySql with respect to a conceptual request which is equivalent to \"select a,sum(a) from results\";  ANSI Sql would report an error if a was not unique where MySql would simply view a,suma(a) as equivalent to firstof(a),sum(a).", alias="useAnsiLikeSyntax")
+    allow_partial_entitlement_success: Optional[StrictBool] = Field(default=None, description="In the case of valuing a portfolio group where some, but not all entitlements fail, should the aggregation return the valuations  applied only to those portfolios where entitlements checks succeeded.", alias="allowPartialEntitlementSuccess")
+    apply_iso4217_rounding: Optional[StrictBool] = Field(default=None, description="Various results that are units of currency might need to be rounded.  This will round according to the ISO4217 standard number of decimal places for a currency.", alias="applyIso4217Rounding")
     __properties = ["useAnsiLikeSyntax", "allowPartialEntitlementSuccess", "applyIso4217Rounding"]
 
     class Config:
@@ -79,3 +81,5 @@ class AggregationOptions(BaseModel):
             "apply_iso4217_rounding": obj.get("applyIso4217Rounding")
         })
         return _obj
+
+AggregationOptions.update_forward_refs()

lusid/models/aggregation_query.py

@@ -17,9 +17,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
 from datetime import datetime
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool, StrictStr, constr, validator 
 from lusid.models.address_key_option_definition import AddressKeyOptionDefinition
 
 class AggregationQuery(BaseModel):
@@ -31,11 +33,11 @@ class AggregationQuery(BaseModel):
     display_name:  StrictStr = Field(...,alias="displayName", description="The suggested name that the user would wish to put on to the returned information for visualisation in preference to the address.") 
     type:  StrictStr = Field(...,alias="type", description="Financially meaningful results can be presented as either simple flat types or more complex expanded types. This field gives the type of the more complex representation.  For example, the present value (PV) of a holding could be represented either as a simple decimal (with currency implied) or as a decimal-currency pair. In this example, the type returned in this field would be \"Result0D\", the decimal-currency pair. The available values are: String, Int, Decimal, DateTime, Boolean, ResultValue, Result0D, Json") 
     flattened_type:  StrictStr = Field(...,alias="flattenedType", description="Financially meaningful results can be presented as either simple flat types or more complex expanded types. This field gives the type of the simpler representation.  For example, the present value (PV) of a holding could be represented either as a simple decimal (with currency implied) or as a decimal-currency pair. In this example, the type returned in this field would be \"Decimal\". The available values are: String, Int, Decimal, DateTime, Boolean, ResultValue, Result0D, Json") 
-    scales_with_holding_quantity: StrictBool = Field(..., alias="scalesWithHoldingQuantity", description="Is the data scaled when it is for, e.g. a holding in an instrument. A key example would be the difference between price and PV. The present value of an instrument would scale with the quantity held. The price would be that for a hypothetical unit of that instrument, typically associated with the contract size.")
+    scales_with_holding_quantity: StrictBool = Field(description="Is the data scaled when it is for, e.g. a holding in an instrument. A key example would be the difference between price and PV. The present value of an instrument would scale with the quantity held. The price would be that for a hypothetical unit of that instrument, typically associated with the contract size.", alias="scalesWithHoldingQuantity")
     supported_operations:  StrictStr = Field(...,alias="supportedOperations", description="When performing an aggregation operation, what column type operations can be performed on the data. For example, it makes sense to sum decimals but not strings. Either can be counted. With more complex types, e.g. ResultValues, operations may be linked to a semantic meaning such as the currency of the result. In such cases the operations may be supported but context specific. For example, it makes sense to sum PVs in a single currency but not when the currency is different. In such cases, an error would result (it being assumed that no fx rates for currency conversion were implicit in the context).") 
     life_cycle_status:  StrictStr = Field(...,alias="lifeCycleStatus", description="Within an API where an item can be accessed through an address or property, there is an associated status that determines whether the item is stable or likely to change. This status is one of [Experimental, Beta, EAP, Prod,  Deprecated]. If the item is deprecated it will be removed on or after the associated DateTime RemovalDate field. That field will not otherwise be set.") 
-    removal_date: Optional[datetime] = Field(None, alias="removalDate", description="If the life cycle status is set to deprecated then this will be populated with the date on or after which removal of the address query will happen")
-    applicable_options: Optional[Dict[str, AddressKeyOptionDefinition]] = Field(None, alias="applicableOptions", description="A mapping from option names to the definition that the corresponding option value must match.")
+    removal_date: Optional[datetime] = Field(default=None, description="If the life cycle status is set to deprecated then this will be populated with the date on or after which removal of the address query will happen", alias="removalDate")
+    applicable_options: Optional[Dict[str, AddressKeyOptionDefinition]] = Field(default=None, description="A mapping from option names to the definition that the corresponding option value must match.", alias="applicableOptions")
     __properties = ["addressKey", "description", "displayName", "type", "flattenedType", "scalesWithHoldingQuantity", "supportedOperations", "lifeCycleStatus", "removalDate", "applicableOptions"]
 
     @validator('type')
@@ -88,14 +90,19 @@ class AggregationQuery(BaseModel):
                                     'SchedulerJobResponse', 
                                     'SleepResponse',
                                     'Library',
-                                    'LibraryResponse']:
+                                    'LibraryResponse',
+                                    'DayRegularity',
+                                    'RelativeMonthRegularity',
+                                    'SpecificMonthRegularity',
+                                    'WeekRegularity',
+                                    'YearRegularity']:
            return value
         
         # Only validate the 'type' property of the class
         if "type" != "type":
             return value
 
-        if value not in ('String', 'Int', 'Decimal', 'DateTime', 'Boolean', 'ResultValue', 'Result0D', 'Json'):
+        if value not in ['String', 'Int', 'Decimal', 'DateTime', 'Boolean', 'ResultValue', 'Result0D', 'Json']:
             raise ValueError("must be one of enum values ('String', 'Int', 'Decimal', 'DateTime', 'Boolean', 'ResultValue', 'Result0D', 'Json')")
         return value
 
@@ -149,14 +156,19 @@ class AggregationQuery(BaseModel):
                                     'SchedulerJobResponse', 
                                     'SleepResponse',
                                     'Library',
-                                    'LibraryResponse']:
+                                    'LibraryResponse',
+                                    'DayRegularity',
+                                    'RelativeMonthRegularity',
+                                    'SpecificMonthRegularity',
+                                    'WeekRegularity',
+                                    'YearRegularity']:
            return value
         
         # Only validate the 'type' property of the class
         if "flattened_type" != "type":
             return value
 
-        if value not in ('String', 'Int', 'Decimal', 'DateTime', 'Boolean', 'ResultValue', 'Result0D', 'Json'):
+        if value not in ['String', 'Int', 'Decimal', 'DateTime', 'Boolean', 'ResultValue', 'Result0D', 'Json']:
             raise ValueError("must be one of enum values ('String', 'Int', 'Decimal', 'DateTime', 'Boolean', 'ResultValue', 'Result0D', 'Json')")
         return value
 
@@ -238,3 +250,5 @@ class AggregationQuery(BaseModel):
             else None
         })
         return _obj
+
+AggregationQuery.update_forward_refs()

lusid/models/aggregation_type.py

@@ -17,8 +17,10 @@ import pprint
 import re  # noqa: F401
 from aenum import Enum, no_arg
 
-
-
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 
 
 class AggregationType(str, Enum):

lusid/models/alias.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, constr, validator 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 
 class Alias(BaseModel):
     """
@@ -77,3 +79,5 @@ class Alias(BaseModel):
             "attribute_alias": obj.get("attributeAlias")
         })
         return _obj
+
+Alias.update_forward_refs()

lusid/models/allocation.py

@@ -17,9 +17,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictFloat, StrictInt, StrictStr, conlist, constr 
 from lusid.models.currency_and_amount import CurrencyAndAmount
 from lusid.models.data_model_membership import DataModelMembership
 from lusid.models.link import Link
@@ -31,28 +33,28 @@ class Allocation(BaseModel):
     """
     An Allocation of a certain quantity of a specific instrument against an originating  Order.  # noqa: E501
     """
-    id: ResourceId = Field(...)
-    allocated_order_id: ResourceId = Field(..., alias="allocatedOrderId")
-    portfolio_id: ResourceId = Field(..., alias="portfolioId")
-    quantity: Union[StrictFloat, StrictInt] = Field(..., description="The quantity of given instrument allocated.")
-    instrument_identifiers: Dict[str, StrictStr] = Field(..., alias="instrumentIdentifiers", description="The instrument allocated.")
+    id: ResourceId
+    allocated_order_id: ResourceId = Field(alias="allocatedOrderId")
+    portfolio_id: ResourceId = Field(alias="portfolioId")
+    quantity: Union[StrictFloat, StrictInt] = Field(description="The quantity of given instrument allocated.")
+    instrument_identifiers: Dict[str, Optional[StrictStr]] = Field(description="The instrument allocated.", alias="instrumentIdentifiers")
     version: Optional[Version] = None
-    properties: Optional[Dict[str, PerpetualProperty]] = Field(None, description="Client-defined properties associated with this allocation.")
+    properties: Optional[Dict[str, PerpetualProperty]] = Field(default=None, description="Client-defined properties associated with this allocation.")
     instrument_scope:  Optional[StrictStr] = Field(None,alias="instrumentScope", description="The scope in which the instrument lies") 
     lusid_instrument_id:  StrictStr = Field(...,alias="lusidInstrumentId", description="The LUSID instrument id for the instrument allocated.") 
-    placement_ids: Optional[conlist(ResourceId)] = Field(None, alias="placementIds", description="A placement - also known as an order placed in the market - associated with this allocation.")
+    placement_ids: Optional[List[ResourceId]] = Field(default=None, description="A placement - also known as an order placed in the market - associated with this allocation.", alias="placementIds")
     state:  Optional[StrictStr] = Field(None,alias="state", description="The state of this allocation.") 
     side:  Optional[StrictStr] = Field(None,alias="side", description="The side of this allocation (examples: Buy, Sell, ...).") 
     type:  Optional[StrictStr] = Field(None,alias="type", description="The type of order associated with this allocation (examples: Limit, Market, ...).") 
-    settlement_date: Optional[datetime] = Field(None, alias="settlementDate", description="The settlement date for this allocation.")
-    var_date: Optional[datetime] = Field(None, alias="date", description="The date of this allocation.")
+    settlement_date: Optional[datetime] = Field(default=None, description="The settlement date for this allocation.", alias="settlementDate")
+    var_date: Optional[datetime] = Field(default=None, description="The date of this allocation.", alias="date")
     price: Optional[CurrencyAndAmount] = None
     settlement_currency:  Optional[StrictStr] = Field(None,alias="settlementCurrency", description="The settlement currency of this allocation.") 
-    settlement_currency_fx_rate: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="settlementCurrencyFxRate", description="The settlement currency to allocation currency FX rate.")
+    settlement_currency_fx_rate: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The settlement currency to allocation currency FX rate.", alias="settlementCurrencyFxRate")
     counterparty:  Optional[StrictStr] = Field(None,alias="counterparty", description="The counterparty for this allocation.") 
-    execution_ids: Optional[conlist(ResourceId)] = Field(None, alias="executionIds", description="The executions associated with this allocation")
-    data_model_membership: Optional[DataModelMembership] = Field(None, alias="dataModelMembership")
-    links: Optional[conlist(Link)] = None
+    execution_ids: Optional[List[ResourceId]] = Field(default=None, description="The executions associated with this allocation", alias="executionIds")
+    data_model_membership: Optional[DataModelMembership] = Field(default=None, alias="dataModelMembership")
+    links: Optional[List[Link]] = None
     __properties = ["id", "allocatedOrderId", "portfolioId", "quantity", "instrumentIdentifiers", "version", "properties", "instrumentScope", "lusidInstrumentId", "placementIds", "state", "side", "type", "settlementDate", "date", "price", "settlementCurrency", "settlementCurrencyFxRate", "counterparty", "executionIds", "dataModelMembership", "links"]
 
     class Config:
@@ -234,3 +236,5 @@ class Allocation(BaseModel):
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj
+
+Allocation.update_forward_refs()