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

lusid/models/recipe_block.py

@@ -0,0 +1,95 @@
+# 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
+from lusid.models.recipe_value import RecipeValue
+
+class RecipeBlock(BaseModel):
+    """
+    An atomic operation used in Recipe composer to compose a Configuration Recipe  # noqa: E501
+    """
+    value: Optional[RecipeValue] = None
+    path: Optional[StrictStr] = Field(None, description="Path of the Value that the operation is to be performed on.")
+    op: Optional[StrictStr] = Field(None, description="Operation to be performed on the part of the value.")
+    __properties = ["value", "path", "op"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __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) -> RecipeBlock:
+        """Create an instance of RecipeBlock from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of value
+        if self.value:
+            _dict['value'] = self.value.to_dict()
+        # set to None if path (nullable) is None
+        # and __fields_set__ contains the field
+        if self.path is None and "path" in self.__fields_set__:
+            _dict['path'] = None
+
+        # set to None if op (nullable) is None
+        # and __fields_set__ contains the field
+        if self.op is None and "op" in self.__fields_set__:
+            _dict['op'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RecipeBlock:
+        """Create an instance of RecipeBlock from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RecipeBlock.parse_obj(obj)
+
+        _obj = RecipeBlock.parse_obj({
+            "value": RecipeValue.from_dict(obj.get("value")) if obj.get("value") is not None else None,
+            "path": obj.get("path"),
+            "op": obj.get("op")
+        })
+        return _obj

lusid/models/recipe_composer.py

@@ -0,0 +1,108 @@
+# 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, validator
+from lusid.models.recipe_block import RecipeBlock
+
+class RecipeComposer(BaseModel):
+    """
+    Recipe composer is an object used to dynamically compose Configuration Recipe from atomic operations.  # noqa: E501
+    """
+    scope: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The scope used when updating or inserting the Recipe Composer.")
+    code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="User given string name (code) to identify the recipe.")
+    operations: Optional[conlist(RecipeBlock)] = Field(None, description="Atomic operations used to compose a Configuration Recipe.")
+    __properties = ["scope", "code", "operations"]
+
+    @validator('scope')
+    def scope_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
+        return value
+
+    @validator('code')
+    def code_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
+        return value
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __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) -> RecipeComposer:
+        """Create an instance of RecipeComposer from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in operations (list)
+        _items = []
+        if self.operations:
+            for _item in self.operations:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['operations'] = _items
+        # set to None if operations (nullable) is None
+        # and __fields_set__ contains the field
+        if self.operations is None and "operations" in self.__fields_set__:
+            _dict['operations'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RecipeComposer:
+        """Create an instance of RecipeComposer from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RecipeComposer.parse_obj(obj)
+
+        _obj = RecipeComposer.parse_obj({
+            "scope": obj.get("scope"),
+            "code": obj.get("code"),
+            "operations": [RecipeBlock.from_dict(_item) for _item in obj.get("operations")] if obj.get("operations") is not None else None
+        })
+        return _obj

lusid/models/recipe_value.py

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

