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

lusid/models/workspace_item.py

@@ -0,0 +1,120 @@
+# 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, StrictInt, conlist, constr, validator
+from lusid.models.link import Link
+from lusid.models.version import Version
+
+class WorkspaceItem(BaseModel):
+    """
+    An item stored in a workspace.  # noqa: E501
+    """
+    type: constr(strict=True, min_length=1) = Field(..., description="The type of the workspace item.")
+    format: StrictInt = Field(..., description="A simple integer format identifier.")
+    name: constr(strict=True, min_length=1) = Field(..., description="A workspace item's name.")
+    group: constr(strict=True, min_length=1) = Field(..., description="The group containing a workspace item.")
+    description: constr(strict=True, max_length=1024, min_length=0) = Field(..., description="The description of a workspace item.")
+    content: Optional[Any] = Field(..., description="The content associated with a workspace item.")
+    version: Optional[Version] = None
+    links: Optional[conlist(Link)] = None
+    __properties = ["type", "format", "name", "group", "description", "content", "version", "links"]
+
+    @validator('description')
+    def description_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[\s\S]*$", value):
+            raise ValueError(r"must validate the regular expression /^[\s\S]*$/")
+        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) -> WorkspaceItem:
+        """Create an instance of WorkspaceItem 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 content (nullable) is None
+        # and __fields_set__ contains the field
+        if self.content is None and "content" in self.__fields_set__:
+            _dict['content'] = None
+
+        # 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) -> WorkspaceItem:
+        """Create an instance of WorkspaceItem from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return WorkspaceItem.parse_obj(obj)
+
+        _obj = WorkspaceItem.parse_obj({
+            "type": obj.get("type"),
+            "format": obj.get("format"),
+            "name": obj.get("name"),
+            "group": obj.get("group"),
+            "description": obj.get("description"),
+            "content": obj.get("content"),
+            "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_item_creation_request.py

@@ -0,0 +1,113 @@
+# 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, StrictInt, constr, validator
+
+class WorkspaceItemCreationRequest(BaseModel):
+    """
+    A request to create an item in a workspace.  # noqa: E501
+    """
+    format: StrictInt = Field(..., description="A simple integer format identifier.")
+    name: constr(strict=True, max_length=64, min_length=1) = Field(..., description="A workspace item's name.")
+    group: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The group containing a workspace item.")
+    description: constr(strict=True, max_length=1024, min_length=0) = Field(..., description="The description of a workspace item.")
+    content: Optional[Any] = Field(..., description="The content associated with a workspace item.")
+    type: constr(strict=True, max_length=6000, min_length=0) = Field(..., description="The type of the workspace item.")
+    __properties = ["format", "name", "group", "description", "content", "type"]
+
+    @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
+
+    @validator('group')
+    def group_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
+        return value
+
+    @validator('description')
+    def description_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[\s\S]*$", value):
+            raise ValueError(r"must validate the regular expression /^[\s\S]*$/")
+        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) -> WorkspaceItemCreationRequest:
+        """Create an instance of WorkspaceItemCreationRequest 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 content (nullable) is None
+        # and __fields_set__ contains the field
+        if self.content is None and "content" in self.__fields_set__:
+            _dict['content'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> WorkspaceItemCreationRequest:
+        """Create an instance of WorkspaceItemCreationRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return WorkspaceItemCreationRequest.parse_obj(obj)
+
+        _obj = WorkspaceItemCreationRequest.parse_obj({
+            "format": obj.get("format"),
+            "name": obj.get("name"),
+            "group": obj.get("group"),
+            "description": obj.get("description"),
+            "content": obj.get("content"),
+            "type": obj.get("type")
+        })
+        return _obj

lusid/models/workspace_item_update_request.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, StrictInt, constr, validator
+
+class WorkspaceItemUpdateRequest(BaseModel):
+    """
+    A request to update a workspace item.  # noqa: E501
+    """
+    format: StrictInt = Field(..., description="A simple integer format identifier.")
+    description: constr(strict=True, max_length=1024, min_length=0) = Field(..., description="The description of a workspace item.")
+    content: Optional[Any] = Field(..., description="The content associated with a workspace item.")
+    type: constr(strict=True, max_length=6000, min_length=0) = Field(..., description="The type of the workspace item.")
+    __properties = ["format", "description", "content", "type"]
+
+    @validator('description')
+    def description_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[\s\S]*$", value):
+            raise ValueError(r"must validate the regular expression /^[\s\S]*$/")
+        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) -> WorkspaceItemUpdateRequest:
+        """Create an instance of WorkspaceItemUpdateRequest 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 content (nullable) is None
+        # and __fields_set__ contains the field
+        if self.content is None and "content" in self.__fields_set__:
+            _dict['content'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> WorkspaceItemUpdateRequest:
+        """Create an instance of WorkspaceItemUpdateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return WorkspaceItemUpdateRequest.parse_obj(obj)
+
+        _obj = WorkspaceItemUpdateRequest.parse_obj({
+            "format": obj.get("format"),
+            "description": obj.get("description"),
+            "content": obj.get("content"),
+            "type": obj.get("type")
+        })
+        return _obj

