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

lusid/models/lusid_instrument.py

@@ -19,21 +19,21 @@ import json
 
 
 from typing import Any, Dict, Union
-from pydantic import BaseModel, Field, StrictStr, validator
+from pydantic.v1 import BaseModel, Field, StrictStr, validator
 import lusid.models
 
 class LusidInstrument(BaseModel):
     """
     Base class in the hierarchy for representing the full economic definition of instruments in LUSID.  These definitions are used to provide instrument analytics such as PV, accrual, cash flows, and risk.  This base class should not be directly instantiated; each supported InstrumentType has a corresponding inherited class.  # noqa: E501
     """
-    instrument_type: StrictStr = Field(..., alias="instrumentType", description="The available values are: QuotedSecurity, InterestRateSwap, FxForward, Future, ExoticInstrument, FxOption, CreditDefaultSwap, InterestRateSwaption, Bond, EquityOption, FixedLeg, FloatingLeg, BespokeCashFlowsLeg, Unknown, TermDeposit, ContractForDifference, EquitySwap, CashPerpetual, CapFloor, CashSettled, CdsIndex, Basket, FundingLeg, FxSwap, ForwardRateAgreement, SimpleInstrument, Repo, Equity, ExchangeTradedOption, ReferenceInstrument, ComplexBond, InflationLinkedBond, InflationSwap, SimpleCashFlowLoan, TotalReturnSwap, InflationLeg")
+    instrument_type: StrictStr = Field(..., alias="instrumentType", description="The available values are: QuotedSecurity, InterestRateSwap, FxForward, Future, ExoticInstrument, FxOption, CreditDefaultSwap, InterestRateSwaption, Bond, EquityOption, FixedLeg, FloatingLeg, BespokeCashFlowsLeg, Unknown, TermDeposit, ContractForDifference, EquitySwap, CashPerpetual, CapFloor, CashSettled, CdsIndex, Basket, FundingLeg, FxSwap, ForwardRateAgreement, SimpleInstrument, Repo, Equity, ExchangeTradedOption, ReferenceInstrument, ComplexBond, InflationLinkedBond, InflationSwap, SimpleCashFlowLoan, TotalReturnSwap, InflationLeg, FundShareClass, FlexibleLoan, UnsettledCash, Cash, MasteredInstrument, LoanFacility, FlexibleDeposit")
     __properties = ["instrumentType"]
 
     @validator('instrument_type')
     def instrument_type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in ('QuotedSecurity', 'InterestRateSwap', 'FxForward', 'Future', 'ExoticInstrument', 'FxOption', 'CreditDefaultSwap', 'InterestRateSwaption', 'Bond', 'EquityOption', 'FixedLeg', 'FloatingLeg', 'BespokeCashFlowsLeg', 'Unknown', 'TermDeposit', 'ContractForDifference', 'EquitySwap', 'CashPerpetual', 'CapFloor', 'CashSettled', 'CdsIndex', 'Basket', 'FundingLeg', 'FxSwap', 'ForwardRateAgreement', 'SimpleInstrument', 'Repo', 'Equity', 'ExchangeTradedOption', 'ReferenceInstrument', 'ComplexBond', 'InflationLinkedBond', 'InflationSwap', 'SimpleCashFlowLoan', 'TotalReturnSwap', 'InflationLeg'):
