aspose-cells · February 28, 2017 11:41
diff --git a/AddChartToWorksheet.py b/AddChartToWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartType = "bar"
 upperLeftRow = 12
 upperLeftColumn = 12
 lowerRightRow = 20
 lowerRightColumn = 20
 area = "A1:A3"
 isVertical = False
 isAutoGetSerialName = True
 title = "SalesState"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to add a chart in a worksheet
    response = cellsApi.PutWorksheetAddChart(name=filename, sheetName=sheetName, chartType=chartType, upperLeftRow=upperLeftRow, upperLeftColumn=upperLeftColumn, lowerRightColumn=lowerRightColumn, area=area, isVertical=isVertical, isAutoGetSerialName=isAutoGetSerialName, title=title)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/AddEmptyRowInWorkSheet.py b/AddEmptyRowInWorkSheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 rowIndex = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to add an empty row in a worksheet
    response = cellsApi.PutInsertWorksheetRow(name=filename, sheetName=sheetName, rowIndex=rowIndex)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/AddHyperlinksFromExcelWorksheet.py b/AddHyperlinksFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 firstRow = 2
 firstColumn = 2
 totalRows = 2
 totalColumns = 2
 address = "http://www.aspose.com/cloud/total-api.aspx"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)


 try:
    #invoke Aspose.Cells Cloud SDK API to add a hyperlink to a worksheet
    response = cellsApi.PutWorkSheetHyperlink(name=filename, sheetName=sheetName, firstRow=firstRow, firstColumn=firstColumn, totalRows=totalRows, totalColumns=totalColumns, address=address)

    if response.Status == "OK":
        hyperlink = response.Hyperlink
        print "Hyperlink Address : " + hyperlink.Address
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/AddNewExcelWorksheet.py b/AddNewExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1-new"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to add a new worksheet in a workbook
    response = cellsApi.PutAddNewWorksheet(name=filename, sheetName=sheetName)

    if response.Status == "Created":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/AddOLEObjectsToExcelWorksheet.py b/AddOLEObjectsToExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import OleObject

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 sourceFileName = "Sample_Book2.xls"

 imageFileName = "aspose-logo.png"
 height = 200
 width = 200
 oleFile = sourceFileName
 imageFile = imageFileName

 body  = OleObject.OleObject()
 body.SourceFullName = sourceFileName
 body.ImageSourceFullName = imageFileName
 body.UpperLeftRow = 15
 body.UpperLeftColumn = 5
 body.Top = 10
 body.Bottom = 10
 body.Left = 10
 body.Height = 200
 body.Width = 200
 body.IsAutoSize = True

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)
 storageApi.PutCreate(Path=sourceFileName, file=data_folder + sourceFileName)
 storageApi.PutCreate(Path=imageFileName, file=data_folder + imageFileName)


 try:
    #invoke Aspose.Cells Cloud SDK API to add an OleObject to a worksheet
    response = cellsApi.PutWorksheetOleObject(name=filename, sheetName=sheetName, body=body, imageFile=imageFile,oleFile=oleFile,height=height,width=width)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/AddPictureToExcelWorksheet.py b/AddPictureToExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 upperLeftRow = 5
 upperLeftColumn = 5
 lowerRightRow = 10
 lowerRightColumn = 10
 picturePath = "aspose-cloud.png"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)
 storageApi.PutCreate(Path=picturePath, file=data_folder + picturePath)


 try:
    #invoke Aspose.Cells Cloud SDK API to add a picture to a worksheet
    response = cellsApi.PutWorksheetAddPicture(name=filename, sheetName=sheetName, file=None, picturePath=picturePath, upperLeftRow=upperLeftRow, upperLeftColumn=upperLeftColumn,lowerRightRow=lowerRightRow, lowerRightColumn=lowerRightColumn )

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/AddPivotFieldInPivotTable.py b/AddPivotFieldInPivotTable.py
 mport asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import PivotTableFieldRequest

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Pivot_Table_Example.xls"
 sheetName = "Sheet2"
 pivotTableIndex = 0
 pivotFieldType = "Row"

 body = PivotTableFieldRequest.PivotTableFieldRequest()
 body.Data = [1,2]

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to add pivot field into pivot table
    response = cellsApi.PutPivotTableField(name=filename, sheetName=sheetName, pivotTableIndex=pivotTableIndex, pivotFieldType=pivotFieldType, body=body)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/AddPivotTableInw b/AddPivotTableInw
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import CreatePivotTableRequest

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"

 body = CreatePivotTableRequest.CreatePivotTableRequest()
 body.Name = "MyPivot"
 body.SourceData = "A5:E10"
 body.DestCellName ="H20"
 body.UseSameSource = True
 body.PivotFieldRows = [1]
 body.PivotFieldColumns = [1]
 body.PivotFieldData = [1]

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to add a pivot table in a worksheet
    response = cellsApi.PutWorksheetPivotTable(name=filename, sheetName=sheetName, body=body)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message

diff --git a/AddPivotTableInWorkSheet.py b/AddPivotTableInWorkSheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import CreatePivotTableRequest

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"

 body = CreatePivotTableRequest.CreatePivotTableRequest()
 body.Name = "MyPivot"
 body.SourceData = "A5:E10"
 body.DestCellName ="H20"
 body.UseSameSource = True
 body.PivotFieldRows = [1]
 body.PivotFieldColumns = [1]
 body.PivotFieldData = [1]

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to add a pivot table in a worksheet
    response = cellsApi.PutWorksheetPivotTable(name=filename, sheetName=sheetName, body=body)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/AutoFitRowsInExcelWorksheet.py b/AutoFitRowsInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to automatically fit rows height and width
    response = cellsApi.GetWorkBook(name=filename, isAutoFit=True)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/CalculateFormulaInWorksheet.py b/CalculateFormulaInWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 formula = "SUM(A5:A10)"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to calculate formula in a worksheet
    response = cellsApi.GetWorkSheetCalculateFormula(name=filename, sheetName=sheetName, formula=formula)

    if response.Status == "OK":
        print "Result :: " + str(response.Value.Value)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ClearCellFormattingInExcelWorksheet.py b/ClearCellFormattingInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 range = "A1:A12"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to clear cells formatting in a worksheet
    response = cellsApi.PostClearFormats(name=filename, sheetName=sheetName, range=range)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ClearContentsFromExcelWorkSheet.py b/ClearContentsFromExcelWorkSheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 startRow = 1
 startColumn = 1
 endRow = 2
 endColumn = 2

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to clear contents and styles of selected cells in a worksheet
    response = cellsApi.PostClearContents(name=filename, sheetName=sheetName, startRow=startRow, startColumn=startColumn, endRow=endRow, endColumn=endColumn)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ClearModifyPassword.py b/ClearModifyPassword.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "password_protected_Sample_Test_Book.xls"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to clear modify password of a workbook
    response = cellsApi.DeleteDocumentUnProtectFromChanges(name=filename)

    if response.Status == "OK":
        print "Workbook password has been cleared successfully"
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + "cleared_" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ConvertAutoShapeToImage.py b/ConvertAutoShapeToImage.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 name = "Sample_Test_Book"
 filename = name + ".xls"
 sheetName = "Sheet4"
 autoshapeNumber = 1
 format = "png"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to convert an autoshape to image
    response = cellsApi.GetWorksheetAutoshapeWithFormat(name=filename, sheetName=sheetName, autoshapeNumber=autoshapeNumber, format=format)

    if response.Status == "OK":
        #download image from response stream
        outfilename = "c:/temp/" +  name + str(autoshapeNumber) + "." + format
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ConvertChartToImage.py b/ConvertChartToImage.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 name = "Sample_Test_Book"
 filename = name + ".xls"
 sheetName = "Sheet5"
 chartNumber = 0
 format = "png"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to convert a chart to image
    response = cellsApi.GetWorksheetChartWithFormat(name=filename, sheetName=sheetName, chartNumber=chartNumber, format=format)

    if response.Status == "OK":
        #download image from response stream
        outfilename = "c:/temp/" +  name + str(chartNumber) + "." + format
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ConvertExcelToVariousFormats.py b/ConvertExcelToVariousFormats.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import SaveOptions

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 name = "Sample_Test_Book"
 filename = name + ".xls"
 format = "pdf"
 outputfilename = name + "." + format

 body = SaveOptions.SaveOptions()

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to convert workbook to different file formats using cloud storage
    response = cellsApi.PostDocumentSaveAs(name=filename, body=body, newfilename=outputfilename)

    if response.Status == "OK":

        destfilename = response.SaveResult.DestDocument.Href
        print "FileName: " + destfilename
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=destfilename)
        outfilename = "c:/temp/" +  destfilename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ConvertExcelToVariousFormatsWithoutStorage.py b/ConvertExcelToVariousFormatsWithoutStorage.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import SaveOptions

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 name = "Sample_Test_Book"
 filename = name + ".xls"
 format = "pdf"
 outputfilename = name + "." + format

 try:
    #invoke Aspose.Cells Cloud SDK API to convert workbook to different file formats without storage
    response = cellsApi.PutConvertWorkBook(file=data_folder + filename, data=data_folder + "Sample_SaveOption_Data.xml", format=format)

    if response.Status == "OK":
        #download Workbook from response stream
        outfilename = "c:/temp/" +  outputfilename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ConvertExcelWorkbookWithAdditionalSettings.py b/ConvertExcelWorkbookWithAdditionalSettings.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import SaveOptions

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 name = "Sample_Test_Book"
 filename = name + ".xls"
 format = "pdf"
 outputfilename = name + "." + format

 body = SaveOptions.SaveOptions()

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to convert workbook to different file formats using cloud storage
    response = cellsApi.PostDocumentSaveAs(name=filename, body=body, newfilename=outputfilename)

    if response.Status == "OK":

        destfilename = response.SaveResult.DestDocument.Href
        print "FileName: " + destfilename
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=destfilename)
        outfilename = "c:/temp/" +  destfilename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ConvertOLEObjectToImage.py b/ConvertOLEObjectToImage.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 name = "Sample_OleObject_Book1"
 filename = name + ".xlsx"
 sheetName = "Sheet1"
 objectNumber = 0
 format = "png"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to convert an OLE object to image
    response = cellsApi.GetWorksheetOleObjectWithFormat(name=filename, sheetName=sheetName, objectNumber=objectNumber, format=format)

    if response.Status == "OK":
        #get converted image from response stream
        outfilename = "c:/temp/" +  name + str(objectNumber) + "." +  format
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ConvertPictureToImage.py b/ConvertPictureToImage.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 name = "Sample_Test_Book"
 filename = name + ".xls"
 sheetName = "Sheet6"
 pictureNumber = 0
 format = "png"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to convert a picture to image
    response = cellsApi.GetWorksheetPictureWithFormat(name=filename, sheetName=sheetName, pictureNumber=pictureNumber, format=format)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ConvertWorkSheetToImage.py b/ConvertWorkSheetToImage.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 name = "Sample_Test_Book"
 filename = name + ".xls"
 sheetName = "Sheet1"
 format = "png"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to add a new worksheet in a workbook
    response = cellsApi.GetWorkSheetWithFormat(name=filename, sheetName=sheetName, format=format)

    if response.Status == "OK":
        #download converted document from response stream
        outfilename = "c:/temp/" + name + "." + format
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/CopyExcelWorksheet.py b/CopyExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet7"
 sourceSheet = "Sheet1"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to copy a worksheet
    response = cellsApi.PostCopyWorksheet(name=filename, sheetName=sheetName, sourceSheet=sourceSheet)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/CopyRowsInExcelWorksheet.py b/CopyRowsInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 sourceRowIndex = 1
 destinationRowIndex = 1
 rowNumber = 1
 worksheet = "Sheet1"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to copy selected rows in a worksheet
    response = cellsApi.PostCopyWorksheetRows(name=filename, sheetName=sheetName, sourceRowIndex=sourceRowIndex, destinationRowIndex=destinationRowIndex, rowNumber=rowNumber, worksheet=worksheet)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/CreateEmptyExcelWorkbook.py b/CreateEmptyExcelWorkbook.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import CellsDocumentPropertiesResponse

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi
 from asposestoragecloud.StorageApi import ResponseMessage
 from pip._vendor.pkg_resources import null_ns_handler

 import random
 import string

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(8))
 filename = filename + ".xlsx"

 try:
    #invoke Aspose.Cells Cloud SDK API to create an empty workbook
    response = cellsApi.PutWorkbookCreate(name=filename, file=None)

    if response.Status == "OK":
        print "EmptyWorkbook has been creeated successfully"
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/CreateExcelWorkbookFromSmartMarkerTemplate.py b/CreateExcelWorkbookFromSmartMarkerTemplate.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import SaveOptions

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 import random
 import string

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(8)) + ".xls"

 #The template file, if the data not provided default workbook is created.
 templatefile = "Sample_SmartMarker.xlsx"

 #Smart marker data file, if the data not provided the request content is checked for the data.
 datafile = "Sample_SmartMarker_Data.xml"

 #upload SmartMarker template file to aspose cloud storage
 storageApi.PutCreate(Path=templatefile, file=data_folder + templatefile)

 #upload SmartMarker template data file to aspose cloud storage
 storageApi.PutCreate(Path=datafile, file=data_folder + datafile)

 try:
    #invoke Aspose.Cells Cloud SDK API to create a workbook from a SmartMarker template
    response = cellsApi.PutWorkbookCreate(name=filename, file=None, templateFile=templatefile, dataFile=datafile)

    if response.Status == "OK":

        outputfilename = response.Workbook.FileName
        print "FileName: " + outputfilename
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=outputfilename)
        outfilename = "c:/temp/" +  outputfilename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/CreateExcelWorkbookFromTempateFile.py b/CreateExcelWorkbookFromTempateFile.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import SaveOptions

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 import random
 import string

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(8)) + ".xls"

 #The template file, if the data not provided default workbook is created.
 templatefile = "Sample_Test_Book.xls"

 #upload template file to aspose cloud storage
 storageApi.PutCreate(Path=templatefile, file=data_folder + templatefile)

 try:
    #invoke Aspose.Cells Cloud SDK API to create a workbook from a template file
    response = cellsApi.PutWorkbookCreate(name=filename, file=None, templateFile=templatefile)

    if response.Status == "OK":

        outputfilename = response.Workbook.FileName
        print "FileName: " + outputfilename
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=outputfilename)
        outfilename = "c:/temp/" +  outputfilename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DecryptExcelWorkbooks.py b/DecryptExcelWorkbooks.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import WorkbookEncryptionRequest

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filePrefix = "encrypted_"
 filename = filePrefix + "Sample_Test_Book.xls"

 body = WorkbookEncryptionRequest.WorkbookEncryptionRequest()
 body.EncryptionType = "XOR"
 body.Password = "aspose"
 body.KeyLength = 128

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to decrypt a workbook
    response = cellsApi.DeleteDecryptDocument(name=filename, body=body)

    if response.Status == "OK":

        #download encrypted document from cloud storage
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" +  filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DeleteAllChartsFromAWorksheet.py b/DeleteAllChartsFromAWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to delete all charts from a worksheet
    response = cellsApi.DeleteWorksheetClearCharts(name=filename, sheetName=sheetName)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DeleteAllObjectsFromExcelWorksheet.py b/DeleteAllObjectsFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Embeded_OleObject_Sample_Book1.xlsx"
 sheetName = "Sheet1"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to delete all OleObjects from a worksheet
    response = cellsApi.DeleteWorksheetOleObjects(name=filename, sheetName=sheetName)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/"  + "Deleted_" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DeleteAllPicturesFromExcelWorksheet.py b/DeleteAllPicturesFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet6"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to delete all pictures from a worksheet
    response = cellsApi.DeleteWorkSheetPictures(name=filename, sheetName=sheetName)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DeleteBackground.py b/DeleteBackground.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "WorkSheetBackground_Sample_Test_Book.xls"
 sheetName = "Sheet1"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to delete background image or watermark image for a worksheet
    response = cellsApi.DeleteWorkSheetBackground(name=filename, sheetName=sheetName)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DeleteChartExcelWorksheet.py b/DeleteChartExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to delete chart title of a chart
    response = cellsApi.DeleteWorksheetChartTitle(name=filename, sheetName=sheetName, chartIndex=chartIndex)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DeleteChartFromWorkSheet.py b/DeleteChartFromWorkSheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to delete a chart from a worksheet
    response = cellsApi.DeleteWorksheetDeleteChart(name=filename, sheetName=sheetName, chartIndex=chartIndex)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message