lusid/models/workspace_update_request.py

@@ -0,0 +1,77 @@
+# 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
+
+class WorkspaceUpdateRequest(BaseModel):
+    """
+    A request to update a workspace.  # noqa: E501
+    """
+    description: constr(strict=True, max_length=256, min_length=1) = Field(..., description="A friendly description for the workspace.")
+    __properties = ["description"]
+
+    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) -> WorkspaceUpdateRequest:
+        """Create an instance of WorkspaceUpdateRequest 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) -> WorkspaceUpdateRequest:
+        """Create an instance of WorkspaceUpdateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return WorkspaceUpdateRequest.parse_obj(obj)
+
+        _obj = WorkspaceUpdateRequest.parse_obj({
+            "description": obj.get("description")
+        })
+        return _obj

lusid/models/yield_curve_data.py

@@ -19,7 +19,7 @@ import json
 
 from datetime import datetime
 from typing import Any, Dict, List, Optional
-from pydantic import Field, StrictStr, conlist, constr, validator
+from pydantic.v1 import Field, StrictStr, conlist, constr, validator
 from lusid.models.complex_market_data import ComplexMarketData
 from lusid.models.lusid_instrument import LusidInstrument
 from lusid.models.market_data_options import MarketDataOptions
@@ -34,15 +34,15 @@ class YieldCurveData(ComplexMarketData):
     quotes: conlist(MarketQuote) = Field(..., description="The market quotes corresponding to the the instruments used to define the curve")
     lineage: Optional[constr(strict=True, max_length=1024, min_length=0)] = Field(None, description="Description of the complex market data's lineage e.g. 'FundAccountant_GreenQuality'.")
     market_data_options: Optional[MarketDataOptions] = Field(None, alias="marketDataOptions")
-    market_data_type: StrictStr = Field(..., alias="marketDataType", description="The available values are: DiscountFactorCurveData, EquityVolSurfaceData, FxVolSurfaceData, IrVolCubeData, OpaqueMarketData, YieldCurveData, FxForwardCurveData, FxForwardPipsCurveData, FxForwardTenorCurveData, FxForwardTenorPipsCurveData, FxForwardCurveByQuoteReference, CreditSpreadCurveData, EquityCurveByPricesData")
+    market_data_type: StrictStr = Field(..., alias="marketDataType", description="The available values are: DiscountFactorCurveData, EquityVolSurfaceData, FxVolSurfaceData, IrVolCubeData, OpaqueMarketData, YieldCurveData, FxForwardCurveData, FxForwardPipsCurveData, FxForwardTenorCurveData, FxForwardTenorPipsCurveData, FxForwardCurveByQuoteReference, CreditSpreadCurveData, EquityCurveByPricesData, ConstantVolatilitySurface")
     additional_properties: Dict[str, Any] = {}
     __properties = ["marketDataType", "baseDate", "instruments", "quotes", "lineage", "marketDataOptions"]
 
     @validator('market_data_type')
     def market_data_type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in ('DiscountFactorCurveData', 'EquityVolSurfaceData', 'FxVolSurfaceData', 'IrVolCubeData', 'OpaqueMarketData', 'YieldCurveData', 'FxForwardCurveData', 'FxForwardPipsCurveData', 'FxForwardTenorCurveData', 'FxForwardTenorPipsCurveData', 'FxForwardCurveByQuoteReference', 'CreditSpreadCurveData', 'EquityCurveByPricesData'):
