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

lusid/models/versioned_resource_list_of_portfolio_holding.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, StrictStr, conlist
+from pydantic.v1 import BaseModel, Field, StrictStr, conlist
 from lusid.models.link import Link
 from lusid.models.portfolio_holding import PortfolioHolding
 from lusid.models.version import Version
@@ -41,6 +41,14 @@ class VersionedResourceListOfPortfolioHolding(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/versioned_resource_list_of_transaction.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, StrictStr, conlist
+from pydantic.v1 import BaseModel, Field, StrictStr, conlist
 from lusid.models.link import Link
 from lusid.models.transaction import Transaction
 from lusid.models.version import Version
@@ -41,6 +41,14 @@ class VersionedResourceListOfTransaction(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/versioned_resource_list_of_trial_balance.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, StrictStr, conlist
+from pydantic.v1 import BaseModel, Field, StrictStr, conlist
 from lusid.models.link import Link
 from lusid.models.trial_balance import TrialBalance
 from lusid.models.version import Version
@@ -41,6 +41,14 @@ class VersionedResourceListOfTrialBalance(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/versioned_resource_list_with_warnings_of_portfolio_holding.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, StrictStr, conlist
+from pydantic.v1 import BaseModel, Field, StrictStr, conlist
 from lusid.models.link import Link
 from lusid.models.portfolio_holding import PortfolioHolding
 from lusid.models.version import Version
@@ -43,6 +43,14 @@ class VersionedResourceListWithWarningsOfPortfolioHolding(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/virtual_document.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.structured_result_data_id import StructuredResultDataId
 from lusid.models.virtual_document_row import VirtualDocumentRow
 
@@ -36,6 +36,14 @@ class VirtualDocument(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/virtual_document_row.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
 from lusid.models.grouped_result_of_address_key import GroupedResultOfAddressKey
 
 class VirtualDocumentRow(BaseModel):
@@ -35,6 +35,14 @@ class VirtualDocumentRow(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/virtual_row.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
 from lusid.models.result_value import ResultValue
 
 class VirtualRow(BaseModel):
@@ -35,6 +35,14 @@ class VirtualRow(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/warning.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict
-from pydantic import BaseModel, Field, StrictStr
+from pydantic.v1 import BaseModel, Field, StrictStr
 
 class Warning(BaseModel):
     """
@@ -34,6 +34,14 @@ class Warning(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/weekend_mask.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List
-from pydantic import BaseModel, Field, conlist, constr, validator
+from pydantic.v1 import BaseModel, Field, conlist, constr, validator
 from lusid.models.day_of_week import DayOfWeek
 
 class WeekendMask(BaseModel):
@@ -42,6 +42,14 @@ class WeekendMask(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/weighted_instrument.py

@@ -19,8 +19,9 @@ import json
 
 
 from typing import Any, Dict, Optional, Union
-from pydantic import BaseModel, Field, StrictFloat, StrictInt, constr
+from pydantic.v1 import BaseModel, Field, StrictFloat, StrictInt, constr
 from lusid.models.lusid_instrument import LusidInstrument
+from lusid.models.weighted_instrument_in_line_lookup_identifiers import WeightedInstrumentInLineLookupIdentifiers
 
 class WeightedInstrument(BaseModel):
     """
@@ -29,13 +30,23 @@ class WeightedInstrument(BaseModel):
     quantity: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="The quantity of the instrument that is owned.")
     holding_identifier: Optional[constr(strict=True, max_length=256, min_length=0)] = Field(None, alias="holdingIdentifier", description="Identifier for the instrument.  For a single, unique trade or transaction this can be thought of as equivalent to the transaction identifier, or  a composite of the sub-holding keys for a regular sub-holding. When there are multiple transactions sharing the same underlying instrument  such as purchase of shares on multiple dates where tax implications are different this would not be the case.    In an inlined aggregation request if this is wanted to identify a line item, it can be specified in the set of aggregation keys given on the aggregation  request that accompanies the set of weighted instruments.")
     instrument: Optional[LusidInstrument] = None
-    __properties = ["quantity", "holdingIdentifier", "instrument"]
+    in_line_lookup_identifiers: Optional[WeightedInstrumentInLineLookupIdentifiers] = Field(None, alias="inLineLookupIdentifiers")
+    instrument_scope: Optional[constr(strict=True, max_length=256, min_length=0)] = Field(None, alias="instrumentScope", description="The scope in which to resolve the instrument, if no inlined definition is provided.  If left empty, the default scope will be used.")
+    __properties = ["quantity", "holdingIdentifier", "instrument", "inLineLookupIdentifiers", "instrumentScope"]
 
     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))
@@ -58,11 +69,24 @@ class WeightedInstrument(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of instrument
         if self.instrument:
             _dict['instrument'] = self.instrument.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of in_line_lookup_identifiers
+        if self.in_line_lookup_identifiers:
+            _dict['inLineLookupIdentifiers'] = self.in_line_lookup_identifiers.to_dict()
         # set to None if holding_identifier (nullable) is None
         # and __fields_set__ contains the field
         if self.holding_identifier is None and "holding_identifier" in self.__fields_set__:
             _dict['holdingIdentifier'] = None
 
+        # set to None if in_line_lookup_identifiers (nullable) is None
+        # and __fields_set__ contains the field
+        if self.in_line_lookup_identifiers is None and "in_line_lookup_identifiers" in self.__fields_set__:
+            _dict['inLineLookupIdentifiers'] = None
+
+        # set to None if instrument_scope (nullable) is None
+        # and __fields_set__ contains the field
+        if self.instrument_scope is None and "instrument_scope" in self.__fields_set__:
+            _dict['instrumentScope'] = None
+
         return _dict
 
     @classmethod
@@ -77,6 +101,8 @@ class WeightedInstrument(BaseModel):
         _obj = WeightedInstrument.parse_obj({
             "quantity": obj.get("quantity"),
             "holding_identifier": obj.get("holdingIdentifier"),
-            "instrument": LusidInstrument.from_dict(obj.get("instrument")) if obj.get("instrument") is not None else None
+            "instrument": LusidInstrument.from_dict(obj.get("instrument")) if obj.get("instrument") is not None else None,
+            "in_line_lookup_identifiers": WeightedInstrumentInLineLookupIdentifiers.from_dict(obj.get("inLineLookupIdentifiers")) if obj.get("inLineLookupIdentifiers") is not None else None,
+            "instrument_scope": obj.get("instrumentScope")
         })
         return _obj

lusid/models/weighted_instrument_in_line_lookup_identifiers.py

@@ -0,0 +1,97 @@
+# 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, StrictStr
+
+class WeightedInstrumentInLineLookupIdentifiers(BaseModel):
+    """
+    External market codes and identifiers for the equity, e.g. IBM.  Required for valuation via SimpleStatic (look-up pricing).  Valuation will not succeed without a matching quote.  # noqa: E501
+    """
+    lusid_instrument_id: Optional[StrictStr] = Field(None, alias="LusidInstrumentId")
+    isin: Optional[StrictStr] = Field(None, alias="Isin")
+    sedol: Optional[StrictStr] = Field(None, alias="Sedol")
+    cusip: Optional[StrictStr] = Field(None, alias="Cusip")
+    client_internal: Optional[StrictStr] = Field(None, alias="ClientInternal")
+    figi: Optional[StrictStr] = Field(None, alias="Figi")
+    ric: Optional[StrictStr] = Field(None, alias="RIC")
+    quote_perm_id: Optional[StrictStr] = Field(None, alias="QuotePermId")
+    red_code: Optional[StrictStr] = Field(None, alias="REDCode")
+    bbgid: Optional[StrictStr] = Field(None, alias="BBGId")
+    ice_code: Optional[StrictStr] = Field(None, alias="ICECode")
+    __properties = ["LusidInstrumentId", "Isin", "Sedol", "Cusip", "ClientInternal", "Figi", "RIC", "QuotePermId", "REDCode", "BBGId", "ICECode"]
+
+    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) -> WeightedInstrumentInLineLookupIdentifiers:
+        """Create an instance of WeightedInstrumentInLineLookupIdentifiers from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> WeightedInstrumentInLineLookupIdentifiers:
+        """Create an instance of WeightedInstrumentInLineLookupIdentifiers from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return WeightedInstrumentInLineLookupIdentifiers.parse_obj(obj)
+
+        _obj = WeightedInstrumentInLineLookupIdentifiers.parse_obj({
+            "lusid_instrument_id": obj.get("LusidInstrumentId"),
+            "isin": obj.get("Isin"),
+            "sedol": obj.get("Sedol"),
+            "cusip": obj.get("Cusip"),
+            "client_internal": obj.get("ClientInternal"),
+            "figi": obj.get("Figi"),
+            "ric": obj.get("RIC"),
+            "quote_perm_id": obj.get("QuotePermId"),
+            "red_code": obj.get("REDCode"),
+            "bbgid": obj.get("BBGId"),
+            "ice_code": obj.get("ICECode")
+        })
+        return _obj

lusid/models/weighted_instruments.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List
-from pydantic import BaseModel, Field, conlist
+from pydantic.v1 import BaseModel, Field, conlist
 from lusid.models.weighted_instrument import WeightedInstrument
 
 class WeightedInstruments(BaseModel):
@@ -34,6 +34,14 @@ class WeightedInstruments(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/workspace.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.v1 import BaseModel, Field, conlist, constr
+from lusid.models.link import Link
+from lusid.models.version import Version
+
+class Workspace(BaseModel):
+    """
+    A workspace.  # noqa: E501
+    """
+    name: constr(strict=True, min_length=1) = Field(..., description="A workspace's name.")
+    description: constr(strict=True, max_length=6000, min_length=0) = Field(..., description="A friendly description for the workspace.")
+    version: Optional[Version] = None
+    links: Optional[conlist(Link)] = None
+    __properties = ["name", "description", "version", "links"]
+
+    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) -> Workspace:
+        """Create an instance of Workspace 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 version
+        if self.version:
+            _dict['version'] = self.version.to_dict()
+        # 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) -> Workspace:
+        """Create an instance of Workspace from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return Workspace.parse_obj(obj)
+
+        _obj = Workspace.parse_obj({
+            "name": obj.get("name"),
+            "description": obj.get("description"),
+            "version": Version.from_dict(obj.get("version")) if obj.get("version") 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/workspace_creation_request.py

@@ -0,0 +1,86 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict
+from pydantic.v1 import BaseModel, Field, constr, validator
+
+class WorkspaceCreationRequest(BaseModel):
+    """
+    A request to create an empty workspace.  # noqa: E501
+    """
+    name: constr(strict=True, max_length=64, min_length=1) = Field(..., description="A workspace's name.")
+    description: constr(strict=True, max_length=6000, min_length=0) = Field(..., description="A friendly description for the workspace.")
+    __properties = ["name", "description"]
+
+    @validator('name')
+    def name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
+        return value
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __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) -> WorkspaceCreationRequest:
+        """Create an instance of WorkspaceCreationRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> WorkspaceCreationRequest:
+        """Create an instance of WorkspaceCreationRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return WorkspaceCreationRequest.parse_obj(obj)
+
+        _obj = WorkspaceCreationRequest.parse_obj({
+            "name": obj.get("name"),
+            "description": obj.get("description")
+        })
+        return _obj