lusid-sdk 2.0.50b0__py3-none-any.whl → 2.0.470__py3-none-any.whl

lusid/models/trial_balance.py

@@ -18,9 +18,11 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional, Union
-from pydantic import BaseModel, Field, StrictFloat, StrictInt, StrictStr, conlist, constr
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field, StrictStr, conlist, constr
 from lusid.models.link import Link
+from lusid.models.model_property import ModelProperty
+from lusid.models.multi_currency_amounts import MultiCurrencyAmounts
 
 class TrialBalance(BaseModel):
     """
@@ -30,12 +32,14 @@ class TrialBalance(BaseModel):
     description: Optional[StrictStr] = Field(None, description="The description of the record")
     levels: conlist(StrictStr) = Field(..., description="The levels that have been derived from the specified General Ledger Profile")
     account_type: constr(strict=True, min_length=1) = Field(..., alias="accountType", description="The account type attributed to the record")
-    opening: Union[StrictFloat, StrictInt] = Field(..., description="The opening balance at the start of the period")
-    closing: Union[StrictFloat, StrictInt] = Field(..., description="The closing balance at the end of the period")
-    debit: Union[StrictFloat, StrictInt] = Field(..., description="All debits that occured in the period")
-    credit: Union[StrictFloat, StrictInt] = Field(..., description="All credits that occured in the period")
+    local_currency: constr(strict=True, min_length=1) = Field(..., alias="localCurrency", description="The account type attributed to the record")
+    opening: MultiCurrencyAmounts = Field(...)
+    closing: MultiCurrencyAmounts = Field(...)
+    debit: MultiCurrencyAmounts = Field(...)
+    credit: MultiCurrencyAmounts = Field(...)
+    properties: Optional[Dict[str, ModelProperty]] = Field(None, description="Properties found on the mapped 'Account', as specified in request")
     links: Optional[conlist(Link)] = None
-    __properties = ["generalLedgerAccountCode", "description", "levels", "accountType", "opening", "closing", "debit", "credit", "links"]
+    __properties = ["generalLedgerAccountCode", "description", "levels", "accountType", "localCurrency", "opening", "closing", "debit", "credit", "properties", "links"]
 
     class Config:
         """Pydantic configuration"""
@@ -61,6 +65,25 @@ class TrialBalance(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of opening
+        if self.opening:
+            _dict['opening'] = self.opening.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of closing
+        if self.closing:
+            _dict['closing'] = self.closing.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of debit
+        if self.debit:
+            _dict['debit'] = self.debit.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of credit
+        if self.credit:
+            _dict['credit'] = self.credit.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each value in properties (dict)
+        _field_dict = {}
+        if self.properties:
+            for _key in self.properties:
+                if self.properties[_key]:
+                    _field_dict[_key] = self.properties[_key].to_dict()
+            _dict['properties'] = _field_dict
         # override the default output from pydantic by calling `to_dict()` of each item in links (list)
         _items = []
         if self.links:
@@ -73,6 +96,11 @@ class TrialBalance(BaseModel):
         if self.description is None and "description" in self.__fields_set__:
             _dict['description'] = None
 
+        # set to None if properties (nullable) is None
+        # and __fields_set__ contains the field
+        if self.properties is None and "properties" in self.__fields_set__:
+            _dict['properties'] = None
+
         # set to None if links (nullable) is None
         # and __fields_set__ contains the field
         if self.links is None and "links" in self.__fields_set__:
@@ -94,10 +122,17 @@ class TrialBalance(BaseModel):
             "description": obj.get("description"),
             "levels": obj.get("levels"),
             "account_type": obj.get("accountType"),
-            "opening": obj.get("opening"),
-            "closing": obj.get("closing"),
-            "debit": obj.get("debit"),
-            "credit": obj.get("credit"),
+            "local_currency": obj.get("localCurrency"),
+            "opening": MultiCurrencyAmounts.from_dict(obj.get("opening")) if obj.get("opening") is not None else None,
+            "closing": MultiCurrencyAmounts.from_dict(obj.get("closing")) if obj.get("closing") is not None else None,
+            "debit": MultiCurrencyAmounts.from_dict(obj.get("debit")) if obj.get("debit") is not None else None,
+            "credit": MultiCurrencyAmounts.from_dict(obj.get("credit")) if obj.get("credit") is not None else None,
+            "properties": dict(
+                (_k, ModelProperty.from_dict(_v))
+                for _k, _v in obj.get("properties").items()
+            )
+            if obj.get("properties") is not None
+            else None,
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj

lusid/models/trial_balance_query_parameters.py

@@ -18,8 +18,8 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional
-from pydantic import BaseModel, Field, StrictStr, constr, validator
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field, StrictBool, StrictStr, conlist, constr, validator
 from lusid.models.date_or_diary_entry import DateOrDiaryEntry
 
 class TrialBalanceQueryParameters(BaseModel):
@@ -28,9 +28,11 @@ class TrialBalanceQueryParameters(BaseModel):
     """
     start: Optional[DateOrDiaryEntry] = None
     end: Optional[DateOrDiaryEntry] = None
