lusid-sdk 2.1.929__tar.gz → 2.1.931__tar.gz

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lusid-sdk
-Version: 2.1.929
+Version: 2.1.931
 Summary: LUSID API
 Home-page: https://github.com/finbourne/lusid-sdk-python
 License: MIT
@@ -1522,6 +1522,7 @@ Class | Method | HTTP request | Description
  - [PostingModuleRulesUpdatedResponse](docs/PostingModuleRulesUpdatedResponse.md)
  - [PreTradeConfiguration](docs/PreTradeConfiguration.md)
  - [Premium](docs/Premium.md)
+ - [PreviousFundCalendarEntry](docs/PreviousFundCalendarEntry.md)
  - [PreviousFundValuationPointData](docs/PreviousFundValuationPointData.md)
  - [PreviousNAV](docs/PreviousNAV.md)
  - [PreviousShareClassBreakdown](docs/PreviousShareClassBreakdown.md)

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/README.md

@@ -1495,6 +1495,7 @@ Class | Method | HTTP request | Description
  - [PostingModuleRulesUpdatedResponse](docs/PostingModuleRulesUpdatedResponse.md)
  - [PreTradeConfiguration](docs/PreTradeConfiguration.md)
  - [Premium](docs/Premium.md)
+ - [PreviousFundCalendarEntry](docs/PreviousFundCalendarEntry.md)
  - [PreviousFundValuationPointData](docs/PreviousFundValuationPointData.md)
  - [PreviousNAV](docs/PreviousNAV.md)
  - [PreviousShareClassBreakdown](docs/PreviousShareClassBreakdown.md)

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/lusid/__init__.py

@@ -938,6 +938,7 @@ from lusid.models.posting_module_rule import PostingModuleRule
 from lusid.models.posting_module_rules_updated_response import PostingModuleRulesUpdatedResponse
 from lusid.models.pre_trade_configuration import PreTradeConfiguration
 from lusid.models.premium import Premium
+from lusid.models.previous_fund_calendar_entry import PreviousFundCalendarEntry
 from lusid.models.previous_fund_valuation_point_data import PreviousFundValuationPointData
 from lusid.models.previous_nav import PreviousNAV
 from lusid.models.previous_share_class_breakdown import PreviousShareClassBreakdown