-            raise ValueError("must be one of enum values ('DiscountFactorCurveData', 'EquityVolSurfaceData', 'FxVolSurfaceData', 'IrVolCubeData', 'OpaqueMarketData', 'YieldCurveData', 'FxForwardCurveData', 'FxForwardPipsCurveData', 'FxForwardTenorCurveData', 'FxForwardTenorPipsCurveData', 'FxForwardCurveByQuoteReference', 'CreditSpreadCurveData', 'EquityCurveByPricesData')")
+        if value not in ('DiscountFactorCurveData', 'EquityVolSurfaceData', 'FxVolSurfaceData', 'IrVolCubeData', 'OpaqueMarketData', 'YieldCurveData', 'FxForwardCurveData', 'FxForwardPipsCurveData', 'FxForwardTenorCurveData', 'FxForwardTenorPipsCurveData', 'FxForwardCurveByQuoteReference', 'CreditSpreadCurveData', 'EquityCurveByPricesData', 'ConstantVolatilitySurface'):
+            raise ValueError("must be one of enum values ('DiscountFactorCurveData', 'EquityVolSurfaceData', 'FxVolSurfaceData', 'IrVolCubeData', 'OpaqueMarketData', 'YieldCurveData', 'FxForwardCurveData', 'FxForwardPipsCurveData', 'FxForwardTenorCurveData', 'FxForwardTenorPipsCurveData', 'FxForwardCurveByQuoteReference', 'CreditSpreadCurveData', 'EquityCurveByPricesData', 'ConstantVolatilitySurface')")
         return value
 
     class Config:
@@ -50,6 +50,14 @@ class YieldCurveData(ComplexMarketData):
         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/rest.py

@@ -68,6 +68,11 @@ class RESTClientObject:
 
         self.proxy = configuration.proxy
         self.proxy_headers = configuration.proxy_headers
+        self.timeout = aiohttp.ClientTimeout(
+            total=configuration.timeouts.total_timeout_ms / 1000.0 if configuration.timeouts != None and configuration.timeouts.total_timeout_ms != None else None,
+            connect=configuration.timeouts.connect_timeout_ms / 1000.0 if configuration.timeouts != None and configuration.timeouts.connect_timeout_ms != None else None,
+            sock_read=configuration.timeouts.read_timeout_ms / 1000.0 if configuration.timeouts != None and configuration.timeouts.read_timeout_ms != None else None,
+        )
 
         # https pool manager
         self.pool_manager = aiohttp.ClientSession(
@@ -80,7 +85,7 @@ class RESTClientObject:
 
     async def request(self, method, url, query_params=None, headers=None,
                       body=None, post_params=None, _preload_content=True,
-                      _request_timeout=None):
+                      _request_timeout=None, opts=None):
         """Execute request
 
         :param method: http request method
@@ -93,10 +98,9 @@ class RESTClientObject:
                             and `multipart/form-data`
         :param _preload_content: this is a non-applicable field for
                                  the AiohttpClient.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
         """
         method = method.upper()
         assert method in ['GET', 'HEAD', 'DELETE', 'POST', 'PUT',
@@ -112,11 +116,51 @@ class RESTClientObject:
         # url already contains the URL query string
         # so reset query_params to empty dict
         query_params = {}
-        timeout = _request_timeout or 5 * 60
+
+        # _request_timeout param cannot be removed for backwards compatability
+        # values from opts override values from _request_timeout
+        # try to get values from opts first, then _request_timeout, then self.timeout, else set to None
+        # timeout = _request_timeout or self.timeout
+        timeout = None
+        opts_total_timeout = opts.total_timeout_ms / 1000.0 if opts and opts.total_timeout_ms != None else None
+        opts_connect_timeout = opts.connect_timeout_ms / 1000.0 if opts and opts.connect_timeout_ms != None else None
+        opts_read_timeout = opts.read_timeout_ms / 1000.0 if opts and opts.read_timeout_ms != None else None
+        if not _request_timeout:
+            timeout = aiohttp.ClientTimeout(
+                total=opts_total_timeout if opts_total_timeout != None
+                    else self.timeout.total, 
+                connect=opts_connect_timeout if opts_connect_timeout != None
+                    else self.timeout.connect,
+                sock_read=opts_read_timeout if opts_read_timeout != None
+                    else self.timeout.sock_read)
+        elif isinstance(_request_timeout, aiohttp.ClientTimeout):
+            timeout = aiohttp.ClientTimeout(
+                total=opts_total_timeout if opts_total_timeout != None
+                    else _request_timeout.total if _request_timeout.total != None
+                        else self.timeout.total, 
+                connect=opts_connect_timeout if opts_connect_timeout != None
+                    else _request_timeout.connect if _request_timeout.connect != None
+                        else self.timeout.connect,
+                sock_read=opts_read_timeout if opts_read_timeout != None
+                    else _request_timeout.sock_read if _request_timeout.sock_read != None
+                        else self.timeout.sock_read)
+        elif isinstance(_request_timeout, (int, float)):
+            timeout = aiohttp.ClientTimeout(
+                total=opts_total_timeout if opts_total_timeout != None
+                    else _request_timeout, 
+                connect=opts_connect_timeout if opts_connect_timeout != None
+                    else self.timeout.connect, 
+                sock_read=opts_read_timeout if opts_read_timeout != None
+                    else self.timeout.sock_read)
+        else:
+            raise f"unexpected type '{type(_request_timeout)}' for _request_timeout"
 
         if 'Content-Type' not in headers:
             headers['Content-Type'] = 'application/json'
-
+        
+        for content in headers:
+            headers[content] = str(headers[content])
+            
         args = {
             "method": method,
             "url": url,
@@ -159,7 +203,7 @@ class RESTClientObject:
             # Pass a `bytes` parameter directly in the body to support
             # other content types than Json when `body` argument is provided
             # in serialized form
-            elif isinstance(body, bytes):
+            elif isinstance(body, str) or isinstance(body, bytes):
                 args["data"] = body
             else:
                 # Cannot generate the request from given parameters
@@ -183,69 +227,78 @@ class RESTClientObject:
         return r
 
     async def get_request(self, url, headers=None, query_params=None,
-                  _preload_content=True, _request_timeout=None):
+                  _preload_content=True, _request_timeout=None, opts=None):
         return (await self.request("GET", url,
                                    headers=headers,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   query_params=query_params))
+                                   query_params=query_params,
+                                   opts=opts))
 
     async def head_request(self, url, headers=None, query_params=None,
-                   _preload_content=True, _request_timeout=None):
+                   _preload_content=True, _request_timeout=None, opts=None):
         return (await self.request("HEAD", url,
                                    headers=headers,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   query_params=query_params))