lusid/models/recombine_step.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, List
+from pydantic.v1 import Field, StrictStr, conlist, constr, validator
+from lusid.models.compliance_step import ComplianceStep
+from lusid.models.compliance_template_parameter import ComplianceTemplateParameter
+
+class RecombineStep(ComplianceStep):
+    """
+    RecombineStep
+    """
+    label: constr(strict=True, min_length=1) = Field(..., description="The label of the compliance step")
+    parameters: conlist(ComplianceTemplateParameter) = Field(..., description="Parameters required for the step")
+    compliance_step_type: StrictStr = Field(..., alias="complianceStepType", description=". The available values are: FilterStep, GroupByStep, GroupFilterStep, BranchStep, RecombineStep, CheckStep, PercentCheckStep")
+    additional_properties: Dict[str, Any] = {}
+    __properties = ["complianceStepType", "label", "parameters"]
+
+    @validator('compliance_step_type')
+    def compliance_step_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in ('FilterStep', 'GroupByStep', 'GroupFilterStep', 'BranchStep', 'RecombineStep', 'CheckStep', 'PercentCheckStep'):
+            raise ValueError("must be one of enum values ('FilterStep', 'GroupByStep', 'GroupFilterStep', 'BranchStep', 'RecombineStep', 'CheckStep', 'PercentCheckStep')")
+        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) -> RecombineStep:
+        """Create an instance of RecombineStep from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                            "additional_properties"
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in parameters (list)
+        _items = []
+        if self.parameters:
+            for _item in self.parameters:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['parameters'] = _items
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RecombineStep:
+        """Create an instance of RecombineStep from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RecombineStep.parse_obj(obj)
+
+        _obj = RecombineStep.parse_obj({
+            "compliance_step_type": obj.get("complianceStepType"),
+            "label": obj.get("label"),
+            "parameters": [ComplianceTemplateParameter.from_dict(_item) for _item in obj.get("parameters")] if obj.get("parameters") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj

lusid/models/recommended_sort_by.py

@@ -0,0 +1,84 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, Optional
+from pydantic.v1 import BaseModel, Field, constr
+
+class RecommendedSortBy(BaseModel):
+    """
+    RecommendedSortBy
+    """
+    attribute_name: constr(strict=True, max_length=16384, min_length=1) = Field(..., alias="attributeName", description="The property key, identifier type, or field to be sorted by.")
+    sort_order: Optional[constr(strict=True, max_length=4, min_length=0)] = Field(None, alias="sortOrder", description="The sorting direction. Either ascending (ASC) or descending (DESC).")
+    __properties = ["attributeName", "sortOrder"]
+
+    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) -> RecommendedSortBy:
+        """Create an instance of RecommendedSortBy 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 sort_order (nullable) is None
+        # and __fields_set__ contains the field
+        if self.sort_order is None and "sort_order" in self.__fields_set__:
+            _dict['sortOrder'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RecommendedSortBy:
+        """Create an instance of RecommendedSortBy from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RecommendedSortBy.parse_obj(obj)
+
+        _obj = RecommendedSortBy.parse_obj({
+            "attribute_name": obj.get("attributeName"),
+            "sort_order": obj.get("sortOrder")
+        })
+        return _obj

lusid/models/reconcile_date_time_rule.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional, Union
-from pydantic import Field, StrictFloat, StrictInt, StrictStr, validator
+from pydantic.v1 import Field, StrictFloat, StrictInt, StrictStr, validator
 from lusid.models.aggregate_spec import AggregateSpec
 from lusid.models.reconciliation_rule import ReconciliationRule
 
@@ -53,6 +53,14 @@ class ReconcileDateTimeRule(ReconciliationRule):
         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/reconcile_numeric_rule.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional, Union
-from pydantic import Field, StrictFloat, StrictInt, StrictStr, validator
+from pydantic.v1 import Field, StrictFloat, StrictInt, StrictStr, validator
 from lusid.models.aggregate_spec import AggregateSpec
 from lusid.models.reconciliation_rule import ReconciliationRule
 
@@ -53,6 +53,14 @@ class ReconcileNumericRule(ReconciliationRule):
         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/reconcile_string_rule.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import Field, StrictStr, conlist, validator
+from pydantic.v1 import Field, StrictStr, conlist, validator
 from lusid.models.aggregate_spec import AggregateSpec
 from lusid.models.reconciliation_rule import ReconciliationRule
 
@@ -53,6 +53,14 @@ class ReconcileStringRule(ReconciliationRule):
         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/reconciled_transaction.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional, Union
-from pydantic import BaseModel, Field, StrictBool, StrictFloat, StrictInt, conlist
+from pydantic.v1 import BaseModel, Field, StrictBool, StrictFloat, StrictInt, conlist
 from lusid.models.transaction import Transaction
 
 class ReconciledTransaction(BaseModel):
@@ -37,6 +37,14 @@ class ReconciledTransaction(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/reconciliation.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, StrictBool, StrictStr, conlist
+from pydantic.v1 import BaseModel, Field, StrictBool, StrictStr, conlist
 from lusid.models.link import Link
 from lusid.models.model_property import ModelProperty
 from lusid.models.reconciliation_configuration import ReconciliationConfiguration
@@ -52,6 +52,14 @@ class Reconciliation(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/reconciliation_break.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
+from pydantic.v1 import BaseModel, Field, StrictFloat, StrictInt, StrictStr, conlist, constr
 from lusid.models.currency_and_amount import CurrencyAndAmount
 from lusid.models.model_property import ModelProperty
 from lusid.models.perpetual_property import PerpetualProperty
@@ -45,6 +45,14 @@ class ReconciliationBreak(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/reconciliation_configuration.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic import BaseModel, Field
+from pydantic.v1 import BaseModel, Field
 from lusid.models.reconciliation_side_configuration import ReconciliationSideConfiguration
 from lusid.models.resource_id import ResourceId
 
@@ -37,6 +37,14 @@ class ReconciliationConfiguration(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))