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

lusid/models/transaction_price.py

@@ -26,7 +26,7 @@ class TransactionPrice(BaseModel):
     TransactionPrice
     """
     price: Optional[Union[StrictFloat, StrictInt]] = None
-    type: Optional[StrictStr] = Field(None, description="The available values are: Price, Yield, Spread")
+    type: Optional[StrictStr] = Field(None, description="The available values are: Price, Yield, Spread, CashFlowPerUnit")
     __properties = ["price", "type"]
 
     @validator('type')
@@ -35,8 +35,8 @@ class TransactionPrice(BaseModel):
         if value is None:
             return value
 
-        if value not in ('Price', 'Yield', 'Spread'):
-            raise ValueError("must be one of enum values ('Price', 'Yield', 'Spread')")
+        if value not in ('Price', 'Yield', 'Spread', 'CashFlowPerUnit'):
+            raise ValueError("must be one of enum values ('Price', 'Yield', 'Spread', 'CashFlowPerUnit')")
         return value
 
     class Config:

lusid/models/transaction_price_and_type.py

@@ -0,0 +1,81 @@
+# 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, constr
+
+class TransactionPriceAndType(BaseModel):
+    """
+    TransactionPriceAndType
+    """
+    price: Optional[constr(strict=True, max_length=1024, min_length=0)] = None
+    type: Optional[constr(strict=True, max_length=1024, min_length=0)] = None
+    __properties = ["price", "type"]
+
+    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) -> TransactionPriceAndType:
+        """Create an instance of TransactionPriceAndType 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 price (nullable) is None
+        # and __fields_set__ contains the field
+        if self.price is None and "price" in self.__fields_set__:
+            _dict['price'] = None
+
+        # set to None if type (nullable) is None
+        # and __fields_set__ contains the field
+        if self.type is None and "type" in self.__fields_set__:
+            _dict['type'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> TransactionPriceAndType:
+        """Create an instance of TransactionPriceAndType from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return TransactionPriceAndType.parse_obj(obj)
+
+        _obj = TransactionPriceAndType.parse_obj({
+            "price": obj.get("price"),
+            "type": obj.get("type")
+        })
+        return _obj

lusid/models/transaction_price_type.py

@@ -32,6 +32,7 @@ class TransactionPriceType(str, Enum):
     PRICE = 'Price'
     YIELD = 'Yield'
     SPREAD = 'Spread'
+    CASHFLOWPERUNIT = 'CashFlowPerUnit'
 
     @classmethod
     def from_json(cls, json_str: str) -> TransactionPriceType:

lusid/models/transaction_property_map.py

@@ -0,0 +1,80 @@
+# 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.property_value import PropertyValue
+
+class TransactionPropertyMap(BaseModel):
+    """
+    TransactionPropertyMap
+    """
+    property_key: Optional[StrictStr] = Field(None, alias="propertyKey", description="The key that uniquely identifies the property. It has the format {domain}/{scope}/{code}.")
+    property_value: Optional[PropertyValue] = Field(None, alias="propertyValue")
+    __properties = ["propertyKey", "propertyValue"]
+
+    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) -> TransactionPropertyMap:
+        """Create an instance of TransactionPropertyMap 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 property_value
+        if self.property_value:
+            _dict['propertyValue'] = self.property_value.to_dict()
+        # set to None if property_key (nullable) is None
+        # and __fields_set__ contains the field
+        if self.property_key is None and "property_key" in self.__fields_set__:
+            _dict['propertyKey'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> TransactionPropertyMap:
+        """Create an instance of TransactionPropertyMap from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return TransactionPropertyMap.parse_obj(obj)
+
+        _obj = TransactionPropertyMap.parse_obj({
+            "property_key": obj.get("propertyKey"),
+            "property_value": PropertyValue.from_dict(obj.get("propertyValue")) if obj.get("propertyValue") is not None else None
+        })
+        return _obj

lusid/models/transaction_template.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
+from lusid.models.component_transaction import ComponentTransaction
+from lusid.models.link import Link
+
+class TransactionTemplate(BaseModel):
+    """
+    TransactionTemplate
+    """
+    instrument_type: constr(strict=True, min_length=1) = Field(..., alias="instrumentType", description="A value that represents the instrument type.")
+    instrument_event_type: constr(strict=True, min_length=1) = Field(..., alias="instrumentEventType", description="A value that represents the instrument event type.")
+    description: constr(strict=True, min_length=1) = Field(..., description="The description of the transaction template.")
+    scope: constr(strict=True, min_length=1) = Field(..., description="The scope in which the transaction template resides.")
+    component_transactions: conlist(ComponentTransaction) = Field(..., alias="componentTransactions", description="A set of component transactions that relate to the template to be created.")
+    links: Optional[conlist(Link)] = None
+    __properties = ["instrumentType", "instrumentEventType", "description", "scope", "componentTransactions", "links"]
+
+    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) -> TransactionTemplate:
+        """Create an instance of TransactionTemplate 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 component_transactions (list)
+        _items = []
+        if self.component_transactions:
+            for _item in self.component_transactions:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['componentTransactions'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in links (list)
+        _items = []
+        if self.links:
+            for _item in self.links:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['links'] = _items
+        # 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__:
+            _dict['links'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> TransactionTemplate:
+        """Create an instance of TransactionTemplate from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return TransactionTemplate.parse_obj(obj)
+
+        _obj = TransactionTemplate.parse_obj({
+            "instrument_type": obj.get("instrumentType"),
+            "instrument_event_type": obj.get("instrumentEventType"),
+            "description": obj.get("description"),
+            "scope": obj.get("scope"),
+            "component_transactions": [ComponentTransaction.from_dict(_item) for _item in obj.get("componentTransactions")] if obj.get("componentTransactions") 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/transaction_template_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, List
+from pydantic import BaseModel, Field, conlist, constr
+from lusid.models.component_transaction import ComponentTransaction
+
+class TransactionTemplateRequest(BaseModel):
+    """
+    TransactionTemplateRequest
+    """
+    description: constr(strict=True, max_length=100, min_length=0) = Field(..., description="The description of the transaction template.")
+    component_transactions: conlist(ComponentTransaction) = Field(..., alias="componentTransactions", description="A set of component transactions that relate to the template to be created.")
+    __properties = ["description", "componentTransactions"]
+
+    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) -> TransactionTemplateRequest:
+        """Create an instance of TransactionTemplateRequest 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 component_transactions (list)
+        _items = []
+        if self.component_transactions:
+            for _item in self.component_transactions:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['componentTransactions'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> TransactionTemplateRequest:
+        """Create an instance of TransactionTemplateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return TransactionTemplateRequest.parse_obj(obj)
+
+        _obj = TransactionTemplateRequest.parse_obj({
+            "description": obj.get("description"),
+            "component_transactions": [ComponentTransaction.from_dict(_item) for _item in obj.get("componentTransactions")] if obj.get("componentTransactions") is not None else None
+        })
+        return _obj

lusid/models/transaction_template_specification.py

@@ -0,0 +1,99 @@
+# 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 BaseModel, Field, StrictStr, conlist, constr
+from lusid.models.election_specification import ElectionSpecification
+from lusid.models.eligibility_calculation import EligibilityCalculation
+from lusid.models.template_field import TemplateField
+
+class TransactionTemplateSpecification(BaseModel):
+    """
+    TransactionTemplateSpecification
+    """
+    instrument_event_type: constr(strict=True, min_length=1) = Field(..., alias="instrumentEventType")
+    supported_instrument_types: conlist(StrictStr) = Field(..., alias="supportedInstrumentTypes")
+    supported_participation_types: conlist(StrictStr) = Field(..., alias="supportedParticipationTypes")
+    supported_election_types: conlist(ElectionSpecification) = Field(..., alias="supportedElectionTypes")
+    supported_template_fields: conlist(TemplateField) = Field(..., alias="supportedTemplateFields")
+    eligibility_calculation: EligibilityCalculation = Field(..., alias="eligibilityCalculation")
+    __properties = ["instrumentEventType", "supportedInstrumentTypes", "supportedParticipationTypes", "supportedElectionTypes", "supportedTemplateFields", "eligibilityCalculation"]
+
+    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) -> TransactionTemplateSpecification:
+        """Create an instance of TransactionTemplateSpecification 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 supported_election_types (list)
+        _items = []
+        if self.supported_election_types:
+            for _item in self.supported_election_types:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['supportedElectionTypes'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in supported_template_fields (list)
+        _items = []
+        if self.supported_template_fields:
+            for _item in self.supported_template_fields:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['supportedTemplateFields'] = _items
+        # override the default output from pydantic by calling `to_dict()` of eligibility_calculation
+        if self.eligibility_calculation:
+            _dict['eligibilityCalculation'] = self.eligibility_calculation.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> TransactionTemplateSpecification:
+        """Create an instance of TransactionTemplateSpecification from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return TransactionTemplateSpecification.parse_obj(obj)
+
+        _obj = TransactionTemplateSpecification.parse_obj({
+            "instrument_event_type": obj.get("instrumentEventType"),
+            "supported_instrument_types": obj.get("supportedInstrumentTypes"),
+            "supported_participation_types": obj.get("supportedParticipationTypes"),
+            "supported_election_types": [ElectionSpecification.from_dict(_item) for _item in obj.get("supportedElectionTypes")] if obj.get("supportedElectionTypes") is not None else None,
+            "supported_template_fields": [TemplateField.from_dict(_item) for _item in obj.get("supportedTemplateFields")] if obj.get("supportedTemplateFields") is not None else None,
+            "eligibility_calculation": EligibilityCalculation.from_dict(obj.get("eligibilityCalculation")) if obj.get("eligibilityCalculation") is not None else None
+        })
+        return _obj

lusid/models/transaction_type_alias.py

@@ -32,13 +32,6 @@ class TransactionTypeAlias(BaseModel):
     is_default: Optional[StrictBool] = Field(None, alias="isDefault", description="IsDefault is a flag that denotes the default alias for a source. There can only be, at most, one per source.")
     __properties = ["type", "description", "transactionClass", "transactionRoles", "isDefault"]
 
-    @validator('type')
-    def type_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
-            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
-        return value
-
     @validator('description')
     def description_validate_regular_expression(cls, value):
         """Validates the regular expression"""

lusid/models/transaction_type_calculation.py

@@ -26,7 +26,7 @@ class TransactionTypeCalculation(BaseModel):
     TransactionTypeCalculation
     """
     type: constr(strict=True, min_length=1) = Field(..., description="The type of calculation to perform")
-    side: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The Side determines which of the fields from our transaction are used to generate the Movement. Side1 means the 'security' side of the transaction, ie the Instrument and Units; Side2 means the 'cash' side, ie the Total Consideration")
+    side: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The side to which the calculation is applied")
     __properties = ["type", "side"]
 
     @validator('side')

lusid/models/transition_event.py

@@ -34,15 +34,15 @@ class TransitionEvent(InstrumentEvent):
     payment_date: Optional[datetime] = Field(None, alias="paymentDate", description="The payment date of the corporate action")
     input_transition: Optional[InputTransition] = Field(None, alias="inputTransition")
     output_transitions: Optional[conlist(OutputTransition)] = Field(None, alias="outputTransitions", description="The resulting transitions from this 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", "announcementDate", "exDate", "recordDate", "paymentDate", "inputTransition", "outputTransitions"]
 
     @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/translation_context.py

@@ -0,0 +1,75 @@
+# 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, StrictBool
+from lusid.models.script_map_reference import ScriptMapReference
+
+class TranslationContext(BaseModel):
+    """
+    Options for overriding default scripted translation configuration.  # noqa: E501
+    """
+    disable_scripted_translation: Optional[StrictBool] = Field(None, alias="disableScriptedTranslation")
+    script_map: Optional[ScriptMapReference] = Field(None, alias="scriptMap")
+    __properties = ["disableScriptedTranslation", "scriptMap"]
+
+    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) -> TranslationContext:
+        """Create an instance of TranslationContext 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 script_map
+        if self.script_map:
+            _dict['scriptMap'] = self.script_map.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> TranslationContext:
+        """Create an instance of TranslationContext from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return TranslationContext.parse_obj(obj)
+
+        _obj = TranslationContext.parse_obj({
+            "disable_scripted_translation": obj.get("disableScriptedTranslation"),
+            "script_map": ScriptMapReference.from_dict(obj.get("scriptMap")) if obj.get("scriptMap") is not None else None
+        })
+        return _obj

lusid/models/translation_script.py

@@ -18,9 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 from pydantic import BaseModel, Field, constr
 from lusid.models.translation_script_id import TranslationScriptId
+from lusid.models.version import Version
 
 class TranslationScript(BaseModel):
     """
@@ -28,7 +29,8 @@ class TranslationScript(BaseModel):
     """
     id: TranslationScriptId = Field(...)
     body: constr(strict=True, max_length=500000, min_length=0) = Field(..., description="Body of the translation script, i.e. the actual translation code.")
-    __properties = ["id", "body"]
+    version: Optional[Version] = None
+    __properties = ["id", "body", "version"]
 
     class Config:
         """Pydantic configuration"""
@@ -57,6 +59,9 @@ class TranslationScript(BaseModel):
         # 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 version
+        if self.version:
+            _dict['version'] = self.version.to_dict()
         return _dict
 
     @classmethod
@@ -70,6 +75,7 @@ class TranslationScript(BaseModel):
 
         _obj = TranslationScript.parse_obj({
             "id": TranslationScriptId.from_dict(obj.get("id")) if obj.get("id") is not None else None,
-            "body": obj.get("body")
+            "body": obj.get("body"),
+            "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None
         })
         return _obj