xlwings-utils 25.0.5.post0__py3-none-any.whl → 25.0.6.post0__py3-none-any.whl

xlwings_utils/xlwings_utils.py

@@ -5,7 +5,7 @@
 #  /_/\_\|_|  \_/\_/  |_||_| |_| \__, ||___/ _____  \__,_| \__||_||_||___/
 #                                |___/      |_____|
 
-__version__ = "25.0.5"
+__version__ = "25.0.6"
 
 
 import dropbox
@@ -155,7 +155,7 @@ def list_dropbox(path="", recursive=False, show_files=True, show_folders=False):
     return out
 
 
-def read_dropbox(dropbox_path):
+def read_dropbox(dropbox_path, max_retries=100):
     """
     read_dropbox
 
@@ -166,6 +166,9 @@ def read_dropbox(dropbox_path):
     dropbox_path : str or Pathlib.Path
         path to read from
 
+    max_retries : int
+        number of retries (default: 100)
+
     Returns
     -------
     contents of the dropbox file : bytes
@@ -175,24 +178,25 @@ def read_dropbox(dropbox_path):
     If REFRESH_TOKEN, APP_KEY and APP_SECRET environment variables are specified,
     it is not necessary to call dropbox_init() prior to any dropbox function.
 
-    If the file size does not match the metadata, as sometimes happens on pyodide, an OSError exception will be raised.
+    As reading from dropbox is very unreliable under pyodide, reading will have to be retried (by default maximum 100 times).
+    The number of retries can be found with read_dropbox.retries.
     """
 
     _login_dbx()
-    metadata, response = dbx.files_download(dropbox_path)
-    file_content = response.content
-    if len(file_content) != metadata.size:
-        raise OSError(f"file size ({len(file_content)}) does not match metadata ({metadata.size})")
-    return file_content
+    for read_dropbox.retries in range(max_retries + 1):
+        metadata, response = dbx.files_download(dropbox_path)
+        file_content = response.content
+        if len(file_content) == metadata.size:
+            return file_content
+    raise OSError(f"after {max_retries} still no valid response")
 
 
 def write_dropbox(dropbox_path, contents):
-    _login_dbx()
     """
     write_dropbox
-    
+
     write from dopbox at given path
-    
+
     Parameters
     ----------
     dropbox_path : str or Pathlib.Path
@@ -200,12 +204,13 @@ def write_dropbox(dropbox_path, contents):
 
     contents : bytes
         contents to be written
-        
+
     Note
     ----
     If REFRESH_TOKEN, APP_KEY and APP_SECRET environment variables are specified,
     it is not necessary to call dropbox_init() prior to any dropbox function.
     """
+    _login_dbx()
     dbx.files_upload(contents, dropbox_path, mode=dropbox.files.WriteMode.overwrite)
 
 
@@ -429,6 +434,19 @@ class block:
         if column > self.number_of_columns:
             raise ValueError(f"{name}={column} > number_of_columns={self.number_of_columns}")
 
+    def transpose(self):
+        """
+        transpose block
+
+        Returns
+        -------
+        transposed block : block
+        """
+        bl = block(number_of_rows=self.number_of_columns, number_of_columns=self.number_of_rows)
+        for (row, column), value in self.dict.items():
+            bl[column, row] = value
+        return bl
+
     def vlookup(self, s, *, row_from=1, row_to=missing, column1=1, column2=missing, default=missing):
         """
         searches in column1 for row between row_from and row_to for s and returns the value found at (that row, column2)
@@ -680,63 +698,60 @@ class block:
         return self.vlookup(s, row_from=row_from, row_to=row_to, column1=column1, column2=column2, default=default)
 
     def decode_to_files(self):
-        """ 
-        decode the block with encoded file(s) to individual local files
         """
+        decode the block with encoded file(s) to individual pyoidide files
+        """
+        count = 0
+        for column in self.number_of_columns:
+            row = 1
+            bl = self.mimimized()
+            while row <= self.number_of_rows:
+                if self[row, column] and self[row, column].startswith("<file=") and self[row, column].endswith(">"):
+                    filename = self[row, column][6:-1]
+                    collect = []
+                    row += 1
+                    while bl[row, column] != "</file>":
+                        if bl[row, column]:
+                            collect.append(bl[row, column])
+                        row += 1
+                    decoded = base64.b64decode("".join(collect))
+                    open(filename, "wb").write(decoded)
+                    count += 1
+                row += 1
+        return count
 
-        row=1
-        while row<=self.number_of_rows:
-            if self[row,1] and self[row,1].startswith('<file=') and self[row,1].endswith('>'):
-                filename=self[row,1][6:-1]
-                collect=[]
-                row+=1
-                print(f"{filename=}")
-
-                while self[row,1]!='</file>':
-                    print(f"{self[row,1]=}")
-
-                    if self[row,1]:
-                        collect.append(self[row,1])
-                    row+=1
-                print(f"{collect=}")
-                decoded=base64.b64decode(''.join(collect))
-                open(filename,'wb').write(decoded)
-            row+=1
-            
     @classmethod