-    date_mode: Optional[StrictStr] = Field(None, alias="dateMode", description="The mode of calculation of the journal entry lines.")
-    general_ledger_profile_code: Optional[constr(strict=True, max_length=64, min_length=1)] = Field(None, alias="generalLedgerProfileCode", description="The optional code of a general ledger profile used to decorate journal entry lines with levels.")
-    __properties = ["start", "end", "dateMode", "generalLedgerProfileCode"]
+    date_mode: Optional[StrictStr] = Field(None, alias="dateMode", description="The mode of calculation of the trial balance. The available values are: ActivityDate.")
+    general_ledger_profile_code: Optional[constr(strict=True, max_length=64, min_length=1)] = Field(None, alias="generalLedgerProfileCode", description="The optional code of a general ledger profile used to decorate trial balance with levels.")
+    property_keys: Optional[conlist(StrictStr)] = Field(None, alias="propertyKeys", description="A list of property keys from the 'Instrument', 'Transaction', 'Portfolio', 'Account', 'LegalEntity' or 'CustodianAccount' domain to decorate onto the trial balance.")
+    exclude_cleardown_module: Optional[StrictBool] = Field(None, alias="excludeCleardownModule", description="By deafult this flag is set to false, if this is set to true, no cleardown module will be applied to the trial balance.")
+    __properties = ["start", "end", "dateMode", "generalLedgerProfileCode", "propertyKeys", "excludeCleardownModule"]
 
     @validator('general_ledger_profile_code')
     def general_ledger_profile_code_validate_regular_expression(cls, value):
@@ -82,6 +84,11 @@ class TrialBalanceQueryParameters(BaseModel):
         if self.general_ledger_profile_code is None and "general_ledger_profile_code" in self.__fields_set__:
             _dict['generalLedgerProfileCode'] = None
 
+        # set to None if property_keys (nullable) is None
+        # and __fields_set__ contains the field
+        if self.property_keys is None and "property_keys" in self.__fields_set__:
+            _dict['propertyKeys'] = None
+
         return _dict
 
     @classmethod
@@ -97,6 +104,8 @@ class TrialBalanceQueryParameters(BaseModel):
             "start": DateOrDiaryEntry.from_dict(obj.get("start")) if obj.get("start") is not None else None,
             "end": DateOrDiaryEntry.from_dict(obj.get("end")) if obj.get("end") is not None else None,
             "date_mode": obj.get("dateMode"),
-            "general_ledger_profile_code": obj.get("generalLedgerProfileCode")
+            "general_ledger_profile_code": obj.get("generalLedgerProfileCode"),
+            "property_keys": obj.get("propertyKeys"),
+            "exclude_cleardown_module": obj.get("excludeCleardownModule")
         })
         return _obj

lusid/models/trigger_event.py