@@ -2317,6 +2318,7 @@ __all__ = [
     "PostingModuleRulesUpdatedResponse",
     "PreTradeConfiguration",
     "Premium",
+    "PreviousFundCalendarEntry",
     "PreviousFundValuationPointData",
     "PreviousNAV",
     "PreviousShareClassBreakdown",

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/lusid/api/transaction_portfolios_api.py

@@ -6943,15 +6943,15 @@ class TransactionPortfoliosApi:
 
 
     @overload
-    async def patch_portfolio_details(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the              scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal entities in the request, but will not be used for any perpetual entities.")] = None, **kwargs) -> PortfolioDetails:  # noqa: E501
+    async def patch_portfolio_details(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the              scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal fields (eg: SettlementConfiguration) in the request (but will not be used for any              perpetual fields). When patching a bitemporal field, the field will be updated from the              effectiveAt onwards and until the end of effective time.")] = None, **kwargs) -> PortfolioDetails:  # noqa: E501
         ...
 
     @overload
-    def patch_portfolio_details(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the              scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal entities in the request, but will not be used for any perpetual entities.")] = None, async_req: Optional[bool]=True, **kwargs) -> PortfolioDetails:  # noqa: E501
+    def patch_portfolio_details(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the              scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal fields (eg: SettlementConfiguration) in the request (but will not be used for any              perpetual fields). When patching a bitemporal field, the field will be updated from the              effectiveAt onwards and until the end of effective time.")] = None, async_req: Optional[bool]=True, **kwargs) -> PortfolioDetails:  # noqa: E501
         ...
 
     @validate_arguments
-    def patch_portfolio_details(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the              scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal entities in the request, but will not be used for any perpetual entities.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PortfolioDetails, Awaitable[PortfolioDetails]]:  # noqa: E501
+    def patch_portfolio_details(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the              scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal fields (eg: SettlementConfiguration) in the request (but will not be used for any              perpetual fields). When patching a bitemporal field, the field will be updated from the              effectiveAt onwards and until the end of effective time.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PortfolioDetails, Awaitable[PortfolioDetails]]:  # noqa: E501
         """PatchPortfolioDetails: Patch portfolio details  # noqa: E501
 
         Create or update certain details for a particular transaction portfolio.  Note that not all elements of a transaction portfolio definition are  modifiable once it has been created due to the potential implications for data already stored.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: BaseCurrency, AccountingMethod, SubHoldingKeys, AmortisationMethod, TransactionTypeScope, CashGainLossCalculationDate, InstrumentEventConfiguration, AmortisationRuleSetId, TaxRuleSetScope, SettlementConfiguration.  # noqa: E501
@@ -6967,7 +6967,7 @@ class TransactionPortfoliosApi:
         :type code: str
         :param operation: The patch document. (required)
         :type operation: List[Operation]
-        :param effective_at: The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal entities in the request, but will not be used for any perpetual entities.
+        :param effective_at: The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal fields (eg: SettlementConfiguration) in the request (but will not be used for any              perpetual fields). When patching a bitemporal field, the field will be updated from the              effectiveAt onwards and until the end of effective time.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -6988,7 +6988,7 @@ class TransactionPortfoliosApi:
         return self.patch_portfolio_details_with_http_info(scope, code, operation, effective_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def patch_portfolio_details_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the              scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal entities in the request, but will not be used for any perpetual entities.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def patch_portfolio_details_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the              scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal fields (eg: SettlementConfiguration) in the request (but will not be used for any              perpetual fields). When patching a bitemporal field, the field will be updated from the              effectiveAt onwards and until the end of effective time.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """PatchPortfolioDetails: Patch portfolio details  # noqa: E501
 
         Create or update certain details for a particular transaction portfolio.  Note that not all elements of a transaction portfolio definition are  modifiable once it has been created due to the potential implications for data already stored.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: BaseCurrency, AccountingMethod, SubHoldingKeys, AmortisationMethod, TransactionTypeScope, CashGainLossCalculationDate, InstrumentEventConfiguration, AmortisationRuleSetId, TaxRuleSetScope, SettlementConfiguration.  # noqa: E501
@@ -7004,7 +7004,7 @@ class TransactionPortfoliosApi:
         :type code: str
         :param operation: The patch document. (required)
         :type operation: List[Operation]
-        :param effective_at: The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal entities in the request, but will not be used for any perpetual entities.
+        :param effective_at: The effective datetime or cut label at which the updated or inserted details should become valid.              Defaults to the current LUSID system datetime if not specified.              Note that this will affect all bitemporal fields (eg: SettlementConfiguration) in the request (but will not be used for any              perpetual fields). When patching a bitemporal field, the field will be updated from the              effectiveAt onwards and until the end of effective time.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/lusid/configuration.py

@@ -445,7 +445,7 @@ class Configuration:
         return "Python SDK Debug Report:\n"\
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
-               "Version of the API: 0.11.8221\n"\
+               "Version of the API: 0.11.8230\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/lusid/models/__init__.py

@@ -847,6 +847,7 @@ from lusid.models.posting_module_rule import PostingModuleRule
 from lusid.models.posting_module_rules_updated_response import PostingModuleRulesUpdatedResponse
 from lusid.models.pre_trade_configuration import PreTradeConfiguration
 from lusid.models.premium import Premium
+from lusid.models.previous_fund_calendar_entry import PreviousFundCalendarEntry
 from lusid.models.previous_fund_valuation_point_data import PreviousFundValuationPointData
 from lusid.models.previous_nav import PreviousNAV
 from lusid.models.previous_share_class_breakdown import PreviousShareClassBreakdown
@@ -2136,6 +2137,7 @@ __all__ = [
     "PostingModuleRulesUpdatedResponse",
     "PreTradeConfiguration",
     "Premium",
+    "PreviousFundCalendarEntry",
     "PreviousFundValuationPointData",
     "PreviousNAV",
     "PreviousShareClassBreakdown",

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/lusid/models/account_holder.py

@@ -21,7 +21,6 @@ import json
 from typing import Any, Dict, Optional
 from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr 
 from lusid.models.investor_record import InvestorRecord
-from lusid.models.model_property import ModelProperty
 
 class AccountHolder(BaseModel):
     """
@@ -29,7 +28,7 @@ class AccountHolder(BaseModel):
     """
     key:  Optional[StrictStr] = Field(None,alias="key", description="A client-defined key used to identify the Account Holder, unique within the Investment Account") 
     scope:  Optional[StrictStr] = Field(None,alias="scope", description="The scope in which the Investor Record lies.") 
-    identifiers: Optional[Dict[str, ModelProperty]] = Field(None, description="Single Account Holder identifier that should target the desired Investor Record.")
+    identifiers: Optional[Dict[str, StrictStr]] = Field(None, description="Single Account Holder identifier that should target the desired Investor Record.")
     entity_unique_id:  Optional[StrictStr] = Field(None,alias="entityUniqueId", description="The unique InvestorRecord entity identifier") 
     investor_record: Optional[InvestorRecord] = Field(None, alias="investorRecord")
     __properties = ["key", "scope", "identifiers", "entityUniqueId", "investorRecord"]
@@ -66,13 +65,6 @@ class AccountHolder(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of each value in identifiers (dict)
-        _field_dict = {}
-        if self.identifiers:
-            for _key in self.identifiers:
-                if self.identifiers[_key]:
-                    _field_dict[_key] = self.identifiers[_key].to_dict()
-            _dict['identifiers'] = _field_dict
         # override the default output from pydantic by calling `to_dict()` of investor_record
         if self.investor_record:
             _dict['investorRecord'] = self.investor_record.to_dict()
@@ -110,12 +102,7 @@ class AccountHolder(BaseModel):
         _obj = AccountHolder.parse_obj({
             "key": obj.get("key"),
             "scope": obj.get("scope"),
-            "identifiers": dict(
-                (_k, ModelProperty.from_dict(_v))
-                for _k, _v in obj.get("identifiers").items()
-            )
-            if obj.get("identifiers") is not None
-            else None,
+            "identifiers": obj.get("identifiers"),
             "entity_unique_id": obj.get("entityUniqueId"),
             "investor_record": InvestorRecord.from_dict(obj.get("investorRecord")) if obj.get("investorRecord") is not None else None
         })

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/lusid/models/account_holder_identifier.py

@@ -19,8 +19,7 @@ import json
 
 
 from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, constr, validator 
-from lusid.models.model_property import ModelProperty
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, constr, validator 
 
 class AccountHolderIdentifier(BaseModel):
     """
@@ -28,7 +27,7 @@ class AccountHolderIdentifier(BaseModel):
     """
     key:  StrictStr = Field(...,alias="key", description="A client-defined key used to identify the Account Holder, unique within the Investment Account") 
     scope:  StrictStr = Field(...,alias="scope", description="The scope in which the Investor Record lies.") 
-    identifiers: Dict[str, ModelProperty] = Field(..., description="Single Account Holder identifier that should target the desired Investor Record.")
+    identifiers: Dict[str, StrictStr] = Field(..., description="Single Account Holder identifier that should target the desired Investor Record.")
     __properties = ["key", "scope", "identifiers"]
 
     class Config:
@@ -63,13 +62,6 @@ class AccountHolderIdentifier(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of each value in identifiers (dict)
-        _field_dict = {}
-        if self.identifiers:
-            for _key in self.identifiers:
-                if self.identifiers[_key]:
-                    _field_dict[_key] = self.identifiers[_key].to_dict()
-            _dict['identifiers'] = _field_dict
         return _dict
 
     @classmethod
@@ -84,11 +76,6 @@ class AccountHolderIdentifier(BaseModel):
         _obj = AccountHolderIdentifier.parse_obj({
             "key": obj.get("key"),
             "scope": obj.get("scope"),
-            "identifiers": dict(
-                (_k, ModelProperty.from_dict(_v))
-                for _k, _v in obj.get("identifiers").items()
-            )
-            if obj.get("identifiers") is not None
-            else None
+            "identifiers": obj.get("identifiers")
         })
         return _obj

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/lusid/models/fund_calendar_entry.py

@@ -21,6 +21,7 @@ from datetime import datetime
 from typing import Any, Dict, Optional
 from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool, StrictStr, constr, validator 
 from lusid.models.model_property import ModelProperty
+from lusid.models.previous_fund_calendar_entry import PreviousFundCalendarEntry
 from lusid.models.version import Version
 
 class FundCalendarEntry(BaseModel):
@@ -31,6 +32,7 @@ class FundCalendarEntry(BaseModel):
     display_name:  StrictStr = Field(...,alias="displayName", description="The name of the Fund Calendar entry.") 
     description:  Optional[StrictStr] = Field(None,alias="description", description="A description for the Fund Calendar entry.") 
     nav_type_code:  StrictStr = Field(...,alias="navTypeCode", description="The navTypeCode of the Fund Calendar Entry. This is the code of the NAV type that this Calendar Entry is associated with.") 
+    previous_entry: Optional[PreviousFundCalendarEntry] = Field(None, alias="previousEntry")
     effective_at: Optional[datetime] = Field(None, alias="effectiveAt", description="The effective at of the Calendar Entry.")
     as_at: datetime = Field(..., alias="asAt", description="The asAt datetime for the Calendar Entry.")
     entry_type:  StrictStr = Field(...,alias="entryType", description="The type of the Fund Calendar Entry. Only 'ValuationPoint' currently supported. The available values are: ValuationPointFundCalendarEntry, BookmarkFundCalendarEntry") 
@@ -39,7 +41,7 @@ class FundCalendarEntry(BaseModel):
     properties: Optional[Dict[str, ModelProperty]] = Field(None, description="The properties for the Calendar Entry. These will be from the 'ClosedPeriod' domain.")
     version: Version = Field(...)
     href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested asAt datetime.") 
-    __properties = ["code", "displayName", "description", "navTypeCode", "effectiveAt", "asAt", "entryType", "status", "applyClearDown", "properties", "version", "href"]
+    __properties = ["code", "displayName", "description", "navTypeCode", "previousEntry", "effectiveAt", "asAt", "entryType", "status", "applyClearDown", "properties", "version", "href"]
 
     @validator('entry_type')
     def entry_type_validate_enum(cls, value):
@@ -132,6 +134,9 @@ class FundCalendarEntry(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of previous_entry
+        if self.previous_entry:
+            _dict['previousEntry'] = self.previous_entry.to_dict()
         # override the default output from pydantic by calling `to_dict()` of each value in properties (dict)
         _field_dict = {}
         if self.properties:
@@ -178,6 +183,7 @@ class FundCalendarEntry(BaseModel):
             "display_name": obj.get("displayName"),
             "description": obj.get("description"),
             "nav_type_code": obj.get("navTypeCode"),
+            "previous_entry": PreviousFundCalendarEntry.from_dict(obj.get("previousEntry")) if obj.get("previousEntry") is not None else None,
             "effective_at": obj.get("effectiveAt"),
             "as_at": obj.get("asAt"),
             "entry_type": obj.get("entryType"),

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/lusid/models/investment_portfolio.py

@@ -28,10 +28,10 @@ class InvestmentPortfolio(BaseModel):
     """
     key:  Optional[StrictStr] = Field(None,alias="key", description="A client-defined key used to identify the Investment Portfolio, unique within the Investment Account") 
     scope:  Optional[StrictStr] = Field(None,alias="scope", description="The scope of the Investment Portfolio") 
-    code:  Optional[StrictStr] = Field(None,alias="code", description="The code of the Investment Portfolio") 
+    identifiers: Optional[Dict[str, StrictStr]] = Field(None, description="The code identifier of the Investment Portfolio")
     entity_unique_id:  Optional[StrictStr] = Field(None,alias="entityUniqueId", description="The unique Portfolio entity identifier") 
     portfolio: Optional[Portfolio] = None
-    __properties = ["key", "scope", "code", "entityUniqueId", "portfolio"]
+    __properties = ["key", "scope", "identifiers", "entityUniqueId", "portfolio"]
 
     class Config:
         """Pydantic configuration"""
@@ -78,10 +78,10 @@ class InvestmentPortfolio(BaseModel):
         if self.scope is None and "scope" in self.__fields_set__:
             _dict['scope'] = None
 
-        # set to None if code (nullable) is None
+        # set to None if identifiers (nullable) is None
         # and __fields_set__ contains the field
-        if self.code is None and "code" in self.__fields_set__:
-            _dict['code'] = None
+        if self.identifiers is None and "identifiers" in self.__fields_set__:
+            _dict['identifiers'] = None
 
         # set to None if entity_unique_id (nullable) is None
         # and __fields_set__ contains the field
@@ -102,7 +102,7 @@ class InvestmentPortfolio(BaseModel):
         _obj = InvestmentPortfolio.parse_obj({
             "key": obj.get("key"),
             "scope": obj.get("scope"),
-            "code": obj.get("code"),
+            "identifiers": obj.get("identifiers"),
             "entity_unique_id": obj.get("entityUniqueId"),
             "portfolio": Portfolio.from_dict(obj.get("portfolio")) if obj.get("portfolio") is not None else None
         })

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/lusid/models/investment_portfolio_identifier.py

@@ -19,16 +19,16 @@ import json
 
 
 from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, constr, validator 
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, constr, validator 
 
 class InvestmentPortfolioIdentifier(BaseModel):
     """
     InvestmentPortfolioIdentifier
     """
     key:  StrictStr = Field(...,alias="key", description="A client-defined key used to identify the Investment Portfolio, unique within the Investment Account") 
-    portfolio_scope:  StrictStr = Field(...,alias="portfolioScope", description="The scope of the Investment Portfolio.") 
-    portfolio_code:  StrictStr = Field(...,alias="portfolioCode", description="The code of the Investment Portfolio.") 
-    __properties = ["key", "portfolioScope", "portfolioCode"]
+    scope:  StrictStr = Field(...,alias="scope", description="The scope of the Investment Portfolio.") 
+    identifiers: Dict[str, StrictStr] = Field(..., description="The code identifier of the Investment Portfolio.")
+    __properties = ["key", "scope", "identifiers"]
 
     class Config:
         """Pydantic configuration"""
@@ -75,7 +75,7 @@ class InvestmentPortfolioIdentifier(BaseModel):
 
         _obj = InvestmentPortfolioIdentifier.parse_obj({
             "key": obj.get("key"),
-            "portfolio_scope": obj.get("portfolioScope"),
-            "portfolio_code": obj.get("portfolioCode")
+            "scope": obj.get("scope"),
+            "identifiers": obj.get("identifiers")
         })
         return _obj

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/lusid/models/investor.py

@@ -21,7 +21,6 @@ import json
 from typing import Any, Dict, Optional
 from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr 
 from lusid.models.legal_entity import LegalEntity
-from lusid.models.model_property import ModelProperty
 from lusid.models.person import Person
 
 class Investor(BaseModel):
@@ -29,7 +28,7 @@ class Investor(BaseModel):
     Representation of an Investor on the LUSID API  # noqa: E501
     """
     investor_type:  Optional[StrictStr] = Field(None,alias="investorType", description="The type of the Investor") 
-    identifiers: Optional[Dict[str, ModelProperty]] = Field(None, description="The identifiers of the Investor")
+    identifiers: Optional[Dict[str, StrictStr]] = Field(None, description="The identifiers of the Investor")
     entity_unique_id:  Optional[StrictStr] = Field(None,alias="entityUniqueId", description="The unique Investor entity identifier") 
     person: Optional[Person] = None
     legal_entity: Optional[LegalEntity] = Field(None, alias="legalEntity")
@@ -67,13 +66,6 @@ class Investor(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of each value in identifiers (dict)
-        _field_dict = {}
-        if self.identifiers:
-            for _key in self.identifiers:
-                if self.identifiers[_key]:
-                    _field_dict[_key] = self.identifiers[_key].to_dict()
-            _dict['identifiers'] = _field_dict
         # override the default output from pydantic by calling `to_dict()` of person
         if self.person:
             _dict['person'] = self.person.to_dict()
@@ -108,12 +100,7 @@ class Investor(BaseModel):
 
         _obj = Investor.parse_obj({
             "investor_type": obj.get("investorType"),
-            "identifiers": dict(
-                (_k, ModelProperty.from_dict(_v))
-                for _k, _v in obj.get("identifiers").items()
-            )
-            if obj.get("identifiers") is not None
-            else None,
+            "identifiers": obj.get("identifiers"),
             "entity_unique_id": obj.get("entityUniqueId"),
             "person": Person.from_dict(obj.get("person")) if obj.get("person") is not None else None,
             "legal_entity": LegalEntity.from_dict(obj.get("legalEntity")) if obj.get("legalEntity") is not None else None

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/lusid/models/investor_identifier.py

@@ -19,15 +19,14 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, constr 
-from lusid.models.model_property import ModelProperty
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, constr 
 
 class InvestorIdentifier(BaseModel):
     """
     Identification of an Investor on the LUSID API.  # noqa: E501
     """
     investor_type:  StrictStr = Field(...,alias="investorType", description="The type of the investor of the Investor Record. Can be either a Person or a LegalEntity") 
-    identifiers: Optional[Dict[str, ModelProperty]] = Field(None, description="Single identifier that should target the desired person or legal entity")
+    identifiers: Optional[Dict[str, StrictStr]] = Field(None, description="Single identifier that should target the desired person or legal entity")
     __properties = ["investorType", "identifiers"]
 
     class Config:
@@ -62,13 +61,6 @@ class InvestorIdentifier(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of each value in identifiers (dict)
-        _field_dict = {}
-        if self.identifiers:
-            for _key in self.identifiers:
-                if self.identifiers[_key]:
-                    _field_dict[_key] = self.identifiers[_key].to_dict()
-            _dict['identifiers'] = _field_dict
         # set to None if identifiers (nullable) is None
         # and __fields_set__ contains the field
         if self.identifiers is None and "identifiers" in self.__fields_set__:
@@ -87,11 +79,6 @@ class InvestorIdentifier(BaseModel):
 
         _obj = InvestorIdentifier.parse_obj({
             "investor_type": obj.get("investorType"),
-            "identifiers": dict(
-                (_k, ModelProperty.from_dict(_v))
-                for _k, _v in obj.get("identifiers").items()
-            )
-            if obj.get("identifiers") is not None
-            else None
+            "identifiers": obj.get("identifiers")
         })
         return _obj

lusid_sdk-2.1.931/lusid/models/previous_fund_calendar_entry.py

@@ -0,0 +1,90 @@
+# 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, Optional
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, constr 
+
+class PreviousFundCalendarEntry(BaseModel):
+    """
+    PreviousFundCalendarEntry
+    """
+    code:  StrictStr = Field(...,alias="code", description="The unique Code of the Calendar Entry. The Calendar Entry, together with the Fund Scope and Code, uniquely identifies a Fund Calendar Entry") 
+    display_name:  StrictStr = Field(...,alias="displayName", description="The name of the Fund Calendar entry.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A description for the Fund Calendar entry.") 
+    effective_at: Optional[datetime] = Field(None, alias="effectiveAt", description="The effective at of the Calendar Entry.")
+    as_at: datetime = Field(..., alias="asAt", description="The asAt datetime for the Calendar Entry.")
+    __properties = ["code", "displayName", "description", "effectiveAt", "asAt"]
+
+    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) -> PreviousFundCalendarEntry:
+        """Create an instance of PreviousFundCalendarEntry 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 description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> PreviousFundCalendarEntry:
+        """Create an instance of PreviousFundCalendarEntry from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return PreviousFundCalendarEntry.parse_obj(obj)
+
+        _obj = PreviousFundCalendarEntry.parse_obj({
+            "code": obj.get("code"),
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "effective_at": obj.get("effectiveAt"),
+            "as_at": obj.get("asAt")
+        })
+        return _obj

{lusid_sdk-2.1.929 → lusid_sdk-2.1.931}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "lusid-sdk"
-version = "2.1.929"
+version = "2.1.931"
 description = "LUSID API"
 authors = ["FINBOURNE Technology <info@finbourne.com>"]
 license = "MIT"