-            raise ValueError("must be one of enum values ('QuotedSecurity', 'InterestRateSwap', 'FxForward', 'Future', 'ExoticInstrument', 'FxOption', 'CreditDefaultSwap', 'InterestRateSwaption', 'Bond', 'EquityOption', 'FixedLeg', 'FloatingLeg', 'BespokeCashFlowsLeg', 'Unknown', 'TermDeposit', 'ContractForDifference', 'EquitySwap', 'CashPerpetual', 'CapFloor', 'CashSettled', 'CdsIndex', 'Basket', 'FundingLeg', 'FxSwap', 'ForwardRateAgreement', 'SimpleInstrument', 'Repo', 'Equity', 'ExchangeTradedOption', 'ReferenceInstrument', 'ComplexBond', 'InflationLinkedBond', 'InflationSwap', 'SimpleCashFlowLoan', 'TotalReturnSwap', 'InflationLeg')")
+        if value not in ('QuotedSecurity', 'InterestRateSwap', 'FxForward', 'Future', 'ExoticInstrument', 'FxOption', 'CreditDefaultSwap', 'InterestRateSwaption', 'Bond', 'EquityOption', 'FixedLeg', 'FloatingLeg', 'BespokeCashFlowsLeg', 'Unknown', 'TermDeposit', 'ContractForDifference', 'EquitySwap', 'CashPerpetual', 'CapFloor', 'CashSettled', 'CdsIndex', 'Basket', 'FundingLeg', 'FxSwap', 'ForwardRateAgreement', 'SimpleInstrument', 'Repo', 'Equity', 'ExchangeTradedOption', 'ReferenceInstrument', 'ComplexBond', 'InflationLinkedBond', 'InflationSwap', 'SimpleCashFlowLoan', 'TotalReturnSwap', 'InflationLeg', 'FundShareClass', 'FlexibleLoan', 'UnsettledCash', 'Cash', 'MasteredInstrument', 'LoanFacility', 'FlexibleDeposit'):
+            raise ValueError("must be one of enum values ('QuotedSecurity', 'InterestRateSwap', 'FxForward', 'Future', 'ExoticInstrument', 'FxOption', 'CreditDefaultSwap', 'InterestRateSwaption', 'Bond', 'EquityOption', 'FixedLeg', 'FloatingLeg', 'BespokeCashFlowsLeg', 'Unknown', 'TermDeposit', 'ContractForDifference', 'EquitySwap', 'CashPerpetual', 'CapFloor', 'CashSettled', 'CdsIndex', 'Basket', 'FundingLeg', 'FxSwap', 'ForwardRateAgreement', 'SimpleInstrument', 'Repo', 'Equity', 'ExchangeTradedOption', 'ReferenceInstrument', 'ComplexBond', 'InflationLinkedBond', 'InflationSwap', 'SimpleCashFlowLoan', 'TotalReturnSwap', 'InflationLeg', 'FundShareClass', 'FlexibleLoan', 'UnsettledCash', 'Cash', 'MasteredInstrument', 'LoanFacility', 'FlexibleDeposit')")
         return value
 
     class Config:
@@ -49,6 +49,7 @@ class LusidInstrument(BaseModel):
         'Basket': 'Basket',
         'Bond': 'Bond',
         'CapFloor': 'CapFloor',
+        'Cash': 'Cash',
         'CashPerpetual': 'CashPerpetual',
         'CdsIndex': 'CdsIndex',
         'ComplexBond': 'ComplexBond',
@@ -60,8 +61,11 @@ class LusidInstrument(BaseModel):
         'ExchangeTradedOption': 'ExchangeTradedOption',
         'ExoticInstrument': 'ExoticInstrument',
         'FixedLeg': 'FixedLeg',
+        'FlexibleDeposit': 'FlexibleDeposit',
+        'FlexibleLoan': 'FlexibleLoan',
         'FloatingLeg': 'FloatingLeg',
         'ForwardRateAgreement': 'ForwardRateAgreement',
+        'FundShareClass': 'FundShareClass',
         'FundingLeg': 'FundingLeg',
         'Future': 'Future',
         'FxForward': 'FxForward',
@@ -73,6 +77,8 @@ class LusidInstrument(BaseModel):
         'InstrumentLeg': 'InstrumentLeg',
         'InterestRateSwap': 'InterestRateSwap',
         'InterestRateSwaption': 'InterestRateSwaption',
+        'LoanFacility': 'LoanFacility',
+        'MasteredInstrument': 'MasteredInstrument',
         'ReferenceInstrument': 'ReferenceInstrument',
         'Repo': 'Repo',
         'SimpleCashFlowLoan': 'SimpleCashFlowLoan',