-    def encode_files(cls, *files):
+    def encode_file(cls, file):
         """
-        make a block with the given files encoded
+        make a block with the given pyodide file encoded
 
         Parameters
         ----------
-        files : file names (str)
-            files to be encoded 
+        file : file name (str)
+            file to be encoded
 
         Returns
         -------
-        block with encoded files : block
-            not minimized!
+        block with encoded file : block (minimized)
         """
 
-        bl =cls(number_of_rows=50000, number_of_columns=1)
-        
+        bl = cls(number_of_rows=100000, number_of_columns=1)
+
         n = 5000  # block size
         row = 1
-        for file in files:
-            bl[row, 1] = f"<file={file}>"
+        bl[row, 1] = f"<file={file}>"
+        row += 1
+        b64 = base64.b64encode(open(file, "rb").read()).decode("utf-8")
+        while b64:
+            b64_n = b64[:n]
+            bl[row, 1] = b64_n
             row += 1
-            b64 = base64.b64encode(open(file, "rb").read()).decode("utf-8")
-            while b64:
-                b64_n = b64[:n]
-                bl[row, 1] = b64_n
-                row += 1
-                b64 = b64[n:]
-            bl[row, 1] = f"</file>"
-            row+=1    
-        return bl
-            
-    
+            b64 = b64[n:]
+        bl[row, 1] = f"</file>"
+        row += 1
+        return bl.minimized()
+
+
 class Capture:
     """
     specifies how to capture stdout
@@ -842,9 +857,9 @@ class Capture:
     @include_print.setter
     def include_print(self, value):
         self._include_print = value
-        
 
-def trigger(sheet):
+
+def trigger_macro(sheet):
     """
     triggers the macro on sheet
 
@@ -852,11 +867,12 @@ def trigger(sheet):
     ----------
     sheet : sheet
         sheet to use
