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

lusid/models/property_key_list_compliance_parameter.py

@@ -28,15 +28,15 @@ class PropertyKeyListComplianceParameter(ComplianceParameter):
     PropertyKeyListComplianceParameter
     """
     value: ResourceId = Field(...)
-    compliance_parameter_type: StrictStr = Field(..., alias="complianceParameterType", description="The parameter type. The available values are: BoolComplianceParameter, StringComplianceParameter, DecimalComplianceParameter, DateTimeComplianceParameter, PropertyKeyComplianceParameter, AddressKeyComplianceParameter, PortfolioIdComplianceParameter, PortfolioGroupIdComplianceParameter, StringListComplianceParameter, BoolListComplianceParameter, DateTimeListComplianceParameter, DecimalListComplianceParameter, PropertyKeyListComplianceParameter, AddressKeyListComplianceParameter, PortfolioIdListComplianceParameter, PortfolioGroupIdListComplianceParameter, InstrumentListComplianceParameter")
+    compliance_parameter_type: StrictStr = Field(..., alias="complianceParameterType", description="The parameter type. The available values are: BoolComplianceParameter, StringComplianceParameter, DecimalComplianceParameter, DateTimeComplianceParameter, PropertyKeyComplianceParameter, AddressKeyComplianceParameter, PortfolioIdComplianceParameter, PortfolioGroupIdComplianceParameter, StringListComplianceParameter, BoolListComplianceParameter, DateTimeListComplianceParameter, DecimalListComplianceParameter, PropertyKeyListComplianceParameter, AddressKeyListComplianceParameter, PortfolioIdListComplianceParameter, PortfolioGroupIdListComplianceParameter, InstrumentListComplianceParameter, FilterPredicateComplianceParameter, GroupFilterPredicateComplianceParameter, GroupBySelectorComplianceParameter")
     additional_properties: Dict[str, Any] = {}
     __properties = ["complianceParameterType", "value"]
 
     @validator('compliance_parameter_type')
     def compliance_parameter_type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in ('BoolComplianceParameter', 'StringComplianceParameter', 'DecimalComplianceParameter', 'DateTimeComplianceParameter', 'PropertyKeyComplianceParameter', 'AddressKeyComplianceParameter', 'PortfolioIdComplianceParameter', 'PortfolioGroupIdComplianceParameter', 'StringListComplianceParameter', 'BoolListComplianceParameter', 'DateTimeListComplianceParameter', 'DecimalListComplianceParameter', 'PropertyKeyListComplianceParameter', 'AddressKeyListComplianceParameter', 'PortfolioIdListComplianceParameter', 'PortfolioGroupIdListComplianceParameter', 'InstrumentListComplianceParameter'):
-            raise ValueError("must be one of enum values ('BoolComplianceParameter', 'StringComplianceParameter', 'DecimalComplianceParameter', 'DateTimeComplianceParameter', 'PropertyKeyComplianceParameter', 'AddressKeyComplianceParameter', 'PortfolioIdComplianceParameter', 'PortfolioGroupIdComplianceParameter', 'StringListComplianceParameter', 'BoolListComplianceParameter', 'DateTimeListComplianceParameter', 'DecimalListComplianceParameter', 'PropertyKeyListComplianceParameter', 'AddressKeyListComplianceParameter', 'PortfolioIdListComplianceParameter', 'PortfolioGroupIdListComplianceParameter', 'InstrumentListComplianceParameter')")
+        if value not in ('BoolComplianceParameter', 'StringComplianceParameter', 'DecimalComplianceParameter', 'DateTimeComplianceParameter', 'PropertyKeyComplianceParameter', 'AddressKeyComplianceParameter', 'PortfolioIdComplianceParameter', 'PortfolioGroupIdComplianceParameter', 'StringListComplianceParameter', 'BoolListComplianceParameter', 'DateTimeListComplianceParameter', 'DecimalListComplianceParameter', 'PropertyKeyListComplianceParameter', 'AddressKeyListComplianceParameter', 'PortfolioIdListComplianceParameter', 'PortfolioGroupIdListComplianceParameter', 'InstrumentListComplianceParameter', 'FilterPredicateComplianceParameter', 'GroupFilterPredicateComplianceParameter', 'GroupBySelectorComplianceParameter'):
+            raise ValueError("must be one of enum values ('BoolComplianceParameter', 'StringComplianceParameter', 'DecimalComplianceParameter', 'DateTimeComplianceParameter', 'PropertyKeyComplianceParameter', 'AddressKeyComplianceParameter', 'PortfolioIdComplianceParameter', 'PortfolioGroupIdComplianceParameter', 'StringListComplianceParameter', 'BoolListComplianceParameter', 'DateTimeListComplianceParameter', 'DecimalListComplianceParameter', 'PropertyKeyListComplianceParameter', 'AddressKeyListComplianceParameter', 'PortfolioIdListComplianceParameter', 'PortfolioGroupIdListComplianceParameter', 'InstrumentListComplianceParameter', 'FilterPredicateComplianceParameter', 'GroupFilterPredicateComplianceParameter', 'GroupBySelectorComplianceParameter')")
         return value
 
     class Config:

lusid/models/queryable_key.py

@@ -0,0 +1,124 @@
+# 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 datetime import datetime
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field, StrictStr, conlist, constr
+from lusid.models.address_key_option_definition import AddressKeyOptionDefinition
+
+class QueryableKey(BaseModel):
+    """
+    QueryableKey
+    """
+    address_key: constr(strict=True, min_length=1) = Field(..., alias="addressKey", description="The address that is the query to be made into the system. e.g. a Valuation/PV or Instrument/MaturityDate")
+    description: Optional[StrictStr] = Field(None, description="What does the information that is being queried by the address mean. What is the address for.")
+    display_name: constr(strict=True, min_length=1) = 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: constr(strict=True, min_length=1) = Field(..., 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.")
+    flattened_type: constr(strict=True, min_length=1) = 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\".")
+    holding_quantity_scaling: constr(strict=True, min_length=1) = Field(..., alias="holdingQuantityScaling", 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.")
+    supported_usages: conlist(StrictStr) = Field(..., alias="supportedUsages", description="The types of queries that support this key.")
+    supported_operations: conlist(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: constr(strict=True, min_length=1) = 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.")
+    derivation_formula: Optional[StrictStr] = Field(None, alias="derivationFormula", description="Derivation formula for when the for when the query key represents a DerivedValuation property.")
+    __properties = ["addressKey", "description", "displayName", "type", "flattenedType", "holdingQuantityScaling", "supportedUsages", "supportedOperations", "lifeCycleStatus", "removalDate", "applicableOptions", "derivationFormula"]
+
+    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) -> QueryableKey:
+        """Create an instance of QueryableKey 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 value in applicable_options (dict)
+        _field_dict = {}
+        if self.applicable_options:
+            for _key in self.applicable_options:
+                if self.applicable_options[_key]:
+                    _field_dict[_key] = self.applicable_options[_key].to_dict()
+            _dict['applicableOptions'] = _field_dict
+        # 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
+
+        # set to None if removal_date (nullable) is None
+        # and __fields_set__ contains the field
+        if self.removal_date is None and "removal_date" in self.__fields_set__:
+            _dict['removalDate'] = None
+
+        # set to None if applicable_options (nullable) is None
+        # and __fields_set__ contains the field
+        if self.applicable_options is None and "applicable_options" in self.__fields_set__:
+            _dict['applicableOptions'] = None
+
+        # set to None if derivation_formula (nullable) is None
+        # and __fields_set__ contains the field
+        if self.derivation_formula is None and "derivation_formula" in self.__fields_set__:
+            _dict['derivationFormula'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> QueryableKey:
+        """Create an instance of QueryableKey from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return QueryableKey.parse_obj(obj)
+
+        _obj = QueryableKey.parse_obj({
+            "address_key": obj.get("addressKey"),
+            "description": obj.get("description"),
+            "display_name": obj.get("displayName"),
+            "type": obj.get("type"),
+            "flattened_type": obj.get("flattenedType"),
+            "holding_quantity_scaling": obj.get("holdingQuantityScaling"),
+            "supported_usages": obj.get("supportedUsages"),
+            "supported_operations": obj.get("supportedOperations"),
+            "life_cycle_status": obj.get("lifeCycleStatus"),
+            "removal_date": obj.get("removalDate"),
+            "applicable_options": dict(
+                (_k, AddressKeyOptionDefinition.from_dict(_v))
+                for _k, _v in obj.get("applicableOptions").items()
+            )
+            if obj.get("applicableOptions") is not None
+            else None,
+            "derivation_formula": obj.get("derivationFormula")
+        })
+        return _obj

lusid/models/raw_vendor_event.py

@@ -30,16 +30,15 @@ class RawVendorEvent(InstrumentEvent):
     effective_at: datetime = Field(..., alias="effectiveAt", description="The effective date of the event")
     event_value: LifeCycleEventValue = Field(..., alias="eventValue")
     event_type: constr(strict=True, min_length=1) = Field(..., alias="eventType", description="What type of internal event does this represent; reset, exercise, amortisation etc.")
-    event_status: constr(strict=True, min_length=1) = Field(..., alias="eventStatus", description="What is the event status, is it a known (ie historic) or unknown (ie projected) event?")
-    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", "effectiveAt", "eventValue", "eventType", "eventStatus"]
+    __properties = ["instrumentEventType", "effectiveAt", "eventValue", "eventType"]
 
     @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:
@@ -90,8 +89,7 @@ class RawVendorEvent(InstrumentEvent):
             "instrument_event_type": obj.get("instrumentEventType"),
             "effective_at": obj.get("effectiveAt"),
             "event_value": LifeCycleEventValue.from_dict(obj.get("eventValue")) if obj.get("eventValue") is not None else None,
-            "event_type": obj.get("eventType"),
-            "event_status": obj.get("eventStatus")
+            "event_type": obj.get("eventType")
         })
         # store additional fields in additional_properties
         for _key in obj.keys():

lusid/models/re_open_period_diary_entry_request.py

@@ -0,0 +1,84 @@
+# 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, constr, validator
+
+class ReOpenPeriodDiaryEntryRequest(BaseModel):
+    """
+    A definition for the period you wish to re open  # noqa: E501
+    """
+    diary_entry_code: Optional[constr(strict=True, max_length=64, min_length=0)] = Field(None, alias="diaryEntryCode", description="Unique code assigned to a period. When left blank last period will be used.")
+    __properties = ["diaryEntryCode"]
+
+    @validator('diary_entry_code')
+    def diary_entry_code_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
+        return value
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        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) -> ReOpenPeriodDiaryEntryRequest:
+        """Create an instance of ReOpenPeriodDiaryEntryRequest 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)
+        # set to None if diary_entry_code (nullable) is None
+        # and __fields_set__ contains the field
+        if self.diary_entry_code is None and "diary_entry_code" in self.__fields_set__:
+            _dict['diaryEntryCode'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ReOpenPeriodDiaryEntryRequest:
+        """Create an instance of ReOpenPeriodDiaryEntryRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ReOpenPeriodDiaryEntryRequest.parse_obj(obj)
+
+        _obj = ReOpenPeriodDiaryEntryRequest.parse_obj({
+            "diary_entry_code": obj.get("diaryEntryCode")
+        })
+        return _obj

lusid/models/recipe_block.py

@@ -0,0 +1,87 @@
+# 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, StrictStr
+from lusid.models.recipe_value import RecipeValue
+
+class RecipeBlock(BaseModel):
+    """
+    An atomic operation used in Recipe composer to compose a Configuration Recipe  # noqa: E501
+    """
+    value: Optional[RecipeValue] = None
+    path: Optional[StrictStr] = Field(None, description="Path of the Value that the operation is to be performed on.")
+    op: Optional[StrictStr] = Field(None, description="Operation to be performed on the part of the value.")
+    __properties = ["value", "path", "op"]
+
+    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) -> RecipeBlock:
+        """Create an instance of RecipeBlock 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 value
+        if self.value:
+            _dict['value'] = self.value.to_dict()
+        # set to None if path (nullable) is None
+        # and __fields_set__ contains the field
+        if self.path is None and "path" in self.__fields_set__:
+            _dict['path'] = None
+
+        # set to None if op (nullable) is None
+        # and __fields_set__ contains the field
+        if self.op is None and "op" in self.__fields_set__:
+            _dict['op'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RecipeBlock:
+        """Create an instance of RecipeBlock from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RecipeBlock.parse_obj(obj)
+
+        _obj = RecipeBlock.parse_obj({
+            "value": RecipeValue.from_dict(obj.get("value")) if obj.get("value") is not None else None,
+            "path": obj.get("path"),
+            "op": obj.get("op")
+        })
+        return _obj

lusid/models/recipe_composer.py

@@ -0,0 +1,100 @@
+# 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, validator
+from lusid.models.recipe_block import RecipeBlock
+
+class RecipeComposer(BaseModel):
+    """
+    Recipe composer is an object used to dynamically compose Configuration Recipe from atomic operations.  # noqa: E501
+    """
+    scope: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The scope used when updating or inserting the Recipe Composer.")
+    code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="User given string name (code) to identify the recipe.")
+    operations: Optional[conlist(RecipeBlock)] = Field(None, description="Atomic operations used to compose a Configuration Recipe.")
+    __properties = ["scope", "code", "operations"]
+
+    @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
+
+    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) -> RecipeComposer:
+        """Create an instance of RecipeComposer 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 operations (list)
+        _items = []
+        if self.operations:
+            for _item in self.operations:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['operations'] = _items
+        # set to None if operations (nullable) is None
+        # and __fields_set__ contains the field
+        if self.operations is None and "operations" in self.__fields_set__:
+            _dict['operations'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RecipeComposer:
+        """Create an instance of RecipeComposer from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RecipeComposer.parse_obj(obj)
+
+        _obj = RecipeComposer.parse_obj({
+            "scope": obj.get("scope"),
+            "code": obj.get("code"),
+            "operations": [RecipeBlock.from_dict(_item) for _item in obj.get("operations")] if obj.get("operations") is not None else None
+        })
+        return _obj

lusid/models/{reconciliation_break_id.py → recipe_value.py}

@@ -20,16 +20,16 @@ import json
 
 from typing import Any, Dict, Optional
 from pydantic import BaseModel, Field, StrictStr
-from lusid.models.reconciliation_run_id import ReconciliationRunId
+from lusid.models.from_recipe import FromRecipe
 
-class ReconciliationBreakId(BaseModel):
+class RecipeValue(BaseModel):
     """
-    ReconciliationBreakId
+    Recipe value represents a data that is then used to perform an atomic operation which is then used in composition of Configuration Recipe.  This object either includes the data itself (in json form or as simple string) or is a reference where the data can be obtained from (from a Configuration Recipe say).  Only one field is to be populated.  # noqa: E501
     """
-    reconciliation_run: Optional[ReconciliationRunId] = Field(None, alias="reconciliationRun")
-    break_id: Optional[StrictStr] = Field(None, alias="breakId")
-    as_string: Optional[StrictStr] = Field(None, alias="asString")
-    __properties = ["reconciliationRun", "breakId", "asString"]
+    as_json: Optional[StrictStr] = Field(None, alias="asJson", description="Field to allow providing a potentially complex json value.")
+    as_string: Optional[StrictStr] = Field(None, alias="asString", description="For simple value, a single input value, note complex nested objects are not allowed here.")
+    from_recipe: Optional[FromRecipe] = Field(None, alias="fromRecipe")
+    __properties = ["asJson", "asString", "fromRecipe"]
 
     class Config:
         """Pydantic configuration"""
@@ -45,24 +45,23 @@ class ReconciliationBreakId(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> ReconciliationBreakId:
-        """Create an instance of ReconciliationBreakId from a JSON string"""
+    def from_json(cls, json_str: str) -> RecipeValue:
+        """Create an instance of RecipeValue 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={
-                            "as_string",
                           },
                           exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of reconciliation_run
-        if self.reconciliation_run:
-            _dict['reconciliationRun'] = self.reconciliation_run.to_dict()
-        # set to None if break_id (nullable) is None
+        # override the default output from pydantic by calling `to_dict()` of from_recipe
+        if self.from_recipe:
+            _dict['fromRecipe'] = self.from_recipe.to_dict()
+        # set to None if as_json (nullable) is None
         # and __fields_set__ contains the field
-        if self.break_id is None and "break_id" in self.__fields_set__:
-            _dict['breakId'] = None
+        if self.as_json is None and "as_json" in self.__fields_set__:
+            _dict['asJson'] = None
 
         # set to None if as_string (nullable) is None
         # and __fields_set__ contains the field
@@ -72,17 +71,17 @@ class ReconciliationBreakId(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> ReconciliationBreakId:
-        """Create an instance of ReconciliationBreakId from a dict"""
+    def from_dict(cls, obj: dict) -> RecipeValue:
+        """Create an instance of RecipeValue from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return ReconciliationBreakId.parse_obj(obj)
+            return RecipeValue.parse_obj(obj)
 
-        _obj = ReconciliationBreakId.parse_obj({
-            "reconciliation_run": ReconciliationRunId.from_dict(obj.get("reconciliationRun")) if obj.get("reconciliationRun") is not None else None,
-            "break_id": obj.get("breakId"),
-            "as_string": obj.get("asString")
+        _obj = RecipeValue.parse_obj({
+            "as_json": obj.get("asJson"),
+            "as_string": obj.get("asString"),
+            "from_recipe": FromRecipe.from_dict(obj.get("fromRecipe")) if obj.get("fromRecipe") is not None else None
         })
         return _obj

lusid/models/recombine_step.py

@@ -0,0 +1,101 @@
+# 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
+from pydantic import Field, StrictStr, conlist, constr, validator
+from lusid.models.compliance_step import ComplianceStep
+from lusid.models.compliance_template_parameter import ComplianceTemplateParameter
+
+class RecombineStep(ComplianceStep):
+    """
+    RecombineStep
+    """
+    label: constr(strict=True, min_length=1) = Field(..., description="The label of the compliance step")
+    parameters: conlist(ComplianceTemplateParameter) = Field(..., description="Parameters required for the step")
+    compliance_step_type: StrictStr = Field(..., alias="complianceStepType", description=". The available values are: FilterStep, GroupByStep, GroupFilterStep, BranchStep, RecombineStep, CheckStep")
+    additional_properties: Dict[str, Any] = {}
+    __properties = ["complianceStepType", "label", "parameters"]
+
+    @validator('compliance_step_type')
+    def compliance_step_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in ('FilterStep', 'GroupByStep', 'GroupFilterStep', 'BranchStep', 'RecombineStep', 'CheckStep'):
+            raise ValueError("must be one of enum values ('FilterStep', 'GroupByStep', 'GroupFilterStep', 'BranchStep', 'RecombineStep', 'CheckStep')")
+        return value
+
+    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) -> RecombineStep:
+        """Create an instance of RecombineStep 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={
+                            "additional_properties"
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in parameters (list)
+        _items = []
+        if self.parameters:
+            for _item in self.parameters:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['parameters'] = _items
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RecombineStep:
+        """Create an instance of RecombineStep from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RecombineStep.parse_obj(obj)
+
+        _obj = RecombineStep.parse_obj({
+            "compliance_step_type": obj.get("complianceStepType"),
+            "label": obj.get("label"),
+            "parameters": [ComplianceTemplateParameter.from_dict(_item) for _item in obj.get("parameters")] if obj.get("parameters") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj