2023-09-12 : Synchronize codes to the origin repository.

Author: roywangaspose

asposecellscloud/__init__.py

@@ -597,6 +597,9 @@
 from .requests.delete_worksheet_validations_request import DeleteWorksheetValidationsRequest
 from .requests.post_workbook_export_xml_request import PostWorkbookExportXMLRequest
 from .requests.post_workbook_import_xml_request import PostWorkbookImportXMLRequest
+from .requests.post_worksheet_range_sort_request import PostWorksheetRangeSortRequest
+from .requests.post_worksheet_list_object_remove_duplicates_request import PostWorksheetListObjectRemoveDuplicatesRequest
+from .requests.post_worksheet_list_object_insert_slicer_request import PostWorksheetListObjectInsertSlicerRequest
 from .requests.download_file_request import DownloadFileRequest
 from .requests.upload_file_request import UploadFileRequest
 from .requests.copy_file_request import CopyFileRequest

asposecellscloud/apis/cells_api.py

@@ -9889,6 +9889,53 @@ def post_worksheet_cells_range_move_to_with_http_info(self, request, **kwargs):
                                         _request_timeout=params.get('_request_timeout'),
                                         collection_formats=http_params['collection_formats'])
 
+    # <summary>
+    # Sets outline border around a range of cells.
+    # </summary>
+    # <param name="request">Request. <see cref="PostWorksheetCellsRangeSortRequest" /></param>
+    def post_worksheet_cells_range_sort(self, request, **kwargs):
+
+        kwargs['_return_http_data_only'] = True
+        self.check_access_token()
+        if kwargs.get('callback'):
+            return self.post_worksheet_cells_range_sort_with_http_info(request,**kwargs)
+        else:
+            (data) = self.post_worksheet_cells_range_sort_with_http_info(request,**kwargs)
+            return data
+
+    def post_worksheet_cells_range_sort_with_http_info(self, request, **kwargs):
+        all_params = []
+        all_params.append('callback')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+        params = locals()
+        for key, val in iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method post_worksheet_cells_range_sort" % key
+                )
+            params[key] = val
+        del params['kwargs'] 
+
+        http_params = request.create_http_request(self.api_client)
+        return self.api_client.call_api(http_params['path'], http_params['method'],
+                                        None,
+                                        http_params['query_params'],
+                                        http_params['header_params'],
+                                        body=http_params['body'],
+                                        post_params=http_params['form_params'],
+                                        files=http_params['files'],
+                                        response_type=http_params['response_type'],
+                                        auth_settings=http_params['auth_settings'],
+                                        callback=params.get('callback'),
+                                        _return_http_data_only=params.get('_return_http_data_only'),
+                                        _preload_content=params.get('_preload_content', True),
+                                        _request_timeout=params.get('_request_timeout'),
+                                        collection_formats=http_params['collection_formats'])
+
+
 
 
     # <summary>
@@ -24888,6 +24935,104 @@ def cells_list_objects_get_worksheet_list_objects_with_http_info(self, name, she
                                         _request_timeout=params.get('_request_timeout'),
                                         collection_formats=collection_formats)
 