-        
+
     """
 
     sheet["A1"].value = "=NOW()"
 
-        
+
 if __name__ == "__main__":
     ...
+

{xlwings_utils-25.0.5.post0.dist-info → xlwings_utils-25.0.6.post0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xlwings_utils
-Version: 25.0.5.post0
+Version: 25.0.6.post0
 Summary: xlwings_utils
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://github.com/salabim/xlwings_utils
@@ -62,8 +62,7 @@ python -c "exec(__import__('requests').get('https://salabim.org/dropbox setup.py
 Then, it is possible to list all files in a specified folder using the list_dropbox function.
 It is also possible to get the folders and to access all underlying folders.
 
-The `read_dropbox` function can be used to read the contents (bytes) of a Dropbox file. If the file is not read correctly, which seems
-to happen rather frequently, an OSError exception is raised.
+The `read_dropbox` function can be used to read the contents (bytes) of a Dropbox file. As reading from Dropbox under pyodide is rather unreliable, xlwings_utils automatically retries several times (by default 100 times). The actual number of retries can be found with `read_dropbox.retries`.
 
 The function `write_dropbox` can be used to write contents (bytes) to a Dropbox file.
 
@@ -267,84 +266,52 @@ Clearing the captured stdout buffer can be done at any time with `capture.clear(
 
 Currently, *xlwings Lite* does not provide access to the local file system. Therefore, xlwings_utils offers some functionality to trigger a VBA script as well as functionality to encode a file in the pyodide file system to a VBA sheet and to trigger writing the encoded file(s) to the local file system.
 
-Note that the sheet must have a worksheet named `VBA`, and the VBA code will normally reside there.
+Files can be encoded into a block, like:
 
-There are three Python functions defined:
+```
+    bl = xwu.block.encode_file("film1.mp4")
+    book.sheets["VBA"].range((10,1)).value=bl.value
+```
 
-  * `trigger_VBA()`
-    fires a VBA script, provided a VBA function is defined on the sheet, like:
-    
-    ```
-    Sub Worksheet_Calculate()
-        If Me.Range("A1").Formula = "=NOW()" Then
-            Me.Range("A1").Value = Null
-            REM Code to run 
-        End If
-    End Sub
-    ```
-  * `init_transfer_files()`
-    This should be called prior to any `transfer_file` call. It just removes all encoded files from the VBA sheet (if any)
+With this code, column A will be filled with an encoded copy of the files *film1.mp4* . This can then be used with a suitable VBA macro to decode to the real file system. A VBA macro can be triggered with `xwu.trigger_macro()`. This requires an Excel worksheet where cell A1 is reserved for communication with xlwings lite. This worksheet needs to contain a macro, like
+
+```
+Private Sub Worksheet_Calculate()
+    If Me.Range("A1").Formula = "=NOW()" Then
+        Me.Range("A1").Value = Null
+        Call MacroToExecute
+    End If
+End Sub
+```
 
-  * `transfer_file()`
-    Can be used to encode a file on the pyodide file system to the VBA sheet. Multiple files are allowed. The file name will be encoded on the sheet as well.
+, where `MacroToExecute` should contain the user code, most likely code to decode file(s) encoded.
 
-The VBA code below can be used to decode encoded file(s) and write to the local file system.
+The repo contains a VBA module called xlwings_utils.bas with code to decode encoded files.
+Just add the .bas file to a worksheet and call like
 
 ```
-Sub WriteFiles()
-    
-    Dim vArr() As Byte
-    Dim S As String
-    Dim Column As Integer
-    Dim Row As Integer
-    Dim ws As Worksheet
-    Dim Count As Integer
-    Dim FileNames As String
-    
-    Column = 1
-    Row = 1
-    
-    ThisDir = ThisWorkbook.Path
-    Set ws = Me
-    Count = 0
-    While Row < 30000
-        Line = ws.Cells(Row, Column)
-        If InStr(Line, "<file=") = 1 And Right(Line, 1) = ">" Then
-            If Count <> 0 Then
-                FileNames = FileNames & ", "
-            End If
-            Count = Count + 1
-            FileNameOnly = Mid(Line, 7, Len(Line) - 7)
-            Filename = ThisDir & "/" & FileNameOnly
-            FileNames = FileNames & FileNameOnly
-            
-            Row = Row + 1
-            S = ""
-            While ws.Cells(Row, Column) <> "</file>"
-                S = S & ws.Cells(Row, Column)
-                Row = Row + 1
-            Wend
-                
-            vArr = Base64ToArray(S)
-        
-            Open Filename For Binary Access Write As #1
-            WritePos = 1
-            Put #1, WritePos, vArr
-            Close #1
-        End If
-        
-        Row = Row + 1
-    
-    Wend
-    If Cells(4, 2) = "y" Then
-        ws.Range("A10:A1000000").Clear
-    End If
+Sub MacroToExecute()
+    DecodeFile(Me, 10, 1)
+```
     
-    If Count = 0 Then
-        MsgBox "No files written"
-    Else
-        MsgBox "Successfully written " & Str(Count) & " file(s): " & FileNames
-    End If
+In this example, the file *film1.mp4* will be downloaded into the current directory.
+
+The module xlwings_utils also contains code to encode a local file to a sheet:
+
+```
+Sub MacroToExecute()
+    EncodeFile(Me, "data.json", 10, 1)
+```
+
+This will place an encoded version of *data.json* on the sheet.
+
+Then, the file can be copied to the pyodide file system with
+
+```
+bl = block(xw.range((10,1),(50000,1)).decode_to_files())
+```
+```
+
 ```
 
 ## Contact info

xlwings_utils-25.0.6.post0.dist-info/RECORD

@@ -0,0 +1,6 @@
+xlwings_utils/__init__.py,sha256=FdaRztevSu5akGL7KBUBRzqwLMRTdvVUuS2Kfp2f1Uc,68
+xlwings_utils/xlwings_utils.py,sha256=arj8LGanSJk3pKER9_cIMNuCB77hBVtiPpiKUaXqqKY,25775
+xlwings_utils-25.0.6.post0.dist-info/METADATA,sha256=uUqweJdGbgthjjuACxO2JwfgsBojtsyIrWeBRahVQIo,12255
+xlwings_utils-25.0.6.post0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xlwings_utils-25.0.6.post0.dist-info/top_level.txt,sha256=kf5SEv0gZiRObPhUoYcc1O_iX_wwTOPeUIYvzyYeAM4,14
+xlwings_utils-25.0.6.post0.dist-info/RECORD,,

xlwings_utils-25.0.5.post0.dist-info/RECORD

@@ -1,6 +0,0 @@
-xlwings_utils/__init__.py,sha256=FdaRztevSu5akGL7KBUBRzqwLMRTdvVUuS2Kfp2f1Uc,68
-xlwings_utils/xlwings_utils.py,sha256=KP4RPmEyajLF2pn9IS3QEQyYC_xBn1yNoWzdh3cqqSo,25238
-xlwings_utils-25.0.5.post0.dist-info/METADATA,sha256=1amSYUkgWF76__slfIRyOpR-J-VbHjeoqmZxipWK21Q,13036
-xlwings_utils-25.0.5.post0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xlwings_utils-25.0.5.post0.dist-info/top_level.txt,sha256=kf5SEv0gZiRObPhUoYcc1O_iX_wwTOPeUIYvzyYeAM4,14
-xlwings_utils-25.0.5.post0.dist-info/RECORD,,