@@ -31,15 +31,15 @@ class TriggerEvent(InstrumentEvent):
     trigger_direction: constr(strict=True, min_length=1) = Field(..., alias="triggerDirection", description="The direction of the trigger; valid options are Up and Down")
     trigger_date: datetime = Field(..., alias="triggerDate", description="The date the trigger happens at.")
     maturity_date: datetime = Field(..., alias="maturityDate", description="The date the trigger takes effect.")
-    instrument_event_type: StrictStr = Field(..., alias="instrumentEventType", description="The Type of Event. The available values are: TransitionEvent, InformationalEvent, OpenEvent, CloseEvent, StockSplitEvent, BondDefaultEvent, CashDividendEvent, AmortisationEvent, CashFlowEvent, ExerciseEvent, ResetEvent, TriggerEvent, RawVendorEvent, InformationalErrorEvent")
+    instrument_event_type: StrictStr = Field(..., alias="instrumentEventType", description="The Type of Event. The available values are: TransitionEvent, InformationalEvent, OpenEvent, CloseEvent, StockSplitEvent, BondDefaultEvent, CashDividendEvent, AmortisationEvent, CashFlowEvent, ExerciseEvent, ResetEvent, TriggerEvent, RawVendorEvent, InformationalErrorEvent, BondCouponEvent, DividendReinvestmentEvent, AccumulationEvent, BondPrincipalEvent, DividendOptionEvent, MaturityEvent, FxForwardSettlementEvent, ExpiryEvent")
     additional_properties: Dict[str, Any] = {}
     __properties = ["instrumentEventType", "level", "triggerType", "triggerDirection", "triggerDate", "maturityDate"]
 
     @validator('instrument_event_type')
     def instrument_event_type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in ('TransitionEvent', 'InformationalEvent', 'OpenEvent', 'CloseEvent', 'StockSplitEvent', 'BondDefaultEvent', 'CashDividendEvent', 'AmortisationEvent', 'CashFlowEvent', 'ExerciseEvent', 'ResetEvent', 'TriggerEvent', 'RawVendorEvent', 'InformationalErrorEvent'):
-            raise ValueError("must be one of enum values ('TransitionEvent', 'InformationalEvent', 'OpenEvent', 'CloseEvent', 'StockSplitEvent', 'BondDefaultEvent', 'CashDividendEvent', 'AmortisationEvent', 'CashFlowEvent', 'ExerciseEvent', 'ResetEvent', 'TriggerEvent', 'RawVendorEvent', 'InformationalErrorEvent')")
+        if value not in ('TransitionEvent', 'InformationalEvent', 'OpenEvent', 'CloseEvent', 'StockSplitEvent', 'BondDefaultEvent', 'CashDividendEvent', 'AmortisationEvent', 'CashFlowEvent', 'ExerciseEvent', 'ResetEvent', 'TriggerEvent', 'RawVendorEvent', 'InformationalErrorEvent', 'BondCouponEvent', 'DividendReinvestmentEvent', 'AccumulationEvent', 'BondPrincipalEvent', 'DividendOptionEvent', 'MaturityEvent', 'FxForwardSettlementEvent', 'ExpiryEvent'):
+            raise ValueError("must be one of enum values ('TransitionEvent', 'InformationalEvent', 'OpenEvent', 'CloseEvent', 'StockSplitEvent', 'BondDefaultEvent', 'CashDividendEvent', 'AmortisationEvent', 'CashFlowEvent', 'ExerciseEvent', 'ResetEvent', 'TriggerEvent', 'RawVendorEvent', 'InformationalErrorEvent', 'BondCouponEvent', 'DividendReinvestmentEvent', 'AccumulationEvent', 'BondPrincipalEvent', 'DividendOptionEvent', 'MaturityEvent', 'FxForwardSettlementEvent', 'ExpiryEvent')")
         return value
 
     class Config:

lusid/models/units_ratio.py