diff --git a/DeleteHyperlinksFromExcelWorksheet.py b/DeleteHyperlinksFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 hyperlinkIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)


 try:
    #invoke Aspose.Cells Cloud SDK API to delete a hyperlink from a worksheet
    response = cellsApi.DeleteWorkSheetHyperlink(name=filename, sheetName=sheetName, hyperlinkIndex=hyperlinkIndex)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DeleteRowsFromWorkSheet.py b/DeleteRowsFromWorkSheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 rowIndex = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to delete a row from a worksheet
    response = cellsApi.DeleteWorksheetRow(name=filename, sheetName=sheetName, rowIndex=rowIndex)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DeleteSpecificPictureFromExcelWorksheet.py b/DeleteSpecificPictureFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet6"
 pictureIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to delete a specific picture from a worksheet
    response = cellsApi.DeleteWorksheetPicture(name=filename, sheetName=sheetName, pictureIndex=pictureIndex)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DeleteWorksheetPivotTables.py b/DeleteWorksheetPivotTables.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Pivot_Table_Example.xls"
 sheetName = "Sheet2"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to delete worksheet pivot tables
    response = cellsApi.DeleteWorksheetPivotTables(name=filename, sheetName=sheetName)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DeleteWorksheetPivotTablesByIndex.py b/DeleteWorksheetPivotTablesByIndex.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Pivot_Table_Example.xls"
 sheetName = "Sheet2"
 pivotTableIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to delete worksheet pivot table by index
    response = cellsApi.DeleteWorksheetPivotTable(name=filename, sheetName=sheetName, pivotTableIndex=pivotTableIndex)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/DelteSpecificObjectFromOLEWorksheet.py b/DelteSpecificObjectFromOLEWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Embeded_OleObject_Sample_Book1.xlsx"
 sheetName = "Sheet1"
 oleObjectIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to delete a specific OleObject from a worksheet
    response = cellsApi.DeleteWorksheetOleObject(name=filename, sheetName=sheetName, oleObjectIndex=oleObjectIndex)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/"  + "Deleted_" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/example.py b/example.py
 sample.py