@@ -90,6 +96,14 @@ class LusidInstrument(BaseModel):
         else:
             return None
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))
@@ -99,7 +113,7 @@ class LusidInstrument(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Union(Basket, Bond, CapFloor, CashPerpetual, CdsIndex, ComplexBond, ContractForDifference, CreditDefaultSwap, Equity, EquityOption, EquitySwap, ExchangeTradedOption, ExoticInstrument, ForwardRateAgreement, Future, FxForward, FxOption, FxSwap, InflationLeg, InflationLinkedBond, InflationSwap, InstrumentLeg, InterestRateSwap, InterestRateSwaption, ReferenceInstrument, Repo, SimpleCashFlowLoan, SimpleInstrument, TermDeposit, TotalReturnSwap):
+    def from_json(cls, json_str: str) -> Union(Basket, Bond, CapFloor, Cash, CashPerpetual, CdsIndex, ComplexBond, ContractForDifference, CreditDefaultSwap, Equity, EquityOption, EquitySwap, ExchangeTradedOption, ExoticInstrument, FlexibleDeposit, FlexibleLoan, ForwardRateAgreement, FundShareClass, Future, FxForward, FxOption, FxSwap, InflationLeg, InflationLinkedBond, InflationSwap, InstrumentLeg, InterestRateSwap, InterestRateSwaption, LoanFacility, MasteredInstrument, ReferenceInstrument, Repo, SimpleCashFlowLoan, SimpleInstrument, TermDeposit, TotalReturnSwap):
         """Create an instance of LusidInstrument from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -112,7 +126,7 @@ class LusidInstrument(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> Union(Basket, Bond, CapFloor, CashPerpetual, CdsIndex, ComplexBond, ContractForDifference, CreditDefaultSwap, Equity, EquityOption, EquitySwap, ExchangeTradedOption, ExoticInstrument, ForwardRateAgreement, Future, FxForward, FxOption, FxSwap, InflationLeg, InflationLinkedBond, InflationSwap, InstrumentLeg, InterestRateSwap, InterestRateSwaption, ReferenceInstrument, Repo, SimpleCashFlowLoan, SimpleInstrument, TermDeposit, TotalReturnSwap):
+    def from_dict(cls, obj: dict) -> Union(Basket, Bond, CapFloor, Cash, CashPerpetual, CdsIndex, ComplexBond, ContractForDifference, CreditDefaultSwap, Equity, EquityOption, EquitySwap, ExchangeTradedOption, ExoticInstrument, FlexibleDeposit, FlexibleLoan, ForwardRateAgreement, FundShareClass, Future, FxForward, FxOption, FxSwap, InflationLeg, InflationLinkedBond, InflationSwap, InstrumentLeg, InterestRateSwap, InterestRateSwaption, LoanFacility, MasteredInstrument, ReferenceInstrument, Repo, SimpleCashFlowLoan, SimpleInstrument, TermDeposit, TotalReturnSwap):
         """Create an instance of LusidInstrument from a dict"""
         # look up the object type based on discriminator mapping
         object_type = cls.get_discriminator_value(obj)

lusid/models/lusid_problem_details.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, StrictInt, StrictStr, conlist, constr
+from pydantic.v1 import BaseModel, Field, StrictInt, StrictStr, conlist, constr
 
 class LusidProblemDetails(BaseModel):
     """
@@ -40,6 +40,14 @@ class LusidProblemDetails(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/lusid_trade_ticket.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional, Union
-from pydantic import BaseModel, Field, StrictFloat, StrictInt, StrictStr, conlist, constr, validator
+from pydantic.v1 import BaseModel, Field, StrictFloat, StrictInt, StrictStr, conlist, constr, validator
 from lusid.models.currency_and_amount import CurrencyAndAmount
 from lusid.models.lusid_instrument import LusidInstrument
 from lusid.models.model_property import ModelProperty
@@ -41,10 +41,11 @@ class LusidTradeTicket(BaseModel):
     instrument_name: Optional[constr(strict=True, max_length=256, min_length=0)] = Field(None, alias="instrumentName", description="Name of instrument")
     instrument_definition: Optional[LusidInstrument] = Field(None, alias="instrumentDefinition")
     counterparty_agreement_id: Optional[ResourceId] = Field(None, alias="counterpartyAgreementId")
+    counterparty: Optional[constr(strict=True, max_length=256, min_length=0)] = Field(None, description="Counterparty")
     instrument_properties: Optional[conlist(ModelProperty)] = Field(None, alias="instrumentProperties", description="Set of instrument properties (as defined by client/user).")
     transaction_properties: Optional[conlist(ModelProperty)] = Field(None, alias="transactionProperties", description="Set of transaction properties (as defined by client/user).")
     trade_ticket_type: StrictStr = Field(..., alias="tradeTicketType", description="The available values are: LusidTradeTicket, ExternalTradeTicket")
-    __properties = ["transactionId", "transactionType", "source", "transactionDate", "settlementDate", "totalConsideration", "units", "instrumentIdentifiers", "instrumentScope", "instrumentName", "instrumentDefinition", "counterpartyAgreementId", "instrumentProperties", "transactionProperties", "tradeTicketType"]
+    __properties = ["transactionId", "transactionType", "source", "transactionDate", "settlementDate", "totalConsideration", "units", "instrumentIdentifiers", "instrumentScope", "instrumentName", "instrumentDefinition", "counterpartyAgreementId", "counterparty", "instrumentProperties", "transactionProperties", "tradeTicketType"]
 
     @validator('instrument_scope')
     def instrument_scope_validate_regular_expression(cls, value):
@@ -68,6 +69,14 @@ class LusidTradeTicket(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))
@@ -125,6 +134,11 @@ class LusidTradeTicket(BaseModel):
         if self.instrument_name is None and "instrument_name" in self.__fields_set__:
             _dict['instrumentName'] = None
 
+        # set to None if counterparty (nullable) is None
+        # and __fields_set__ contains the field
+        if self.counterparty is None and "counterparty" in self.__fields_set__:
+            _dict['counterparty'] = None
+
         # set to None if instrument_properties (nullable) is None
         # and __fields_set__ contains the field
         if self.instrument_properties is None and "instrument_properties" in self.__fields_set__:
@@ -159,6 +173,7 @@ class LusidTradeTicket(BaseModel):
             "instrument_name": obj.get("instrumentName"),
             "instrument_definition": LusidInstrument.from_dict(obj.get("instrumentDefinition")) if obj.get("instrumentDefinition") is not None else None,
             "counterparty_agreement_id": ResourceId.from_dict(obj.get("counterpartyAgreementId")) if obj.get("counterpartyAgreementId") is not None else None,
+            "counterparty": obj.get("counterparty"),
             "instrument_properties": [ModelProperty.from_dict(_item) for _item in obj.get("instrumentProperties")] if obj.get("instrumentProperties") is not None else None,
             "transaction_properties": [ModelProperty.from_dict(_item) for _item in obj.get("transactionProperties")] if obj.get("transactionProperties") is not None else None,
             "trade_ticket_type": obj.get("tradeTicketType")

lusid/models/lusid_unique_id.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict
-from pydantic import BaseModel, Field, constr
+from pydantic.v1 import BaseModel, Field, constr
 
 class LusidUniqueId(BaseModel):
     """
@@ -34,6 +34,14 @@ class LusidUniqueId(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/lusid_validation_problem_details.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, StrictInt, StrictStr, conlist, constr
+from pydantic.v1 import BaseModel, Field, StrictInt, StrictStr, conlist, constr
 
 class LusidValidationProblemDetails(BaseModel):
     """
@@ -41,6 +41,14 @@ class LusidValidationProblemDetails(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/mapped_string.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic import BaseModel, Field, StrictBool, StrictStr
+from pydantic.v1 import BaseModel, Field, StrictBool, StrictStr
 
 class MappedString(BaseModel):
     """
@@ -36,6 +36,14 @@ class MappedString(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/mapping.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, conlist, constr, validator
+from pydantic.v1 import BaseModel, Field, conlist, constr, validator
 from lusid.models.mapping_rule import MappingRule
 
 class Mapping(BaseModel):
@@ -59,6 +59,14 @@ class Mapping(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/mapping_rule.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional, Union
-from pydantic import BaseModel, Field, StrictBool, StrictFloat, StrictInt, StrictStr, conlist
+from pydantic.v1 import BaseModel, Field, StrictBool, StrictFloat, StrictInt, StrictStr, conlist
 from lusid.models.mapped_string import MappedString
 
 class MappingRule(BaseModel):
@@ -40,6 +40,14 @@ class MappingRule(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/mark_to_market_conventions.py

@@ -0,0 +1,82 @@
+# 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.v1 import BaseModel, Field, constr
+
+class MarkToMarketConventions(BaseModel):
+    """
+    A set of conventions for mark to market. Mark to market is a method   that values financial instruments based on current market prices,   reflecting their current value, rather than historical cost.  # noqa: E501
+    """
+    calendar_code: Optional[constr(strict=True, max_length=50, min_length=0)] = Field(None, alias="calendarCode", description="The calendar to use when generating mark to market cashflows and events.")
+    __properties = ["calendarCode"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    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) -> MarkToMarketConventions:
+        """Create an instance of MarkToMarketConventions 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 calendar_code (nullable) is None
+        # and __fields_set__ contains the field
+        if self.calendar_code is None and "calendar_code" in self.__fields_set__:
+            _dict['calendarCode'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> MarkToMarketConventions:
+        """Create an instance of MarkToMarketConventions from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return MarkToMarketConventions.parse_obj(obj)
+
+        _obj = MarkToMarketConventions.parse_obj({
+            "calendar_code": obj.get("calendarCode")
+        })
+        return _obj

lusid/models/market_context.py

@@ -19,7 +19,8 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, conlist
+from pydantic.v1 import BaseModel, Field, conlist
+from lusid.models.group_of_market_data_key_rules import GroupOfMarketDataKeyRules
 from lusid.models.market_context_suppliers import MarketContextSuppliers
 from lusid.models.market_data_key_rule import MarketDataKeyRule
 from lusid.models.market_data_specific_rule import MarketDataSpecificRule
@@ -33,13 +34,22 @@ class MarketContext(BaseModel):
     suppliers: Optional[MarketContextSuppliers] = None
     options: Optional[MarketOptions] = None
     specific_rules: Optional[conlist(MarketDataSpecificRule)] = Field(None, alias="specificRules", description="Extends market data key rules to be able to catch dependencies depending on where the dependency comes from, as opposed to what the dependency is asking for.  Using two specific rules, one could instruct rates curves requested by bonds to be retrieved from a different scope than rates curves requested by swaps.  WARNING: The use of specific rules impacts performance. Where possible, one should use MarketDataKeyRules only.")
-    __properties = ["marketRules", "suppliers", "options", "specificRules"]
+    grouped_market_rules: Optional[conlist(GroupOfMarketDataKeyRules)] = Field(None, alias="groupedMarketRules", description="The list of groups of rules that will be used in market data resolution.  Rules given within a group will, if the group is being used to resolve data,  all be applied with the results of those individual resolution attempts combined into a single result.  The method for combining results is determined by the operation detailed in the GroupOfMarketDataKeyRules.                Notes:  - When resolving MarketData, MarketRules will be applied first followed by GroupedMarketRules  if data could not be found using only the MarketRules provided.  - GroupedMarketRules can only be used for resolving data from the QuoteStore.                Caution: As every rule in a given group will be applied in resolution if the group is applied,  groups are computationally expensive for market data resolution.  Therefore, heuristically, rule groups should be kept as small as possible.")
+    __properties = ["marketRules", "suppliers", "options", "specificRules", "groupedMarketRules"]
 
     class Config:
         """Pydantic configuration"""
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))
@@ -79,6 +89,13 @@ class MarketContext(BaseModel):
                 if _item:
                     _items.append(_item.to_dict())
             _dict['specificRules'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in grouped_market_rules (list)
+        _items = []
+        if self.grouped_market_rules:
+            for _item in self.grouped_market_rules:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['groupedMarketRules'] = _items
         # set to None if market_rules (nullable) is None
         # and __fields_set__ contains the field
         if self.market_rules is None and "market_rules" in self.__fields_set__:
@@ -94,6 +111,11 @@ class MarketContext(BaseModel):
         if self.specific_rules is None and "specific_rules" in self.__fields_set__:
             _dict['specificRules'] = None
 
+        # set to None if grouped_market_rules (nullable) is None
+        # and __fields_set__ contains the field
+        if self.grouped_market_rules is None and "grouped_market_rules" in self.__fields_set__:
+            _dict['groupedMarketRules'] = None
+
         return _dict
 
     @classmethod
@@ -109,6 +131,7 @@ class MarketContext(BaseModel):
             "market_rules": [MarketDataKeyRule.from_dict(_item) for _item in obj.get("marketRules")] if obj.get("marketRules") is not None else None,
             "suppliers": MarketContextSuppliers.from_dict(obj.get("suppliers")) if obj.get("suppliers") is not None else None,
             "options": MarketOptions.from_dict(obj.get("options")) if obj.get("options") is not None else None,
-            "specific_rules": [MarketDataSpecificRule.from_dict(_item) for _item in obj.get("specificRules")] if obj.get("specificRules") is not None else None
+            "specific_rules": [MarketDataSpecificRule.from_dict(_item) for _item in obj.get("specificRules")] if obj.get("specificRules") is not None else None,
+            "grouped_market_rules": [GroupOfMarketDataKeyRules.from_dict(_item) for _item in obj.get("groupedMarketRules")] if obj.get("groupedMarketRules") is not None else None
         })
         return _obj

lusid/models/market_context_suppliers.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic import BaseModel, Field, StrictStr
+from pydantic.v1 import BaseModel, Field, StrictStr
 
 class MarketContextSuppliers(BaseModel):
     """
@@ -37,6 +37,14 @@ class MarketContextSuppliers(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/market_data_key_rule.py

@@ -19,7 +19,7 @@ import json
 
 from datetime import datetime
 from typing import Any, Dict, Optional
-from pydantic import BaseModel, Field, StrictStr, constr, validator
+from pydantic.v1 import BaseModel, Field, StrictBool, StrictStr, constr, validator
 
 class MarketDataKeyRule(BaseModel):
     """
@@ -28,14 +28,15 @@ class MarketDataKeyRule(BaseModel):
     key: constr(strict=True, max_length=128, min_length=0) = Field(..., description="A dot-separated string that defines a pattern for matching market data dependencies.  The form of the string depends on the type of the dependency; see below for basic types and the Knowledge Base for further info.  Quote lookup: \"Quote.{CodeType}.*\" e.g. \"Quote.RIC.*\" refers to 'any RIC quote'  Fx rates: \"Fx.CurrencyPair.*\", which refers to 'any FX rate'  Discounting curves: \"Rates.{Currency}.{Currency}OIS e.g. \"Rates.USD.USDOIS\" refers to the OIS USD discounting curve                For non-fx and non-quote rules, trailing parameters can be replaced by the wildcard character '*'.  e.g. \"Rates.*.*\" matches any dependency on a discounting curve.")
     supplier: constr(strict=True, max_length=32, min_length=0) = Field(..., description="The market data supplier (where the data comes from)")
     data_scope: constr(strict=True, max_length=256, min_length=1) = Field(..., alias="dataScope", description="The scope in which the data should be found when using this rule.")
-    quote_type: StrictStr = Field(..., alias="quoteType", description="The available values are: Price, Spread, Rate, LogNormalVol, NormalVol, ParSpread, IsdaSpread, Upfront, Index, Ratio, Delta, PoolFactor, InflationAssumption, DirtyPrice")
+    quote_type: StrictStr = Field(..., alias="quoteType", description="The available values are: Price, Spread, Rate, LogNormalVol, NormalVol, ParSpread, IsdaSpread, Upfront, Index, Ratio, Delta, PoolFactor, InflationAssumption, DirtyPrice, PrincipalWriteOff, InterestDeferred, InterestShortfall")
     field: Optional[constr(strict=True, max_length=32, min_length=0)] = Field(None, description="The conceptual qualification for the field, typically 'bid', 'mid' (default), or 'ask', but can also be 'open', 'close', etc.  When resolving quotes from LUSID's database, only quotes whose Field is identical to the Field specified here  will be accepted as market data.  When resolving data from an external supplier, the Field must be one of a defined set for the given supplier.                Note: Applies to the retrieval of quotes only. Has no impact on the resolution of complex market data.")
     quote_interval: Optional[constr(strict=True, max_length=16, min_length=0)] = Field(None, alias="quoteInterval", description="Shorthand for the time interval used to select market data. This must be a dot-separated string              nominating a start and end date, for example '5D.0D' to look back 5 days from today (0 days ago). The syntax              is <i>int</i><i>char</i>.<i>int</i><i>char</i>, where <i>char</i> is one of              D(ay), Bd(business day), W(eek), M(onth) or Y(ear).              Business days are calculated using the calendars specified on the Valuation Request.              If no calendar is provided in the request, then it will default to only skipping weekends.              For example, if the valuation date is a Monday, then a quote interval of \"1Bd\" would behave as \"3D\",              looking back to the Friday. Data with effectiveAt on the weekend will still be found in that window.")
-    as_at: Optional[datetime] = Field(None, alias="asAt", description="The AsAt predicate specification.")
+    as_at: Optional[datetime] = Field(None, alias="asAt", description="Deprecated field which no longer has any effect on market data resolution.")
     price_source: Optional[constr(strict=True, max_length=256, min_length=0)] = Field(None, alias="priceSource", description="The source of the quote. For a given provider/supplier of market data there may be an additional qualifier, e.g. the exchange or bank that provided the quote")
     mask: Optional[constr(strict=True, max_length=256, min_length=0)] = Field(None, description="Allows for partial or complete override of the market asset resolved for a dependency  Either a named override or a dot separated string (A.B.C.D.*).  e.g. for Rates curve 'EUR.*' will replace the resolve MarketAsset 'GBP/12M', 'GBP/3M' with the EUR equivalent, if there  are no wildcards in the mask, the mask is taken as the MarketAsset for any dependency matching the rule.")
     source_system: Optional[constr(strict=True, max_length=256, min_length=0)] = Field(None, alias="sourceSystem", description="If set, this parameter will seek an external source of market data.  Optional and, if omitted, will default to \"Lusid\".  This means that data will be retrieved from the LUSID Quote Store and LUSID Complex Market Data Store.                This can be set to \"MarketDataOverrides\" if Supplier is set to \"Client\".")
-    __properties = ["key", "supplier", "dataScope", "quoteType", "field", "quoteInterval", "asAt", "priceSource", "mask", "sourceSystem"]
+    fall_through_on_access_denied: Optional[StrictBool] = Field(None, alias="fallThroughOnAccessDenied", description="When a user attempts to use a rule to access data to which they are not entitled,  the rule will fail to resolve any market data.  By default, such an access denied failure will stop any further attempts to resolve market data.  This is so that differently entitled users always receive the same market data from market data resolution,  if they have sufficient entitlements to retrieve the required data.  If set to true, then an access denied failure will not stop further market data resolution,  and resolution will continue with the next specified MarketDataKeyRule.  Optional, and defaults to false.")
+    __properties = ["key", "supplier", "dataScope", "quoteType", "field", "quoteInterval", "asAt", "priceSource", "mask", "sourceSystem", "fallThroughOnAccessDenied"]
 
     @validator('data_scope')
     def data_scope_validate_regular_expression(cls, value):
@@ -47,8 +48,8 @@ class MarketDataKeyRule(BaseModel):
     @validator('quote_type')
     def quote_type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in ('Price', 'Spread', 'Rate', 'LogNormalVol', 'NormalVol', 'ParSpread', 'IsdaSpread', 'Upfront', 'Index', 'Ratio', 'Delta', 'PoolFactor', 'InflationAssumption', 'DirtyPrice'):
-            raise ValueError("must be one of enum values ('Price', 'Spread', 'Rate', 'LogNormalVol', 'NormalVol', 'ParSpread', 'IsdaSpread', 'Upfront', 'Index', 'Ratio', 'Delta', 'PoolFactor', 'InflationAssumption', 'DirtyPrice')")
+        if value not in ('Price', 'Spread', 'Rate', 'LogNormalVol', 'NormalVol', 'ParSpread', 'IsdaSpread', 'Upfront', 'Index', 'Ratio', 'Delta', 'PoolFactor', 'InflationAssumption', 'DirtyPrice', 'PrincipalWriteOff', 'InterestDeferred', 'InterestShortfall'):
+            raise ValueError("must be one of enum values ('Price', 'Spread', 'Rate', 'LogNormalVol', 'NormalVol', 'ParSpread', 'IsdaSpread', 'Upfront', 'Index', 'Ratio', 'Delta', 'PoolFactor', 'InflationAssumption', 'DirtyPrice', 'PrincipalWriteOff', 'InterestDeferred', 'InterestShortfall')")
         return value
 
     class Config:
@@ -56,6 +57,14 @@ class MarketDataKeyRule(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))
@@ -126,6 +135,7 @@ class MarketDataKeyRule(BaseModel):
             "as_at": obj.get("asAt"),
             "price_source": obj.get("priceSource"),
             "mask": obj.get("mask"),
-            "source_system": obj.get("sourceSystem")
+            "source_system": obj.get("sourceSystem"),
+            "fall_through_on_access_denied": obj.get("fallThroughOnAccessDenied")
         })
         return _obj

lusid/models/market_data_options.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Union
-from pydantic import BaseModel, Field, StrictStr, validator
+from pydantic.v1 import BaseModel, Field, StrictStr, validator
 import lusid.models
 
 class MarketDataOptions(BaseModel):
@@ -58,6 +58,14 @@ class MarketDataOptions(BaseModel):
         else:
             return None
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/market_data_overrides.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, conlist
+from pydantic.v1 import BaseModel, Field, conlist
 from lusid.models.economic_dependency_with_complex_market_data import EconomicDependencyWithComplexMarketData
 from lusid.models.economic_dependency_with_quote import EconomicDependencyWithQuote
 
@@ -36,6 +36,14 @@ class MarketDataOverrides(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))