@@ -0,0 +1,71 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, Union
+from pydantic import BaseModel, Field, StrictFloat, StrictInt
+
+class UnitsRatio(BaseModel):
+    """
+    The number of units you have after the event (output) for a given number of units you have prior to the event (input).  # noqa: E501
+    """
+    input: Union[StrictFloat, StrictInt] = Field(..., description="Input amount.  Denominator of the Ratio")
+    output: Union[StrictFloat, StrictInt] = Field(..., description="Output amount. Numerator of the Ratio")
+    __properties = ["input", "output"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> UnitsRatio:
+        """Create an instance of UnitsRatio from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> UnitsRatio:
+        """Create an instance of UnitsRatio from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return UnitsRatio.parse_obj(obj)
+
+        _obj = UnitsRatio.parse_obj({
+            "input": obj.get("input"),
+            "output": obj.get("output")
+        })
+        return _obj

lusid/models/update_staging_rule_set_request.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field, conlist, constr
+from lusid.models.staging_rule import StagingRule
+
+class UpdateStagingRuleSetRequest(BaseModel):
+    """
+    UpdateStagingRuleSetRequest
+    """
+    display_name: Optional[constr(strict=True, max_length=256, min_length=1)] = Field(None, alias="displayName", description="The name of the staging rule set.")
+    description: Optional[constr(strict=True, max_length=1024, min_length=0)] = Field(None, description="A description for the staging rule set.")
+    rules: conlist(StagingRule) = Field(..., description="The list of staging rules that apply to a specific entity type.")
+    __properties = ["displayName", "description", "rules"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> UpdateStagingRuleSetRequest:
+        """Create an instance of UpdateStagingRuleSetRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in rules (list)
+        _items = []
+        if self.rules:
+            for _item in self.rules:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['rules'] = _items
+        # set to None if display_name (nullable) is None
+        # and __fields_set__ contains the field
+        if self.display_name is None and "display_name" in self.__fields_set__:
+            _dict['displayName'] = None
+
+        # set to None if description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> UpdateStagingRuleSetRequest:
+        """Create an instance of UpdateStagingRuleSetRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return UpdateStagingRuleSetRequest.parse_obj(obj)
+
+        _obj = UpdateStagingRuleSetRequest.parse_obj({
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "rules": [StagingRule.from_dict(_item) for _item in obj.get("rules")] if obj.get("rules") is not None else None
+        })
+        return _obj

lusid/models/{compliance_run_summary.py → upsert_compliance_run_summary_result.py}

@@ -23,9 +23,9 @@ from pydantic import BaseModel, Field, conlist, constr
 from lusid.models.compliance_summary_rule_result import ComplianceSummaryRuleResult
 from lusid.models.resource_id import ResourceId
 
-class ComplianceRunSummary(BaseModel):
+class UpsertComplianceRunSummaryResult(BaseModel):
     """
-    ComplianceRunSummary
+    UpsertComplianceRunSummaryResult
     """
     run_id: ResourceId = Field(..., alias="runId")
     instigated_at: datetime = Field(..., alias="instigatedAt")
@@ -48,8 +48,8 @@ class ComplianceRunSummary(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> ComplianceRunSummary:
-        """Create an instance of ComplianceRunSummary from a JSON string"""
+    def from_json(cls, json_str: str) -> UpsertComplianceRunSummaryResult:
+        """Create an instance of UpsertComplianceRunSummaryResult from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self):
@@ -71,15 +71,15 @@ class ComplianceRunSummary(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> ComplianceRunSummary:
-        """Create an instance of ComplianceRunSummary from a dict"""
+    def from_dict(cls, obj: dict) -> UpsertComplianceRunSummaryResult:
+        """Create an instance of UpsertComplianceRunSummaryResult from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return ComplianceRunSummary.parse_obj(obj)
+            return UpsertComplianceRunSummaryResult.parse_obj(obj)
 
-        _obj = ComplianceRunSummary.parse_obj({
+        _obj = UpsertComplianceRunSummaryResult.parse_obj({
             "run_id": ResourceId.from_dict(obj.get("runId")) if obj.get("runId") is not None else None,
             "instigated_at": obj.get("instigatedAt"),
             "completed_at": obj.get("completedAt"),

lusid/models/upsert_dialect_request.py

@@ -0,0 +1,79 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict
+from pydantic import BaseModel, Field
+from lusid.models.dialect_id import DialectId
+from lusid.models.dialect_schema import DialectSchema
+
+class UpsertDialectRequest(BaseModel):
+    """
+    UpsertDialectRequest
+    """
+    id: DialectId = Field(...)
+    var_schema: DialectSchema = Field(..., alias="schema")
+    __properties = ["id", "schema"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> UpsertDialectRequest:
+        """Create an instance of UpsertDialectRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of id
+        if self.id:
+            _dict['id'] = self.id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of var_schema
+        if self.var_schema:
+            _dict['schema'] = self.var_schema.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> UpsertDialectRequest:
+        """Create an instance of UpsertDialectRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return UpsertDialectRequest.parse_obj(obj)
+
+        _obj = UpsertDialectRequest.parse_obj({
+            "id": DialectId.from_dict(obj.get("id")) if obj.get("id") is not None else None,
+            "var_schema": DialectSchema.from_dict(obj.get("schema")) if obj.get("schema") is not None else None
+        })
+        return _obj

lusid/models/upsert_instrument_event_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, StrictStr, conlist, constr, validator
+from pydantic import BaseModel, Field, StrictInt, StrictStr, conlist, constr, validator
 from lusid.models.instrument_event import InstrumentEvent
 from lusid.models.perpetual_property import PerpetualProperty
 
@@ -32,7 +32,9 @@ class UpsertInstrumentEventRequest(BaseModel):
     description: Optional[constr(strict=True, max_length=1024, min_length=0)] = Field(None, description="The description of the instrument event.")
     instrument_event: InstrumentEvent = Field(..., alias="instrumentEvent")
     properties: Optional[conlist(PerpetualProperty)] = Field(None, description="The properties attached to this instrument event.")
-    __properties = ["instrumentEventId", "instrumentIdentifiers", "description", "instrumentEvent", "properties"]
+    sequence_number: Optional[StrictInt] = Field(None, alias="sequenceNumber", description="The order of the instrument event relative others on the same date (0 being processed first). Must be non negative.")
+    participation_type: Optional[StrictStr] = Field('Mandatory', alias="participationType", description="Is participation in this event Mandatory, MandatoryWithChoices, or Voluntary.")
+    __properties = ["instrumentEventId", "instrumentIdentifiers", "description", "instrumentEvent", "properties", "sequenceNumber", "participationType"]
 
     @validator('instrument_event_id')
     def instrument_event_id_validate_regular_expression(cls, value):
@@ -95,6 +97,11 @@ class UpsertInstrumentEventRequest(BaseModel):
         if self.properties is None and "properties" in self.__fields_set__:
             _dict['properties'] = None
 
+        # set to None if participation_type (nullable) is None
+        # and __fields_set__ contains the field
+        if self.participation_type is None and "participation_type" in self.__fields_set__:
+            _dict['participationType'] = None
+
         return _dict
 
     @classmethod
@@ -111,6 +118,8 @@ class UpsertInstrumentEventRequest(BaseModel):
             "instrument_identifiers": obj.get("instrumentIdentifiers"),
             "description": obj.get("description"),
             "instrument_event": InstrumentEvent.from_dict(obj.get("instrumentEvent")) if obj.get("instrumentEvent") is not None else None,
-            "properties": [PerpetualProperty.from_dict(_item) for _item in obj.get("properties")] if obj.get("properties") is not None else None
+            "properties": [PerpetualProperty.from_dict(_item) for _item in obj.get("properties")] if obj.get("properties") is not None else None,
+            "sequence_number": obj.get("sequenceNumber"),
+            "participation_type": obj.get("participationType") if obj.get("participationType") is not None else 'Mandatory'
         })
         return _obj

lusid/models/upsert_quote_request.py

@@ -25,7 +25,7 @@ from lusid.models.quote_id import QuoteId
 
 class UpsertQuoteRequest(BaseModel):
     """
-    The details of the quote including its unique identifier, value and lineage.  # noqa: E501
+    The details of the quote including its unique identifier, value and lineage.  Please note the Unit field on MetricValue is nullable on the upsert but there  is validation within the quote store to make sure this field is populated.  In the absence of a real unit then we recommend putting something in line with  the data in QuoteId.QuoteSeriesId.quoteType e.g. InterestRate.  # noqa: E501
     """
     quote_id: QuoteId = Field(..., alias="quoteId")
     metric_value: Optional[MetricValue] = Field(None, alias="metricValue")

lusid/models/upsert_recipe_composer_request.py

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, Optional
+from pydantic import BaseModel, Field
+from lusid.models.recipe_composer import RecipeComposer
+
+class UpsertRecipeComposerRequest(BaseModel):
+    """
+    A recipe composer that is to be stored in the recipe composer data store or used for inline resolving.  # noqa: E501
+    """
+    recipe_composer: Optional[RecipeComposer] = Field(None, alias="recipeComposer")
+    __properties = ["recipeComposer"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> UpsertRecipeComposerRequest:
+        """Create an instance of UpsertRecipeComposerRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of recipe_composer
+        if self.recipe_composer:
+            _dict['recipeComposer'] = self.recipe_composer.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> UpsertRecipeComposerRequest:
+        """Create an instance of UpsertRecipeComposerRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return UpsertRecipeComposerRequest.parse_obj(obj)
+
+        _obj = UpsertRecipeComposerRequest.parse_obj({
+            "recipe_composer": RecipeComposer.from_dict(obj.get("recipeComposer")) if obj.get("recipeComposer") is not None else None
+        })
+        return _obj

lusid/models/upsert_recipe_request.py

@@ -21,15 +21,13 @@ import json
 from typing import Any, Dict, Optional
 from pydantic import BaseModel, Field
 from lusid.models.configuration_recipe import ConfigurationRecipe
-from lusid.models.configuration_recipe_snippet import ConfigurationRecipeSnippet
 
 class UpsertRecipeRequest(BaseModel):
     """
-    A recipe or recipe snippet that is to be stored in the recipe structured data store.  Only one of these must be present.  # noqa: E501
+    A recipe that is to be stored in the recipe structured data store.  Only one of these must be present.  # noqa: E501
     """
     configuration_recipe: Optional[ConfigurationRecipe] = Field(None, alias="configurationRecipe")
-    configuration_recipe_snippet: Optional[ConfigurationRecipeSnippet] = Field(None, alias="configurationRecipeSnippet")
-    __properties = ["configurationRecipe", "configurationRecipeSnippet"]
+    __properties = ["configurationRecipe"]
 
     class Config:
         """Pydantic configuration"""
@@ -58,9 +56,6 @@ class UpsertRecipeRequest(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of configuration_recipe
         if self.configuration_recipe:
             _dict['configurationRecipe'] = self.configuration_recipe.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of configuration_recipe_snippet
-        if self.configuration_recipe_snippet:
-            _dict['configurationRecipeSnippet'] = self.configuration_recipe_snippet.to_dict()
         return _dict
 
     @classmethod
@@ -73,7 +68,6 @@ class UpsertRecipeRequest(BaseModel):
             return UpsertRecipeRequest.parse_obj(obj)
 
         _obj = UpsertRecipeRequest.parse_obj({
-            "configuration_recipe": ConfigurationRecipe.from_dict(obj.get("configurationRecipe")) if obj.get("configurationRecipe") is not None else None,
-            "configuration_recipe_snippet": ConfigurationRecipeSnippet.from_dict(obj.get("configurationRecipeSnippet")) if obj.get("configurationRecipeSnippet") is not None else None
+            "configuration_recipe": ConfigurationRecipe.from_dict(obj.get("configurationRecipe")) if obj.get("configurationRecipe") is not None else None
         })
         return _obj