diff --git a/FindTextInWorkbook.py b/FindTextInWorkbook.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 text = "aspose"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to find text in a workbook
    response = cellsApi.PostWorkbooksTextSearch(name=filename, text=text)

    if response.Status == "OK":
        for item in response.TextItems.TextItemList:
            print "Text: " + item.Text
            print "Href: " + item.link.Href
            print "--"

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/FindTextInWorksheet.py b/FindTextInWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 text = "aspose"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to find text in a worksheet
    response = cellsApi.PostWorkSheetTextSearch(name=filename, sheetName=sheetName, text=text)

    if response.Status == "OK":
        for item in response.TextItems.TextItemList:
            print "Text: " + item.Text
            print "Href: " + item.link.Href
            print "--"

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetAllDocumentProperties.py b/GetAllDocumentProperties.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Book1.xlsx"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)


 try:
    #invoke Aspose.Cells Cloud SDK API to get all document properties of a workbook
    response = cellsApi.GetDocumentProperties(name=filename)

    if response.Status == "OK":
        for docProperty in response.DocumentProperties.DocumentPropertyList:
            print "Name: " + docProperty.Name
            print "Value: " + docProperty.Value
            print "BuiltIn: " + docProperty.BuiltIn
            print "--"
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetAutoshapeFromWorksheet.py b/GetAutoshapeFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.CellsApi import AutoShapesResponse

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet4"
 autoshapeNumber = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get autoshape from a worksheet
    response = cellsApi.GetWorksheetAutoshape(name=filename, sheetName=sheetName, autoshapeNumber=autoshapeNumber)

    if response.Status == "OK":
        autoShape = response.AutoShape
        print autoShape.HtmlText


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetCellFromWorksheet.py b/GetCellFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellOrMethodName = "a1"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get a specific cell from a worksheet
    response = cellsApi.GetWorksheetCell(name=filename, sheetName=sheetName, cellOrMethodName=cellOrMethodName)
    if response.Status == "OK":
        cell = response.Cell
        print "Cell Name :: " + cell.Name
        print "Cell Value :: " + cell.Value

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetCellStyleFromWorksheet.py b/GetCellStyleFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 cellName = "a1"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get cell style from a worksheet
    response = cellsApi.GetWorksheetCellStyle(name=filename, sheetName=sheetName, cellName=cellName)

    if response.Status == "OK":
        cellStyle = response.Style
        print "Cell Font Name :: " + cellStyle.Font.Name
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetChartAreaFromWorksheet.py b/GetChartAreaFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get the chart area of a chart from a worksheet
    response = cellsApi.GetChartArea(name=filename, sheetName=sheetName, chartIndex=chartIndex)

    if response.Status == "OK":
        chartArea = response.ChartArea
        print "ChatArea X :: " + str(chartArea.X)
        print "ChatArea Y :: " + str(chartArea.Y)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetChartFromWorksheet.py b/GetChartFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartNumber = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get a specific chart from a worksheet
    response = cellsApi.GetWorksheetChart(name=filename, sheetName=sheetName, chartNumber=chartNumber)

    if response.Status == "OK":
        chart = response.Chart
        print "Chat Type :: " + chart.Type
        print "Chat Name :: " + chart.Name

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetChartLegendFromWorksheet.py b/GetChartLegendFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #/invoke Aspose.Cells Cloud SDK API to get information of a chart legend of a chart
    response = cellsApi.GetWorksheetChartLegend(name=filename, sheetName=sheetName, chartIndex=chartIndex)

    if response.Status == "OK":
        chartLegendInfo = response.Legend
        print "Chart Legend Position :: " + chartLegendInfo.Position

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetColumnFromWorksheet.py b/GetColumnFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 columnIndex = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get a specific column from a worksheet
    response = cellsApi.GetWorksheetColumn(name=filename, sheetName=sheetName, columnIndex=columnIndex)

    if response.Status == "OK":
        sheetColumn = response.Column
        print "Href :: " + sheetColumn.link.Href


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetCommentFromWorksheet.py b/GetCommentFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 columnIndex = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get a specific column from a worksheet
    response = cellsApi.GetWorksheetColumn(name=filename, sheetName=sheetName, columnIndex=columnIndex)

    if response.Status == "OK":
        sheetColumn = response.Column
        print "Href :: " + sheetColumn.link.Href


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetFillFormatOfChartAreaFromWorksheet.py b/GetFillFormatOfChartAreaFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get fill format of a chart area from a worksheet
    response = cellsApi.GetChartAreaFillFormat(name=filename, sheetName=sheetName, chartIndex=chartIndex)

    if response.Status == "OK":
        chartAreaFillFormat = response.FillFormat
        print "ChatArea FillFormat Type :: " + chartAreaFillFormat.Type


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetFirstCellFromExcelWorksheet.py b/GetFirstCellFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellOrMethodName = "firstcell"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get first cell of a worksheet
    response = cellsApi.GetWorksheetCell(name=filename, sheetName=sheetName, cellOrMethodName=cellOrMethodName)
    if response.Status == "OK":
        cell = response.Cell
        print "Cell Name :: " + cell.Name
        print "Cell Value :: " + cell.Value

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetHyperlinkFromExcelWorksheet.py b/GetHyperlinkFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 hyperlinkIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)


 try:
    #invoke Aspose.Cells Cloud SDK API to get a specific hyperlink from a worksheet
    response = cellsApi.GetWorkSheetHyperlink(name=filename, sheetName=sheetName, hyperlinkIndex=hyperlinkIndex)

    if response.Status == "OK":
        hyperlink = response.Hyperlink
        print "Hyperlink Address : " + hyperlink.Address

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetLastCellOfExcelWorksheet.py b/GetLastCellOfExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellOrMethodName = "endcell"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get last cell of a worksheet
    response = cellsApi.GetWorksheetCell(name=filename, sheetName=sheetName, cellOrMethodName=cellOrMethodName)
    if response.Status == "OK":
        cell = response.Cell
        print "Cell Name :: " + cell.Name
        print "Cell Value :: " + cell.Value

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetMaxColumnFromExcelWorksheet.py b/GetMaxColumnFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellOrMethodName = "maxcolumn"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get index of last column which contains data or style in a worksheet
    response = cellsApi.GetWorksheetCellProperty(name=filename, sheetName=sheetName, cellOrMethodName=cellOrMethodName)
    print "MaxColumn :: " + str(response)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetMaxDataColumnFromExcelWorksheet.py b/GetMaxDataColumnFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellOrMethodName = "maxdatacolumn"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get index of last column which contains data in a worksheet
    response = cellsApi.GetWorksheetCellProperty(name=filename, sheetName=sheetName, cellOrMethodName=cellOrMethodName)
    print "MaxDataColumn :: " + str(response)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetMaxDataRowFromExcelWorksheet.py b/GetMaxDataRowFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellOrMethodName = "maxdatarow"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get index of last row which contains data in a worksheet
    response = cellsApi.GetWorksheetCellProperty(name=filename, sheetName=sheetName, cellOrMethodName=cellOrMethodName)
    print "MaxDataRow :: " + str(response)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetMaxRowFromExcelWorksheet.py b/GetMaxRowFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellOrMethodName = "maxrow"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get index of last row which contains data or style in a worksheet
    response = cellsApi.GetWorksheetCellProperty(name=filename, sheetName=sheetName, cellOrMethodName=cellOrMethodName)
    print "MaxRow :: " + str(response)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetMergedCellFromWorksheet.py b/GetMergedCellFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 mergedCellIndex = 0

 #upload file to aspose cloud storage
 #storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get merged cells from a worksheet
    response = cellsApi.GetWorkSheetMergedCell(name=filename, sheetName=sheetName, mergedCellIndex=mergedCellIndex)

    if response.Status == "OK":
        mergedCell = response.MergedCell
        print "Merge Start Column :: " + str(mergedCell.StartColumn)
        print "Merge End Column :: " + str(mergedCell.EndColumn)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetMinColumnFromExcelWorksheet.py b/GetMinColumnFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellOrMethodName = "mincolumn"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get index of first column which contains data or style in a worksheet
    response = cellsApi.GetWorksheetCellProperty(name=filename, sheetName=sheetName, cellOrMethodName=cellOrMethodName)
    print "mincolumn :: " + str(response)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetMinDataColumnFromExcelWorksheet.py b/GetMinDataColumnFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellOrMethodName = "mindatacolumn"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get index of first column which contains data in a worksheet
    response = cellsApi.GetWorksheetCellProperty(name=filename, sheetName=sheetName, cellOrMethodName=cellOrMethodName)
    print "MinColumn :: " + str(response)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetMinDataRowFromExcelWorksheet.py b/GetMinDataRowFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellOrMethodName = "mindatarow"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get index of first row which contains data in a worksheet
    response = cellsApi.GetWorksheetCellProperty(name=filename, sheetName=sheetName, cellOrMethodName=cellOrMethodName)
    print "MinDataRow :: " + str(response)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetMinRowFromExcelWorksheet.py b/GetMinRowFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellOrMethodName = "maxrow"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get index of last row which contains data or style in a worksheet
    response = cellsApi.GetWorksheetCellProperty(name=filename, sheetName=sheetName, cellOrMethodName=cellOrMethodName)
    print "MaxRow :: " + str(response)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetNamesCountFromExcelWorkbook.py b/GetNamesCountFromExcelWorkbook.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get names count from a workbook
    response = cellsApi.GetWorkBookNames(name=filename)

    if response.Status == "OK":
        print "Total Workbook Count : " + str(response.Names.Count)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetOLEObjectFromWorksheet.py b/GetOLEObjectFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Embeded_OleObject_Sample_Book1.xlsx"
 sheetName = "Sheet1"
 oleObjectIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get a specific oleobject from a worksheet
    response = cellsApi.GetWorksheetOleObject(name=filename, sheetName=sheetName, objectNumber=oleObjectIndex)

    if response.Status == "OK":
        oleObject = response.OleObject
        print "OleObject File Format Type :: " + oleObject.FileFormatType
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetParticularDocumentProperty.py b/GetParticularDocumentProperty.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Book1.xlsx"
 propertyName = "Author"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)


 try:
    #invoke Aspose.Cells Cloud SDK API to get a particular document property
    response = cellsApi.GetDocumentProperty(name=filename, propertyName=propertyName)

    if response.Status == "OK":
        docProperty = response.DocumentProperty
        print "Name: " + docProperty.Name
        print "Value: " + docProperty.Value
        print "BuiltIn: " + docProperty.BuiltIn

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetPictureFromExcelWorksheet.py b/GetPictureFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet6"
 pictureNumber = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get a specific picture from a worksheet
    response = cellsApi.GetWorksheetPicture(name=filename, sheetName=sheetName, pictureNumber=pictureNumber)

    if response.Status == "OK":
        picture = response.Picture
        print "Picture Image Format : " + picture.ImageFormat

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetRowFromWorkSheet.py b/GetRowFromWorkSheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 rowIndex = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get a specific row from a worksheet
    response = cellsApi.GetWorksheetRow(name=filename, sheetName=sheetName, rowIndex=rowIndex)

    if response.Status == "OK":
        print "Row Href : " + response.Row.link.Href

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetRowFromWorksheet.py b/GetRowFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 rowIndex = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get a specific row from a worksheet
    response = cellsApi.GetWorksheetRow(name=filename, sheetName=sheetName, rowIndex=rowIndex)

    if response.Status == "OK":
        print "Row Href : " + response.Row.link.Href

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetTextItemsFromWorkbook.py b/GetTextItemsFromWorkbook.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get all text items from a workbook
    response = cellsApi.GetWorkBookTextItems(name=filename)

    if response.Status == "OK":
        for item in response.TextItems.TextItemList:
            print "Text: " + item.Text
            print "Href: " + item.link.Href
            print "--"

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetTextITemsFromWorkSheet.py b/GetTextITemsFromWorkSheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get all text items from a worksheet
    response = cellsApi.GetWorkSheetTextItems(name=filename, sheetName=sheetName)

    if response.Status == "OK":
        for item in response.TextItems.TextItemList:
            print "Text: " + item.Text
            print "Href: " + item.link.Href
            print "--"

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetValidationFromWorksheet.py b/GetValidationFromWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 validationIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get validation from a worksheet
    response = cellsApi.GetWorkSheetValidation(name=filename, sheetName=sheetName, validationIndex=validationIndex)

    if response.Status == "OK":
        sheetValidation = response.Validation
        print "Sheet Validation Type :: " + sheetValidation.Type

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetWorksheetCount.py b/GetWorksheetCount.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get worksheet count
    response = cellsApi.GetWorkSheets(name=filename)

    if response.Status == "OK":
        print "Sheet Count :: " + str(len(response.Worksheets.WorksheetList))

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GetWorksheetPivotTablesInformation.py b/GetWorksheetPivotTablesInformation.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Pivot_Table_Example.xls"
 sheetName = "Sheet2"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get worksheet pivot tables information
    response = cellsApi.GetWorksheetPivotTables(name=filename, sheetName=sheetName)

    if response.Status == "OK":
        pivotTables = response.PivotTables

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message