+
+
+
+    # <summary>
+    # Remove duplicates on list object.
+    # </summary>
+    # <param name="request">Request. <see cref="PostWorksheetListObjectRemoveDuplicatesRequest" /></param>
+    def post_worksheet_list_object_remove_duplicates(self, request, **kwargs):
+
+        kwargs['_return_http_data_only'] = True
+        self.check_access_token()
+        if kwargs.get('callback'):
+            return self.post_worksheet_list_object_remove_duplicates_with_http_info(request,**kwargs)
+        else:
+            (data) = self.post_worksheet_list_object_remove_duplicates_with_http_info(request,**kwargs)
+            return data
+
+    def post_worksheet_list_object_remove_duplicates_with_http_info(self, request, **kwargs):
+        all_params = []
+        all_params.append('callback')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+        params = locals()
+        for key, val in iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method post_worksheet_list_object_remove_duplicates" % key
+                )
+            params[key] = val
+        del params['kwargs'] 
+
+        http_params = request.create_http_request(self.api_client)
+        return self.api_client.call_api(http_params['path'], http_params['method'],
+                                        None,
+                                        http_params['query_params'],
+                                        http_params['header_params'],
+                                        body=http_params['body'],
+                                        post_params=http_params['form_params'],
+                                        files=http_params['files'],
+                                        response_type=http_params['response_type'],
+                                        auth_settings=http_params['auth_settings'],
+                                        callback=params.get('callback'),
+                                        _return_http_data_only=params.get('_return_http_data_only'),
+                                        _preload_content=params.get('_preload_content', True),
+                                        _request_timeout=params.get('_request_timeout'),
+                                        collection_formats=http_params['collection_formats'])
+
+
+
+    # <summary>
+    # Insert slicer for list object.
+    # </summary>
+    # <param name="request">Request. <see cref="PostWorksheetListObjectInsertSlicerRequest" /></param>
+    def post_worksheet_list_object_insert_slicer(self, request, **kwargs):
+
+        kwargs['_return_http_data_only'] = True
+        self.check_access_token()
+        if kwargs.get('callback'):
+            return self.post_worksheet_list_object_insert_slicer_with_http_info(request,**kwargs)
+        else:
+            (data) = self.post_worksheet_list_object_insert_slicer_with_http_info(request,**kwargs)
+            return data
+
+    def post_worksheet_list_object_insert_slicer_with_http_info(self, request, **kwargs):
+        all_params = []
+        all_params.append('callback')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+        params = locals()
+        for key, val in iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method post_worksheet_list_object_insert_slicer" % key
+                )
+            params[key] = val
+        del params['kwargs'] 
+
+        http_params = request.create_http_request(self.api_client)
+        return self.api_client.call_api(http_params['path'], http_params['method'],
+                                        None,
+                                        http_params['query_params'],
+                                        http_params['header_params'],
+                                        body=http_params['body'],
+                                        post_params=http_params['form_params'],
+                                        files=http_params['files'],
+                                        response_type=http_params['response_type'],
+                                        auth_settings=http_params['auth_settings'],
+                                        callback=params.get('callback'),
+                                        _return_http_data_only=params.get('_return_http_data_only'),
+                                        _preload_content=params.get('_preload_content', True),
+                                        _request_timeout=params.get('_request_timeout'),
+                                        collection_formats=http_params['collection_formats'])
+
+
     def cells_list_objects_post_worksheet_list_column(self, name, sheet_name, list_object_index, column_index, **kwargs):
         warnings.warn("CellsApi is deprecated", DeprecationWarning)
         """

asposecellscloud/models/__init__.py

@@ -29,8 +29,6 @@
 from .area import Area
 from .auto_fitter_options import AutoFitterOptions
 from .axis import Axis
-from .barcode_response import BarcodeResponse
-from .barcode_response_list import BarcodeResponseList
 from .batch_convert_request import BatchConvertRequest
 from .batch_lock_request import BatchLockRequest
 from .batch_protect_request import BatchProtectRequest

asposecellscloud/models/abstract_calculation_engine.py

@@ -0,0 +1,177 @@
+# coding: utf-8
+"""
+<copyright company="Aspose" file="AbstractCalculationEnginepy.cs">
+  Copyright (c) 2023 Aspose.Cells Cloud
+</copyright>
+<summary>
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+</summary>
+"""
+
+from pprint import pformat
+from six import iteritems
+import re
+
+class AbstractCalculationEngine(object):
+
+    """
+    NOTE: This class is auto generated by the swagger code generator program.
+    Do not edit the class manually.
+    """
+
+
+    """
+    Attributes:
+      swagger_types (dict): The key is attribute name
+                            and the value is attribute type.
+      attribute_map (dict): The key is attribute name
+                            and the value is json key in definition.
+    """
+
+    swagger_types = {
+        'is_param_literal_required' : 'bool',
+        'is_param_array_mode_required' : 'bool',
+        'process_built_in_functions' : 'bool'
+    }
+
+    attribute_map = {
+        'is_param_literal_required' : 'IsParamLiteralRequired' ,
+        'is_param_array_mode_required' : 'IsParamArrayModeRequired' ,
+        'process_built_in_functions' : 'ProcessBuiltInFunctions' 
+    }
+
+    @staticmethod
+    def get_swagger_types():
+        return AbstractCalculationEngine.swagger_types
+
+    @staticmethod
+    def get_attribute_map():
+        return AbstractCalculationEngine.attribute_map
+
+    def get_from_container(self, attr):
+        if attr in self.container:
+            return self.container[attr]
+        return None
+
+    def __init__(self,is_param_literal_required=None ,is_param_array_mode_required=None ,process_built_in_functions=None   ,**kw):
+        """
+        Associative dict for storing property values
+        """
+        self.container = {}
+
+        """
+        AbstractCalculationEngine - a model defined in Swagger
+        """
+        self.container['is_param_literal_required'] = None 
+        self.container['is_param_array_mode_required'] = None 
+        self.container['process_built_in_functions'] = None 
+        params = locals()
+        self.is_param_literal_required = is_param_literal_required
+        if 'is_param_literal_required' in params:
+            self.is_param_literal_required = params["is_param_literal_required"]
+
+
+             
+        self.is_param_array_mode_required = is_param_array_mode_required
+        if 'is_param_array_mode_required' in params:
+            self.is_param_array_mode_required = params["is_param_array_mode_required"]
+
+
+             
+        self.process_built_in_functions = process_built_in_functions
+        if 'process_built_in_functions' in params:
+            self.process_built_in_functions = params["process_built_in_functions"]
+
+
+             
+
+    @property
+    def is_param_literal_required(self):
+        return self.container['is_param_literal_required']
+
+    @is_param_literal_required.setter
+    def is_param_literal_required(self, is_param_literal_required):
+        self.container['is_param_literal_required'] = is_param_literal_required 
+    @property
+    def is_param_array_mode_required(self):
+        return self.container['is_param_array_mode_required']
+
+    @is_param_array_mode_required.setter
+    def is_param_array_mode_required(self, is_param_array_mode_required):
+        self.container['is_param_array_mode_required'] = is_param_array_mode_required 
+    @property
+    def process_built_in_functions(self):
+        return self.container['process_built_in_functions']
+
+    @process_built_in_functions.setter
+    def process_built_in_functions(self, process_built_in_functions):
+        self.container['process_built_in_functions'] = process_built_in_functions 
+
+    def to_dict(self):
+        """
+        Returns the model properties as a dict
+        """
+        result = {}
+
+        for attr, _ in iteritems(self.get_swagger_types()):
+            value = self.get_from_container(attr)
+            if isinstance(value, list):
+                result[attr] = list(map(
+                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
+                    value
+                ))
+            elif hasattr(value, "to_dict"):
+                result[attr] = value.to_dict()
+            elif isinstance(value, dict):
+                result[attr] = dict(map(
+                    lambda item: (item[0], item[1].to_dict())
+                    if hasattr(item[1], "to_dict") else item,
+                    value.items()
+                ))
+            else:
+                result[attr] = value
+
+        return result
+
+    def to_str(self):
+        """
+        Returns the string representation of the model
+        """
+        return pformat(self.to_dict())
+
+    def __repr__(self):
+        """
+        For `print` and `pprint`
+        """
+        return self.to_str()
+
+    def __eq__(self, other):
+        """
+        Returns true if both objects are equal
+        """
+        if not isinstance(other, AbstractCalculationEngine):
+            return False
+
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        """
+        Returns true if both objects are not equal
+        """
+        return not self == other