+                                   query_params=query_params,
+                                   opts=opts))
 
     async def options_request(self, url, headers=None, query_params=None,
                       post_params=None, body=None, _preload_content=True,
-                      _request_timeout=None):
+                      _request_timeout=None, opts=None):
         return (await self.request("OPTIONS", url,
                                    headers=headers,
                                    query_params=query_params,
                                    post_params=post_params,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   body=body))
+                                   body=body,
+                                   opts=opts))
 
     async def delete_request(self, url, headers=None, query_params=None, body=None,
-                     _preload_content=True, _request_timeout=None):
+                     _preload_content=True, _request_timeout=None, 
+                     opts=None):
         return (await self.request("DELETE", url,
                                    headers=headers,
                                    query_params=query_params,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   body=body))
+                                   body=body,
+                                   opts=opts))
 
     async def post_request(self, url, headers=None, query_params=None,
                    post_params=None, body=None, _preload_content=True,
-                   _request_timeout=None):
+                   _request_timeout=None, opts=None):
         return (await self.request("POST", url,
                                    headers=headers,
                                    query_params=query_params,
                                    post_params=post_params,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   body=body))
+                                   body=body,
+                                   opts=opts))
 
     async def put_request(self, url, headers=None, query_params=None, post_params=None,
-                  body=None, _preload_content=True, _request_timeout=None):
+                  body=None, _preload_content=True, _request_timeout=None, 
+                  opts=None):
         return (await self.request("PUT", url,
                                    headers=headers,
                                    query_params=query_params,
                                    post_params=post_params,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   body=body))
+                                   body=body,
+                                   opts=opts))
 
     async def patch_request(self, url, headers=None, query_params=None,
                     post_params=None, body=None, _preload_content=True,
-                    _request_timeout=None):
+                    _request_timeout=None, opts=None):
         return (await self.request("PATCH", url,
                                    headers=headers,
                                    query_params=query_params,
                                    post_params=post_params,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   body=body))
+                                   body=body,
+                                   opts=opts))