diff --git a/GetWorksheetPivotTablesInformationByIndex.py b/GetWorksheetPivotTablesInformationByIndex.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "EastNorthCentralFTWorkers.xls"
 sheetName = "Tables"
 pivottableIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to get worksheet pivot table information by index
    response = cellsApi.GetWorksheetPivotTable(name=filename, sheetName=sheetName, pivottableIndex=pivottableIndex)

    if response.Status == "OK":
        pivotTable = response.PivotTable
        print "Name :: " + pivotTable.Name
        for item in pivotTable.ColumnFields[0].Items:
         print "item :: " +  item

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/GroupRowsInExcelWorksheet.py b/GroupRowsInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 firstIndex = 1
 lastIndex = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to group selected rows in a worksheet
    response = cellsApi.PostGroupWorksheetRows(name=filename, sheetName=sheetName, firstIndex=firstIndex, lastIndex=lastIndex,hide=False )

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/HideChartLegendInWorkSheet.py b/HideChartLegendInWorkSheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to hide chart legend of a chart
    response = cellsApi.DeleteWorksheetChartLegend(name=filename, sheetName=sheetName, chartIndex=chartIndex)

    if response.Status == "OK":
        #download updated workbook from cloud storage
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/HideExcelWorkSheets.py b/HideExcelWorkSheets.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 isVisible = False

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to hide a worksheet in a workbook
    response = cellsApi.PutChangeVisibilityWorksheet(name=filename, sheetName=sheetName, isVisible=isVisible)

    if response.Status == "OK":
        print "Visibility Type: " + response.Worksheet.VisibilityType
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" +  filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/HideRowsInExcelWorksheet.py b/HideRowsInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 startrow = 1
 totalRows = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to hide selected rows in a worksheet
    response = cellsApi.PostHideWorksheetRows(name=filename, sheetName=sheetName, startrow=startrow, totalRows=totalRows)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/MergeCellsInExcelWorksheet.py b/MergeCellsInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 startRow = 1
 startColumn = 1
 totalRows = 1
 totalColumns = 5

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to merge selected cells in a worksheet
    response = cellsApi.PostWorksheetMerge(name=filename, sheetName=sheetName, startRow=startRow, startColumn=startColumn, totalRows=totalRows, totalColumns=totalColumns)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/MergeExcelWorkbooks.py b/MergeExcelWorkbooks.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Book1.xlsx"
 mergeWith = "Sample_Book2.xls"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)
 #upload mergeWith file to aspose cloud storage
 storageApi.PutCreate(Path=mergeWith, file=data_folder + mergeWith)

 try:
    #invoke Aspose.Cells Cloud SDK API to merge multiple workbooks into a single workbook
    response = cellsApi.PostWorkbooksMerge(name=filename, mergeWith=mergeWith)

    if response.Status == "OK":
        destFileName = response.Workbook.FileName
        print "FileName " + destFileName
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=destFileName)
        outfilename = "c:/temp/" + destFileName
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/MoveExcelWorksheets.py b/MoveExcelWorksheets.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import WorksheetMovingRequest

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"

 body = WorksheetMovingRequest.WorksheetMovingRequest()
 body.DestinationWorksheet = "Sheet5"
 body.Position = "after"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to  a new location in a workbook
    response = cellsApi.PostMoveWorksheet(name=filename, sheetName=sheetName, body=body)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" +  filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ProtectExcelWorkbooks.py b/ProtectExcelWorkbooks.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import WorkbookProtectionRequest

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"

 body = WorkbookProtectionRequest.WorkbookProtectionRequest()
 body.Password = "aspose"
 body.ProtectionType = "All"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to protect a workbook
    response = cellsApi.PostProtectDocument(name=filename, body=body)

    if response.Status == "OK":
        #download protected document from cloud storage
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/RemoveAllDocumentProperties.py b/RemoveAllDocumentProperties.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Book1.xlsx"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)


 try:
    #invoke Aspose.Cells Cloud SDK API to remove all document properties
    response = cellsApi.DeleteDocumentProperties(name=filename)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/RemoveParticularDocumentProperty.py b/RemoveParticularDocumentProperty.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Book1.xlsx"
 propertyName = "AsposeAuthor"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)


 try:
    #invoke Aspose.Cells Cloud SDK API to remove a particular document property
    response = cellsApi.DeleteDocumentProperty(name=filename, propertyName=propertyName)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/RemoveWorksheetFromWorkbook.py b/RemoveWorksheetFromWorkbook.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to remove a worksheet from a workbook
    response = cellsApi.DeleteWorksheet(name=filename, sheetName=sheetName)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" +  filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/RenameExcelWorksheet.py b/RenameExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 newname = "newSheet"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to rename a worksheet
    response = cellsApi.PostRenameWorksheet(name=filename, sheetName=sheetName, newname=newname)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" +  filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ReplaceTextInWorkbook.py b/ReplaceTextInWorkbook.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 oldValue = "aspose"
 newValue = "aspose.com"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to replace text in a workbook
    response = cellsApi.PostWorkbooksTextReplace(name=filename, oldValue=oldValue, newValue=newValue)

    if response.Status == "OK":
        print "Matches: " + str(response.Matches)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ReplaceTextInWorksheet.py b/ReplaceTextInWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName="Sheet2"
 oldValue = "aspose"
 newValue = "aspose.com"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to replace text in a worksheet
    response = cellsApi.PostWorsheetTextReplace(name=filename, sheetName=sheetName, oldValue=oldValue, newValue=newValue)

    if response.Status == "OK":
        print "Matches: " + str(response.Matches)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/SetAllDocumentProperties.py b/SetAllDocumentProperties.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Book1.xlsx"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)


 try:
    #invoke Aspose.Cells Cloud SDK API to remove all document properties
    response = cellsApi.DeleteDocumentProperties(name=filename)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/SetBackgroundOrWatermark.py b/SetBackgroundOrWatermark.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 imgname = "aspose-cloud.png"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to set a background image or watermark image for a worksheet
    response = cellsApi.PutWorkSheetBackground(name=filename, sheetName=sheetName, file=data_folder + imgname)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" +  filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/SetCellStyleInExcelWorksheet.py b/SetCellStyleInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import Style
 from asposecellscloud.models import Font

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 cellName = "A2"

 body = Style.Style()

 font = Font.Font()
 font.Name = "Calibri"
 font.Size = 40
 body.Font = font

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to set the styles of selected cells in a worksheet
    response = cellsApi.PostUpdateWorksheetCellStyle(name=filename, sheetName=sheetName, cellName=cellName, body=body)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/SetChartTitle.py b/SetChartTitle.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import Title

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartIndex = 0

 body = Title.Title()
 body.Text = "Aspose"
 body.Height = 15

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to add title to a chart
    response = cellsApi.PutWorksheetChartTitle(name=filename, sheetName=sheetName, chartIndex=chartIndex, body=body)

    if response.Status == "OK":
        #download updated workbook from cloud storage
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/SetFormulaOfACellInWorksheet.py b/SetFormulaOfACellInWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 cellName = "a12"
 type = "int"
 formula = "sum(a5:a10)"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to set formula for a cell in a worksheet
    response = cellsApi.PostWorksheetCellSetValue(name=filename, sheetName=sheetName, cellName=cellName, type=type, formula=formula)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/SetModifyPassword.py b/SetModifyPassword.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import PasswordRequest

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"

 body = PasswordRequest.PasswordRequest()
 body.Password = "aspose"


 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to set modify password of a workbook
    response = cellsApi.PutDocumentProtectFromChanges(name=filename, body=body)

    if response.Status == "OK":
        #download protected document from cloud storage
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + "password_protected_" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/SetParticularDocumentProperties.py b/SetParticularDocumentProperties.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import CellsDocumentProperty

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Book1.xlsx"
 propertyName = "AsposeAuthor"

 body = CellsDocumentProperty.CellsDocumentProperty()
 body.Name ="AsposeAuthor"
 body.Value ="Aspose Plugin Developer"
 body.BuiltIn = False

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)


 try:
    #invoke Aspose.Cells Cloud SDK API to set a particular document property
    response = cellsApi.PutDocumentProperty(name=filename, propertyName=propertyName, body=body)

    if response.Status == "Created":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/SetRangeValueInExcelWorksheet.py b/SetRangeValueInExcelWorksheet.py
 import asposecellscloudimport asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 cellarea = "A10:B20"
 value = "1234"
 type = "int"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to set value for selected range in a worksheet
    response = cellsApi.PostSetCellRangeValue(name=filename, sheetName=sheetName, cellarea=cellarea, type=type, value=value)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message

 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 cellarea = "A10:B20"
 value = "1234"
 type = "int"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to set value for selected range in a worksheet
    response = cellsApi.PostSetCellRangeValue(name=filename, sheetName=sheetName, cellarea=cellarea, type=type, value=value)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/SetValueOfaCellInWorksheet.py b/SetValueOfaCellInWorksheet.py
 mport asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 cellName = "a1"
 value = "99"
 type = "int"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to set value of a cell in a worksheet
    response = cellsApi.PostWorksheetCellSetValue(name=filename, sheetName=sheetName, cellName=cellName, type=type, value=value)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/ShowChartLegendInAWorksheet.py b/ShowChartLegendInAWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartIndex = 0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #/invoke Aspose.Cells Cloud SDK API to get information of a chart legend of a chart
    response = cellsApi.GetWorksheetChartLegend(name=filename, sheetName=sheetName, chartIndex=chartIndex)

    if response.Status == "OK":
        chartLegendInfo = response.Legend
        print "Chart Legend Position :: " + chartLegendInfo.Position

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/SortWorkSheetData.py b/SortWorkSheetData.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import SortKey
 from asposecellscloud.models import DataSorter

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 cellArea = "A5:A10"

 sort = SortKey.SortKey()
 sort.Key = 0
 sort.SortOrder = "descending"

 body = DataSorter.DataSorter()
 body.CaseSensitive = "false"
 body.HasHeaders = "false"
 body.SortLeftToRight = "false"
 body.KeyList = [sort]

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to sort worksheet data
    response = cellsApi.PostWorksheetRangeSort(name=filename, sheetName=sheetName, cellArea=cellArea, body=body)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" +  "sorted_" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/SplitExcelWorkbooks.py b/SplitExcelWorkbooks.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 format = "png"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to merge multiple workbooks into a single workbook
    response = cellsApi.PostWorkbookSplit(name=filename, format=format, ffrom=2, to=2)

    if response.Status == "OK":
        #download splitted document from storage server
        outfilename = response.Result.Documents[0].link.Href
        response = storageApi.GetDownload(Path=outfilename)
        with open("c:/temp/" + outfilename, 'wb') as f:
            for chunk in response.InputStream:
                f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/UnfreezePanesInExcelWorksheet.py b/UnfreezePanesInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet1"
 row = 1
 column = 1
 freezedRows = 1
 freezedColumns = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to o unfreeze panes in a worksheet
    response = cellsApi.DeleteWorksheetFreezePanes(name=filename, sheetName=sheetName, row=row, column=column, freezedRows=freezedRows, freezedColumns=freezedColumns)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" +  filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/UngroupRowsInExcelWorksheet.py b/UngroupRowsInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Group_Rows_Sample_Test_Book.xls"
 sheetName = "Sheet1"
 firstIndex = 1
 lastIndex = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to ungroup selected rows in a worksheet
    response = cellsApi.PostUngroupWorksheetRows(name=filename, sheetName=sheetName, firstIndex=firstIndex, lastIndex=lastIndex)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + "Un" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/UnhideExcelWorksheets.py b/UnhideExcelWorksheets.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Hidden-WorkSheet-Sample_Test_Book.xls"
 sheetName = "Sheet1"
 isVisible = True

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to un-hide a worksheet in a workbook
    response = cellsApi.PutChangeVisibilityWorksheet(name=filename, sheetName=sheetName, isVisible=isVisible)

    if response.Status == "OK":
        print "Visibility Type: " + response.Worksheet.VisibilityType
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" +  filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/UnhideRowsInExcelWorksheet.py b/UnhideRowsInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Hide_Row_Sample_Test_Book.xls"
 sheetName = "Sheet1"
 startrow = 1
 totalRows = 1

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to unhide selected rows in a worksheet
    response = cellsApi.PostUnhideWorksheetRows(name=filename, sheetName=sheetName, startrow=startrow, totalRows=totalRows, height=1.0)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + "Un" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/UnmergeCellsInExcelWorksheet.py b/UnmergeCellsInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "MergeCell_Sample_Test_Book.xls"
 sheetName = "Sheet2"
 startRow = 1
 startColumn = 1
 totalRows = 1
 totalColumns = 5

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to unmerge selected merged cells in a worksheet
    response = cellsApi.PostWorksheetUnmerge(name=filename, sheetName=sheetName, startRow=startRow, startColumn=startColumn, totalRows=totalRows, totalColumns=totalColumns)

    if response.Status == "OK":
        #download updated Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + "Un" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)


 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/UnProtectExcelWorkbooks.py b/UnProtectExcelWorkbooks.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import WorkbookProtectionRequest

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Protected_Test_Book.xls"

 body = WorkbookProtectionRequest.WorkbookProtectionRequest()
 body.Password = "aspose"
 body.ProtectionType = "None"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to un-protect a workbook
    response = cellsApi.DeleteUnProtectDocument(name=filename, body=body)

    if response.Status == "OK":
        #download unprotected document from cloud storage
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/UpdateChartLegendInWorksheet.py b/UpdateChartLegendInWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import Legend

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartIndex = 0

 body = Legend.Legend()
 body.Height = 15
 body.Position = "Left"

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to update a chart legend of a chart
    response = cellsApi.PostWorksheetChartLegend(name=filename, sheetName=sheetName, chartIndex=chartIndex, body=body)

    if response.Status == "OK":
        chartLegendInfo = response.Legend
        print "Chart Legend Position :: " + chartLegendInfo.Position

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/UpdateChartTitleInExcelWorkbook.py b/UpdateChartTitleInExcelWorkbook.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import Title

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet5"
 chartIndex = 0

 body = Title.Title()
 body.Text = "Aspose"
 body.Height = 15

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to update chart title in a Worksheet
    response = cellsApi.PostWorksheetChartTitle(name=filename, sheetName=sheetName, chartIndex=chartIndex, body=body)

    if response.Status == "OK":
        #download updated workbook from cloud storage
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/UpdateHyperlinksInExcelWorksheet.py b/UpdateHyperlinksInExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import Hyperlink

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet2"
 hyperlinkIndex = 0;

 body = Hyperlink.Hyperlink()
 body.Address ="http://www.aspose.com/cloud/total-api.aspx"
 body.TextToDisplay ="Aspose Cloud APIs"


 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)


 try:
    #invoke Aspose.Cells Cloud SDK API to add a hyperlink to a worksheet
    response = cellsApi.PostWorkSheetHyperlink(name=filename, sheetName=sheetName, hyperlinkIndex=hyperlinkIndex, body=body)

    if response.Status == "OK":
        hyperlink = response.Hyperlink
        print "Hyperlink Address : " + hyperlink.Address
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/UpdateSpecificOLEObjectFromExcelWorksheet.py b/UpdateSpecificOLEObjectFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import OleObject

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Embeded_OleObject_Sample_Book1.xlsx"
 sheetName = "Sheet1"
 oleObjectIndex = 0

 sourceFileName = "Sample_Book2.xls"
 imageFileName = "aspose-logo.png"

 body  = OleObject.OleObject()
 body.SourceFullName = sourceFileName
 body.ImageSourceFullName = imageFileName
 body.UpperLeftRow = 15
 body.UpperLeftColumn = 5
 body.Top = 10
 body.Bottom = 10
 body.Left = 10
 body.Height = 400
 body.Width = 400
 body.IsAutoSize = True


 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)
 storageApi.PutCreate(Path=sourceFileName, file=data_folder + sourceFileName)
 storageApi.PutCreate(Path=imageFileName, file=data_folder + imageFileName)

 try:
    #invoke Aspose.Cells Cloud SDK API to update a specific OleObject from a worksheet
    response = cellsApi.PostUpdateWorksheetOleObject(name=filename, sheetName=sheetName, oleObjectIndex=oleObjectIndex, body=body)

    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)
 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
diff --git a/UpdateSpecificPictureFromExcelWorksheet.py b/UpdateSpecificPictureFromExcelWorksheet.py
 import asposecellscloud
 from asposecellscloud.CellsApi import CellsApi
 from asposecellscloud.CellsApi import ApiException
 from asposecellscloud.models import Picture

 import asposestoragecloud
 from asposestoragecloud.StorageApi import StorageApi

 apiKey = "XXXXX" #sepcify App Key
 appSid = "XXXXX" #sepcify App SID
 apiServer = "http://api.aspose.com/v1.1"
 data_folder = "../../data/"

 #Instantiate Aspose Storage API SDK
 storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
 storageApi = StorageApi(storage_apiClient)
 #Instantiate Aspose Cells API SDK
 api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
 cellsApi = CellsApi(api_client);

 #set input file name
 filename = "Sample_Test_Book.xls"
 sheetName = "Sheet6"
 pictureIndex = 0

 body = Picture.Picture()
 body.Name ="aspose-cloud-logo"
 body.RotationAngle = 90.0

 #upload file to aspose cloud storage
 storageApi.PutCreate(Path=filename, file=data_folder + filename)

 try:
    #invoke Aspose.Cells Cloud SDK API to update a picture to a worksheet
    response = cellsApi.PostWorkSheetPicture(name=filename, sheetName=sheetName, pictureIndex=pictureIndex, body=body)
    if response.Status == "OK":
        #download Workbook from storage server
        response = storageApi.GetDownload(Path=filename)
        outfilename = "c:/temp/" + filename
        with open(outfilename, 'wb') as f:
                    for chunk in response.InputStream:
                        f.write(chunk)

 except ApiException as ex:
            print "ApiException:"
            print "Code:" + str(ex.code)
            print "Message:" + ex.message
	import asposecellscloud
	from asposecellscloud.CellsApi import CellsApi
	from asposecellscloud.CellsApi import ApiException

	import asposestoragecloud
	from asposestoragecloud.StorageApi import StorageApi

	apiKey = "XXXXX" #sepcify App Key
	appSid = "XXXXX" #sepcify App SID
	apiServer = "http://api.aspose.com/v1.1"
	data_folder = "../../data/"

	#Instantiate Aspose Storage API SDK
	storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
	storageApi = StorageApi(storage_apiClient)
	#Instantiate Aspose Cells API SDK
	api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
	cellsApi = CellsApi(api_client);

	#set input file name
	filename = "Sample_Test_Book.xls"
	sheetName = "Sheet5"
	chartType = "bar"
	upperLeftRow = 12
	upperLeftColumn = 12
	lowerRightRow = 20
	lowerRightColumn = 20
	area = "A1:A3"
	isVertical = False
	isAutoGetSerialName = True
	title = "SalesState"

	#upload file to aspose cloud storage
	storageApi.PutCreate(Path=filename, file=data_folder + filename)

	try:
	#invoke Aspose.Cells Cloud SDK API to add a chart in a worksheet
	response = cellsApi.PutWorksheetAddChart(name=filename, sheetName=sheetName, chartType=chartType, upperLeftRow=upperLeftRow, upperLeftColumn=upperLeftColumn, lowerRightColumn=lowerRightColumn, area=area, isVertical=isVertical, isAutoGetSerialName=isAutoGetSerialName, title=title)

	if response.Status == "OK":
	#download updated Workbook from storage server
	response = storageApi.GetDownload(Path=filename)
	outfilename = "c:/temp/" + filename
	with open(outfilename, 'wb') as f:
	for chunk in response.InputStream:
	f.write(chunk)
	except ApiException as ex:
	print "ApiException:"
	print "Code:" + str(ex.code)
	print "Message:" + ex.message
	mport asposecellscloud
	from asposecellscloud.CellsApi import CellsApi
	from asposecellscloud.CellsApi import ApiException
	from asposecellscloud.models import PivotTableFieldRequest

	import asposestoragecloud
	from asposestoragecloud.StorageApi import StorageApi

	apiKey = "XXXXX" #sepcify App Key
	appSid = "XXXXX" #sepcify App SID
	apiServer = "http://api.aspose.com/v1.1"
	data_folder = "../../data/"

	#Instantiate Aspose Storage API SDK
	storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
	storageApi = StorageApi(storage_apiClient)
	#Instantiate Aspose Cells API SDK
	api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
	cellsApi = CellsApi(api_client);

	#set input file name
	filename = "Sample_Pivot_Table_Example.xls"
	sheetName = "Sheet2"
	pivotTableIndex = 0
	pivotFieldType = "Row"

	body = PivotTableFieldRequest.PivotTableFieldRequest()
	body.Data = [1,2]

	#upload file to aspose cloud storage
	storageApi.PutCreate(Path=filename, file=data_folder + filename)

	try:
	#invoke Aspose.Cells Cloud SDK API to add pivot field into pivot table
	response = cellsApi.PutPivotTableField(name=filename, sheetName=sheetName, pivotTableIndex=pivotTableIndex, pivotFieldType=pivotFieldType, body=body)

	if response.Status == "OK":
	#download Workbook from storage server
	response = storageApi.GetDownload(Path=filename)
	outfilename = "c:/temp/" + filename
	with open(outfilename, 'wb') as f:
	for chunk in response.InputStream:
	f.write(chunk)

	except ApiException as ex:
	print "ApiException:"
	print "Code:" + str(ex.code)
	print "Message:" + ex.message
	import asposecellscloudimport asposecellscloud
	from asposecellscloud.CellsApi import CellsApi
	from asposecellscloud.CellsApi import ApiException

	import asposestoragecloud
	from asposestoragecloud.StorageApi import StorageApi

	apiKey = "XXXXX" #sepcify App Key
	appSid = "XXXXX" #sepcify App SID
	apiServer = "http://api.aspose.com/v1.1"
	data_folder = "../../data/"

	#Instantiate Aspose Storage API SDK
	storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
	storageApi = StorageApi(storage_apiClient)
	#Instantiate Aspose Cells API SDK
	api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
	cellsApi = CellsApi(api_client);

	#set input file name
	filename = "Sample_Test_Book.xls"
	sheetName = "Sheet1"
	cellarea = "A10:B20"
	value = "1234"
	type = "int"

	#upload file to aspose cloud storage
	storageApi.PutCreate(Path=filename, file=data_folder + filename)

	try:
	#invoke Aspose.Cells Cloud SDK API to set value for selected range in a worksheet
	response = cellsApi.PostSetCellRangeValue(name=filename, sheetName=sheetName, cellarea=cellarea, type=type, value=value)

	if response.Status == "OK":
	#download updated Workbook from storage server
	response = storageApi.GetDownload(Path=filename)
	outfilename = "c:/temp/" + filename
	with open(outfilename, 'wb') as f:
	for chunk in response.InputStream:
	f.write(chunk)


	except ApiException as ex:
	print "ApiException:"
	print "Code:" + str(ex.code)
	print "Message:" + ex.message

	from asposecellscloud.CellsApi import CellsApi
	from asposecellscloud.CellsApi import ApiException

	import asposestoragecloud
	from asposestoragecloud.StorageApi import StorageApi

	apiKey = "XXXXX" #sepcify App Key
	appSid = "XXXXX" #sepcify App SID
	apiServer = "http://api.aspose.com/v1.1"
	data_folder = "../../data/"

	#Instantiate Aspose Storage API SDK
	storage_apiClient = asposestoragecloud.ApiClient.ApiClient(apiKey, appSid, True)
	storageApi = StorageApi(storage_apiClient)
	#Instantiate Aspose Cells API SDK
	api_client = asposecellscloud.ApiClient.ApiClient(apiKey, appSid, True)
	cellsApi = CellsApi(api_client);

	#set input file name
	filename = "Sample_Test_Book.xls"
	sheetName = "Sheet1"
	cellarea = "A10:B20"
	value = "1234"
	type = "int"

	#upload file to aspose cloud storage
	storageApi.PutCreate(Path=filename, file=data_folder + filename)

	try:
	#invoke Aspose.Cells Cloud SDK API to set value for selected range in a worksheet
	response = cellsApi.PostSetCellRangeValue(name=filename, sheetName=sheetName, cellarea=cellarea, type=type, value=value)

	if response.Status == "OK":
	#download updated Workbook from storage server
	response = storageApi.GetDownload(Path=filename)
	outfilename = "c:/temp/" + filename
	with open(outfilename, 'wb') as f:
	for chunk in response.InputStream:
	f.write(chunk)


	except ApiException as ex:
	print "ApiException:"
	print "Code:" + str(ex.code)
	print "Message:" + ex.message