xlwings-utils 0.0.7__tar.gz → 0.0.7.post1__tar.gz

{xlwings_utils-0.0.7/xlwings_utils.egg-info → xlwings_utils-0.0.7.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xlwings_utils
-Version: 0.0.7
+Version: 0.0.7.post1
 Summary: xlwings_utils
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://github.com/salabim/xlwings_utils
@@ -16,16 +16,20 @@ Requires-Dist: ssl
 
 ## Introduction
 
-This module provides some useful functions to be used in xlwings lite.
+This module provides some useful functions to be used in xlwings (lite).
 
 ## Installation
 
-Just add xlwings-utils to the *requirement.txt* tab. It might be required to add ssl.
+Just add xlwings-utils to the *requirements.txt* tab. 
 
 In the script, add
 
 ```ìmport xlwings_utils as xwu```
 
+> [!NOTE]
+>
+> The GitHub repository can be found on https://github.com/salabim/xlwings_utils .
+
 ## Dropbox support
 
 The xlwings lite system does not provide access to the local file system. With this module, files can be copied between Dropbox and the local pyodide file system, making it possible to indirectly use the local file system.
@@ -95,10 +99,26 @@ To assign a block to range, use
 range.value = block.value
 ```
 
-The property `block.highest`_used_row_number returns the
+The property `block.highest_used_row_number` returns the row number of the highest non-None cell.
+
+The property `block.highest_used_column_number` returns the column_number of the highest non-None cell.
 
 The method `block.minimized()` returns a block that has the dimensions of (highest_used_row_number, highest_used_column_number). 
 
+Particularly if we process an unknown number of lines, we can do something like:
+
+```
+this_block = xwu.block(number_of_rows=10000, number_of_columns=2)
+for row in range(1, 10001):
+	this_block[row,1]= ...
+	this_block[row,2]= ...
+	if ...: # end condition
+	    break
+sheet.range(10,1).value = this_block.minimized().value
+```
+
+In this case, only the really processed rows are copied to the sheet.
+
 ## Capture stdout support
 
 The module has support for capturing stdout and -later- using showing the captured output on a sheet.
@@ -117,13 +137,17 @@ sheet.range(4,5).value = xwu.captured_stdout_as_value()
 
 Clearing the captured stdout buffer can be done with `xwu.clear_captured_std_out`.
 
-Normally, stdout will be also sent to the xlwings lite UI panel. This can be suppressed with
+Normally, stdout will also be sent to the xlwings lite UI panel. This can be suppressed with
 
 ```
 with xwu.capture_stdout(include_print=False):
     ...
 ```
 
+## Contact info
+
+You can contact Ruud van der Ham, the core developer, via ruud@salabim.org .
+
 ## Badges
 
 ![PyPI](https://img.shields.io/pypi/v/xlwings-utils) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/xlwings-utils) ![PyPI - Implementation](https://img.shields.io/pypi/implementation/xlwings-utils)

xlwings_utils-0.0.7/PKG-INFO → xlwings_utils-0.0.7.post1/README.md

@@ -1,132 +1,142 @@
-Metadata-Version: 2.4
-Name: xlwings_utils
-Version: 0.0.7
-Summary: xlwings_utils
-Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
-Project-URL: Homepage, https://github.com/salabim/xlwings_utils
-Project-URL: Repository, https://github.com/salabim/xlwings_utils
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Requires-Dist: dropbox
-Requires-Dist: ssl
-
- <img src="https://www.salabim.org/xlwings_utils_logo2.png">  
-
-## Introduction
-
-This module provides some useful functions to be used in xlwings lite.
-
-## Installation
-
-Just add xlwings-utils to the *requirement.txt* tab. It might be required to add ssl.
-
-In the script, add
-
-```ìmport xlwings_utils as xwu```
-
-## Dropbox support
-
-The xlwings lite system does not provide access to the local file system. With this module, files can be copied between Dropbox and the local pyodide file system, making it possible to indirectly use the local file system.
-
-It is only possible, as of now, to use full-access Dropbox apps.
-
-The easiest way to use the Dropbox functionality is to add the credentials to the environment variables. Add REFRESH_TOKEN, APP_KEY and APP_SECRET with their corresponding values to the environment variables.
-
-Then, it is possible to list all files in a specified folder with the function `list_dropbox`.
-It is also possible to get the folders and to access all underlying folders.
-
-The function `read_dropbox` can be used to read a Dropbox file's contents (bytes).
-
-The function `write_dropbox` can be used to write contents (bytes) to a Dropbox file.
-
-The functions `list_local`, `read_local` and `write_local` offer similar functionality for the local file system (on pyodide).
-
-So, a way to access a file on the system's drive (mapped to Dropbox) as a local file is:
-
-```
-contents = xlwings_utils.read_dropbox('/downloads/file1.xls')
-xlwings_utils.write_local('file1.xlsx')
-df = pandas.read_excel"file1.xlsx")
-...
-```
-And the other direction:
-```
-contents = xlwings_utils.read_local('file1.gif')
-xlwings_utils.write_dropbox('/downloads/file1.gif')
-```
-
-## Block support
-
-The module contains a useful 2-dimensional data structure: *block*.
-This can be useful to manipulate a range without accessing the range directly, which is expensive in terms of memory and execution time.
-The advantage over an ordinary list of lists is that a block is index one-based, in line with range and addressing is done with a row, column tuple.
-So, `my_block(lol)[row, col]` is roughly equivalent to `lol[row-1][col-1]`
-
-A block stores the values internally as a dictionary and will only convert these to a list of lists when using `block.value`. 
-
-Converting the value of a range (usually a list of lists, but can also be a list or scalar) to a block can be done with
-
-```
-my_block = xwu.block.from_value(range.value)
-```
-The dimensions (number of rows and number of columns) are automatically set.
-
-Setting of an individual item (one-based, like range) can be done like
-```
-my_block[row, column] = x
-```
-And, likewise, reading an individual item can be done like
-```
-x = my_block[row, column]
-```
-It is not allowed t,o read or write outside the block dimensions.
-
-It is also possible to define an empty block, like
-```
-block = xlwings_utils.block(number_of_rows, number_columns)
-```
-The dimensions can be queried or redefined with `block.number_of_rows` and 
-`block.number_of_columns`.
-
-To assign a block to range, use
-```
-range.value = block.value
-```
-
-The property `block.highest`_used_row_number returns the
-
-The method `block.minimized()` returns a block that has the dimensions of (highest_used_row_number, highest_used_column_number). 
-
-## Capture stdout support
-
-The module has support for capturing stdout and -later- using showing the captured output on a sheet.
-
-To do that:
-
-```makes it possible to capture stdout writes, which
-with xwu.capture_stdout():
-    ...
-```
-and then the captured output can be copied to the screen, like
-
-```can then be copied to a worksheet in a later stage.
-sheet.range(4,5).value = xwu.captured_stdout_as_value()
-```
-
-Clearing the captured stdout buffer can be done with `xwu.clear_captured_std_out`.
-
-Normally, stdout will be also sent to the xlwings lite UI panel. This can be suppressed with
-
-```
-with xwu.capture_stdout(include_print=False):
-    ...
-```
-
-## Badges
-
-![PyPI](https://img.shields.io/pypi/v/xlwings-utils) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/xlwings-utils) ![PyPI - Implementation](https://img.shields.io/pypi/implementation/xlwings-utils)
-![PyPI - License](https://img.shields.io/pypi/l/xlwings-utils) ![ruff](https://img.shields.io/badge/style-ruff-41B5BE?style=flat) 
-![GitHub last commit](https://img.shields.io/github/last-commit/salabim/peek)
-
+ <img src="https://www.salabim.org/xlwings_utils_logo2.png">  
+
+## Introduction
+
+This module provides some useful functions to be used in xlwings (lite).
+
+## Installation
+
+Just add xlwings-utils to the *requirements.txt* tab. 
+
+In the script, add
+
+```ìmport xlwings_utils as xwu```
+
+> [!NOTE]
+>
+> The GitHub repository can be found on https://github.com/salabim/xlwings_utils .
+
+## Dropbox support
+
+The xlwings lite system does not provide access to the local file system. With this module, files can be copied between Dropbox and the local pyodide file system, making it possible to indirectly use the local file system.
+
+It is only possible, as of now, to use full-access Dropbox apps.
+
+The easiest way to use the Dropbox functionality is to add the credentials to the environment variables. Add REFRESH_TOKEN, APP_KEY and APP_SECRET with their corresponding values to the environment variables.
+
+Then, it is possible to list all files in a specified folder with the function `list_dropbox`.
+It is also possible to get the folders and to access all underlying folders.
+
+The function `read_dropbox` can be used to read a Dropbox file's contents (bytes).
+
+The function `write_dropbox` can be used to write contents (bytes) to a Dropbox file.
+
+The functions `list_local`, `read_local` and `write_local` offer similar functionality for the local file system (on pyodide).
+
+So, a way to access a file on the system's drive (mapped to Dropbox) as a local file is:
+
+```
+contents = xlwings_utils.read_dropbox('/downloads/file1.xls')
+xlwings_utils.write_local('file1.xlsx')
+df = pandas.read_excel"file1.xlsx")
+...
+```
+And the other direction:
+```
+contents = xlwings_utils.read_local('file1.gif')
+xlwings_utils.write_dropbox('/downloads/file1.gif')
+```
+
+## Block support
+
+The module contains a useful 2-dimensional data structure: *block*.
+This can be useful to manipulate a range without accessing the range directly, which is expensive in terms of memory and execution time.
+The advantage over an ordinary list of lists is that a block is index one-based, in line with range and addressing is done with a row, column tuple.
+So, `my_block(lol)[row, col]` is roughly equivalent to `lol[row-1][col-1]`
+
+A block stores the values internally as a dictionary and will only convert these to a list of lists when using `block.value`. 
+
+Converting the value of a range (usually a list of lists, but can also be a list or scalar) to a block can be done with
+
+```
+my_block = xwu.block.from_value(range.value)
+```
+The dimensions (number of rows and number of columns) are automatically set.
+
+Setting of an individual item (one-based, like range) can be done like
+```
+my_block[row, column] = x
+```
+And, likewise, reading an individual item can be done like
+```
+x = my_block[row, column]
+```
+It is not allowed t,o read or write outside the block dimensions.
+
+It is also possible to define an empty block, like
+```
+block = xlwings_utils.block(number_of_rows, number_columns)
+```
+The dimensions can be queried or redefined with `block.number_of_rows` and 
+`block.number_of_columns`.
+
+To assign a block to range, use
+```
+range.value = block.value
+```
+
+The property `block.highest_used_row_number` returns the row number of the highest non-None cell.
+
+The property `block.highest_used_column_number` returns the column_number of the highest non-None cell.
+
+The method `block.minimized()` returns a block that has the dimensions of (highest_used_row_number, highest_used_column_number). 
+
+Particularly if we process an unknown number of lines, we can do something like:
+
+```
+this_block = xwu.block(number_of_rows=10000, number_of_columns=2)
+for row in range(1, 10001):
+	this_block[row,1]= ...
+	this_block[row,2]= ...
+	if ...: # end condition
+	    break
+sheet.range(10,1).value = this_block.minimized().value
+```
+
+In this case, only the really processed rows are copied to the sheet.
+
+## Capture stdout support
+
+The module has support for capturing stdout and -later- using showing the captured output on a sheet.
+
+To do that:
+
+```makes it possible to capture stdout writes, which
+with xwu.capture_stdout():
+    ...
+```
+and then the captured output can be copied to the screen, like
+
+```can then be copied to a worksheet in a later stage.
+sheet.range(4,5).value = xwu.captured_stdout_as_value()
+```
+
+Clearing the captured stdout buffer can be done with `xwu.clear_captured_std_out`.
+
+Normally, stdout will also be sent to the xlwings lite UI panel. This can be suppressed with
+
+```
+with xwu.capture_stdout(include_print=False):
+    ...
+```
+
+## Contact info
+
+You can contact Ruud van der Ham, the core developer, via ruud@salabim.org .
+
+## Badges
+
+![PyPI](https://img.shields.io/pypi/v/xlwings-utils) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/xlwings-utils) ![PyPI - Implementation](https://img.shields.io/pypi/implementation/xlwings-utils)
+![PyPI - License](https://img.shields.io/pypi/l/xlwings-utils) ![ruff](https://img.shields.io/badge/style-ruff-41B5BE?style=flat) 
+![GitHub last commit](https://img.shields.io/github/last-commit/salabim/peek)
+

{xlwings_utils-0.0.7 → xlwings_utils-0.0.7.post1}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [
     { name = "Ruud van der Ham", email = "rt.van.der.ham@gmail.com" },
 ]
 description = "xlwings_utils"
-version = "0.0.7"
+version = "0.0.7.post1"
 readme = "README.md"
 requires-python = ">=3.9"
 dependencies = [

{xlwings_utils-0.0.7 → xlwings_utils-0.0.7.post1}/tests/test_xlwings_utils.py

@@ -103,24 +103,34 @@ def test_raise():
 
 
 def test_capture_stdout(capsys):
-    with xwu.capture_stdout():
-        print("abc")
-        print("def")
-    assert xwu.captured_stdout_as_str() == "abc\ndef\n"
-    assert xwu.captured_stdout_as_value() == [["abc"], ["def"]]
-
+    print("abc")
+    print("def")
     out, err = capsys.readouterr()
     assert out == "abc\ndef\n"
-
-    xwu.clear_captured_stdout()
     assert xwu.captured_stdout_as_str() == ""
-    with xwu.capture_stdout(include_print=False):
-        print("ghi")
-        print("jkl")
-    assert xwu.captured_stdout_as_str() == "ghi\njkl\n"
-    assert xwu.captured_stdout_as_value() == [["ghi"], ["jkl"]]
+    assert xwu.captured_stdout_as_value() == []
+
+    xwu.capture_stdout(do_capture=True)
+    print("abc")
+    print("def")
     out, err = capsys.readouterr()
-    assert out == ""
+    assert out == "abc\ndef\n"
+
+    assert xwu.captured_stdout_as_str(clear=False) == "abc\ndef\n"
+    assert xwu.captured_stdout_as_value(clear=False) == [["abc"], ["def"]]
+
+    # out, err = capsys.readouterr()
+    # assert out == "abc\ndef\n"
+
+    # xwu.clear_captured_stdout()
+    # assert xwu.captured_stdout_as_str() == ""
+    # with xwu.capture_stdout(include_print=False):
+    #     print("ghi")
+    #     print("jkl")
+    # assert xwu.captured_stdout_as_str() == "ghi\njkl\n"
+    # assert xwu.captured_stdout_as_value() == [["ghi"], ["jkl"]]
+    # out, err = capsys.readouterr()
+    # assert out == ""
 
 
 if __name__ == "__main__":

{xlwings_utils-0.0.7 → xlwings_utils-0.0.7.post1}/xlwings_utils/xlwings_utils.py

@@ -13,7 +13,8 @@ from pathlib import Path
 import os
 import sys
 
-_captured_stdout = []
+_org_stdout = sys.stdout
+
 dbx = None
 Pythonista = sys.platform == "ios"
 
@@ -217,7 +218,7 @@ def list_local(path, recursive=False, show_files=True, show_folders=False):
     show_folders : bool
         if True, show folder entries
         if False (default), do not show folder entries
-     
+
     Returns
     -------
     files, relative to path : list
@@ -268,33 +269,32 @@ class block:
     block
     """
 
-    def __init__(self, value=None, *, number_of_rows=None, number_of_columns=None,column_like=False):
+    def __init__(self, value=None, *, number_of_rows=None, number_of_columns=None, column_like=False):
         self.dict = {}
-        self.column_like=column_like
+        self.column_like = column_like
         if value is None:
             if number_of_rows is None:
-                 number_of_rows=1
+                number_of_rows = 1
             if number_of_columns is None:
-                 number_of_columns=1
-            self.number_of_rows=number_of_rows
-            self.number_of_columns=number_of_columns                 
-            
+                number_of_columns = 1
+            self.number_of_rows = number_of_rows
+            self.number_of_columns = number_of_columns
+
         else:
-            if isinstance(value,block):
-                value=value.value
-            self.value=value
+            if isinstance(value, block):
+                value = value.value
+            self.value = value
             if number_of_rows is not None:
-                self.number_of_rows=number_of_rows
+                self.number_of_rows = number_of_rows
             if number_of_columns is not None:
-                self.number_of_columns=number_of_columns            
+                self.number_of_columns = number_of_columns
 
-        
     @property
     def value(self):
         return [[self.dict.get((row, column)) for column in range(1, self.number_of_columns + 1)] for row in range(1, self.number_of_rows + 1)]
-        
+
     @value.setter
-    def value(self,value): 
+    def value(self, value):
         if not isinstance(value, list):
             value = [[value]]
         if not isinstance(value[0], list):
@@ -303,7 +303,6 @@ class block:
             else:
                 value = [value]
 
-
         self.number_of_rows = len(value)
         self._number_of_columns = 0
 
@@ -311,8 +310,7 @@ class block:
             for column, item in enumerate(row_contents, 1):
                 if item is not None:
                     self.dict[row, column] = item
-                    self._number_of_columns = max(self.number_of_columns, column)                
-
+                    self._number_of_columns = max(self.number_of_columns, column)
 
     def __setitem__(self, row_column, value):
         row, column = row_column
@@ -329,7 +327,7 @@ class block:
         if column < 1 or column > self.number_of_columns:
             raise IndexError(f"column must be between 1 and {self.number_of_columns} not {column}")
         return self.dict.get((row, column))
-        
+
     def minimized(self):
         return block(self, number_of_rows=self.highest_used_row_number, number_of_columns=self.highest_used_column_number)
 
@@ -358,7 +356,6 @@ class block:
         for row, column in list(self.dict):
             if column > self._number_of_columns:
                 del self.dict[row, column]
-    
 
     @property
     def highest_used_row_number(self):
@@ -378,14 +375,22 @@ class block:
         return f"block({self.value})"
 
 
-def clear_captured_stdout():
+def clear_captured_stdout(clear=True):
     """
     empties the captured stdout
+
+    Parameters
+    ----------
+    clear : bool
+        if True (default), the capture buffer is emptied
+
+        if False: no action
     """
-    _captured_stdout.clear()
+    if clear:
+        _buffer.clear()
 
 
-def captured_stdout_as_str():
+def captured_stdout_as_str(clear=True):
     """
     returns the captured stdout as a string
 
@@ -394,64 +399,84 @@ def captured_stdout_as_str():
     captured stdout : list
         each line is an element of the list
     """
-
-    return "".join(_captured_stdout)
+    result = "".join(_buffer)
+    clear_captured_stdout(clear)
+    return result
 
 
-def captured_stdout_as_value():
+def captured_stdout_as_value(clear=True):
     """
     returns the captured stdout as a list of lists
 
     Returns
     -------
-    captured stdout : list
+    captured stdout : list of lists
         each line is an element of the list
 
     Note
     ----
     This can be used directly to fill a xlwings range
     """
-    return [[line] for line in captured_stdout_as_str().splitlines()]
+    return [[line] for line in captured_stdout_as_str(clear).splitlines()]
+
+
+class handle_capture_stdout:
+    def __init__(self):
+        pass
+
+    def isatty(self):
+        return False
 
+    def write(self, data):
+        if _do_capture:
+            _buffer.append(data)
+        if _do_print:
+            _org_stdout.write(data)
 
-class capture_stdout:
+    def flush(self):
+        if _do_print:
+            _org_stdout.flush()
+        if _do_capture:
+            _buffer.append("\n")
+
+
+def reset():
+    global _buffer
+    global _do_print
+    global _do_capture
+    _buffer = []
+    _do_print = True
+    _do_capture = False
+
+sys.stdout = handle_capture_stdout()
+reset()
+
+def capture_stdout(do_print=True, do_capture=True, clear=True):
+    global _do_print
+    global _do_capture
     """
     start capture stdout
 
     Parameters
     ----------
-    include_print : bool
-        if True (default), the output is also printed out as normal
+    do_print : bool
+        if True (default), the output is (also) printed out as normal
 
         if False, no output is printed
 
-    Note
-    ----
-    This function is normally used as a context manager, like ::
-
-        with capture_stdout():
-            ...
-    """
-
-    def __init__(self, include_print: bool = True):
-        self.stdout = sys.stdout
-        self.include_print = include_print
-
-    def __enter__(self):
-        sys.stdout = self
+    do_capture : bool
+        if True (default), the output is (also) captured to a buffer
 
-    def __exit__(self, exc_type, exc_value, tb):
-        sys.stdout = self.stdout
+        if False, no output is captured
 
-    def write(self, data):
-        _captured_stdout.append(data)
-        if self.include_print:
-            self.stdout.write(data)
-
-    def flush(self):
-        if self.include_print:
-            self.stdout.flush()
-        _captured_stdout.append("\n")
+    clear : bool
+        if True (default), the capture buffer is emptied
+    """
+    if not (do_print or do_capture):
+        raise ValueError("at least one of do_print and do_capture should be True")
+    clear_captured_stdout(clear)
+    _do_print = do_print
+    _do_capture = do_capture
 
 
 if __name__ == "__main__":

xlwings_utils-0.0.7/README.md → xlwings_utils-0.0.7.post1/xlwings_utils.egg-info/PKG-INFO

@@ -1,118 +1,156 @@
- <img src="https://www.salabim.org/xlwings_utils_logo2.png">  
-
-## Introduction
-
-This module provides some useful functions to be used in xlwings lite.
-
-## Installation
-
-Just add xlwings-utils to the *requirement.txt* tab. It might be required to add ssl.
-
-In the script, add
-
-```ìmport xlwings_utils as xwu```
-
-## Dropbox support
-
-The xlwings lite system does not provide access to the local file system. With this module, files can be copied between Dropbox and the local pyodide file system, making it possible to indirectly use the local file system.
-
-It is only possible, as of now, to use full-access Dropbox apps.
-
-The easiest way to use the Dropbox functionality is to add the credentials to the environment variables. Add REFRESH_TOKEN, APP_KEY and APP_SECRET with their corresponding values to the environment variables.
-
-Then, it is possible to list all files in a specified folder with the function `list_dropbox`.
-It is also possible to get the folders and to access all underlying folders.
-
-The function `read_dropbox` can be used to read a Dropbox file's contents (bytes).
-
-The function `write_dropbox` can be used to write contents (bytes) to a Dropbox file.
-
-The functions `list_local`, `read_local` and `write_local` offer similar functionality for the local file system (on pyodide).
-
-So, a way to access a file on the system's drive (mapped to Dropbox) as a local file is:
-
-```
-contents = xlwings_utils.read_dropbox('/downloads/file1.xls')
-xlwings_utils.write_local('file1.xlsx')
-df = pandas.read_excel"file1.xlsx")
-...
-```
-And the other direction:
-```
-contents = xlwings_utils.read_local('file1.gif')
-xlwings_utils.write_dropbox('/downloads/file1.gif')
-```
-
-## Block support
-
-The module contains a useful 2-dimensional data structure: *block*.
-This can be useful to manipulate a range without accessing the range directly, which is expensive in terms of memory and execution time.
-The advantage over an ordinary list of lists is that a block is index one-based, in line with range and addressing is done with a row, column tuple.
-So, `my_block(lol)[row, col]` is roughly equivalent to `lol[row-1][col-1]`
-
-A block stores the values internally as a dictionary and will only convert these to a list of lists when using `block.value`. 
-
-Converting the value of a range (usually a list of lists, but can also be a list or scalar) to a block can be done with
-
-```
-my_block = xwu.block.from_value(range.value)
-```
-The dimensions (number of rows and number of columns) are automatically set.
-
-Setting of an individual item (one-based, like range) can be done like
-```
-my_block[row, column] = x
-```
-And, likewise, reading an individual item can be done like
-```
-x = my_block[row, column]
-```
-It is not allowed t,o read or write outside the block dimensions.
-
-It is also possible to define an empty block, like
-```
-block = xlwings_utils.block(number_of_rows, number_columns)
-```
-The dimensions can be queried or redefined with `block.number_of_rows` and 
-`block.number_of_columns`.
-
-To assign a block to range, use
-```
-range.value = block.value
-```
-
-The property `block.highest`_used_row_number returns the
-
-The method `block.minimized()` returns a block that has the dimensions of (highest_used_row_number, highest_used_column_number). 
-
-## Capture stdout support
-
-The module has support for capturing stdout and -later- using showing the captured output on a sheet.
-
-To do that:
-
-```makes it possible to capture stdout writes, which
-with xwu.capture_stdout():
-    ...
-```
-and then the captured output can be copied to the screen, like
-
-```can then be copied to a worksheet in a later stage.
-sheet.range(4,5).value = xwu.captured_stdout_as_value()
-```
-
-Clearing the captured stdout buffer can be done with `xwu.clear_captured_std_out`.
-
-Normally, stdout will be also sent to the xlwings lite UI panel. This can be suppressed with
-
-```
-with xwu.capture_stdout(include_print=False):
-    ...
-```
-
-## Badges
-
-![PyPI](https://img.shields.io/pypi/v/xlwings-utils) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/xlwings-utils) ![PyPI - Implementation](https://img.shields.io/pypi/implementation/xlwings-utils)
-![PyPI - License](https://img.shields.io/pypi/l/xlwings-utils) ![ruff](https://img.shields.io/badge/style-ruff-41B5BE?style=flat) 
-![GitHub last commit](https://img.shields.io/github/last-commit/salabim/peek)
-
+Metadata-Version: 2.4
+Name: xlwings_utils
+Version: 0.0.7.post1
+Summary: xlwings_utils
+Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
+Project-URL: Homepage, https://github.com/salabim/xlwings_utils
+Project-URL: Repository, https://github.com/salabim/xlwings_utils
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: dropbox
+Requires-Dist: ssl
+
+ <img src="https://www.salabim.org/xlwings_utils_logo2.png">  
+
+## Introduction
+
+This module provides some useful functions to be used in xlwings (lite).
+
+## Installation
+
+Just add xlwings-utils to the *requirements.txt* tab. 
+
+In the script, add
+
+```ìmport xlwings_utils as xwu```
+
+> [!NOTE]
+>
+> The GitHub repository can be found on https://github.com/salabim/xlwings_utils .
+
+## Dropbox support
+
+The xlwings lite system does not provide access to the local file system. With this module, files can be copied between Dropbox and the local pyodide file system, making it possible to indirectly use the local file system.
+
+It is only possible, as of now, to use full-access Dropbox apps.
+
+The easiest way to use the Dropbox functionality is to add the credentials to the environment variables. Add REFRESH_TOKEN, APP_KEY and APP_SECRET with their corresponding values to the environment variables.
+
+Then, it is possible to list all files in a specified folder with the function `list_dropbox`.
+It is also possible to get the folders and to access all underlying folders.
+
+The function `read_dropbox` can be used to read a Dropbox file's contents (bytes).
+
+The function `write_dropbox` can be used to write contents (bytes) to a Dropbox file.
+
+The functions `list_local`, `read_local` and `write_local` offer similar functionality for the local file system (on pyodide).
+
+So, a way to access a file on the system's drive (mapped to Dropbox) as a local file is:
+
+```
+contents = xlwings_utils.read_dropbox('/downloads/file1.xls')
+xlwings_utils.write_local('file1.xlsx')
+df = pandas.read_excel"file1.xlsx")
+...
+```
+And the other direction:
+```
+contents = xlwings_utils.read_local('file1.gif')
+xlwings_utils.write_dropbox('/downloads/file1.gif')
+```
+
+## Block support
+
+The module contains a useful 2-dimensional data structure: *block*.
+This can be useful to manipulate a range without accessing the range directly, which is expensive in terms of memory and execution time.
+The advantage over an ordinary list of lists is that a block is index one-based, in line with range and addressing is done with a row, column tuple.
+So, `my_block(lol)[row, col]` is roughly equivalent to `lol[row-1][col-1]`
+
+A block stores the values internally as a dictionary and will only convert these to a list of lists when using `block.value`. 
+
+Converting the value of a range (usually a list of lists, but can also be a list or scalar) to a block can be done with
+
+```
+my_block = xwu.block.from_value(range.value)
+```
+The dimensions (number of rows and number of columns) are automatically set.
+
+Setting of an individual item (one-based, like range) can be done like
+```
+my_block[row, column] = x
+```
+And, likewise, reading an individual item can be done like
+```
+x = my_block[row, column]
+```
+It is not allowed t,o read or write outside the block dimensions.
+
+It is also possible to define an empty block, like
+```
+block = xlwings_utils.block(number_of_rows, number_columns)
+```
+The dimensions can be queried or redefined with `block.number_of_rows` and 
+`block.number_of_columns`.
+
+To assign a block to range, use
+```
+range.value = block.value
+```
+
+The property `block.highest_used_row_number` returns the row number of the highest non-None cell.
+
+The property `block.highest_used_column_number` returns the column_number of the highest non-None cell.
+
+The method `block.minimized()` returns a block that has the dimensions of (highest_used_row_number, highest_used_column_number). 
+
+Particularly if we process an unknown number of lines, we can do something like:
+
+```
+this_block = xwu.block(number_of_rows=10000, number_of_columns=2)
+for row in range(1, 10001):
+	this_block[row,1]= ...
+	this_block[row,2]= ...
+	if ...: # end condition
+	    break
+sheet.range(10,1).value = this_block.minimized().value
+```
+
+In this case, only the really processed rows are copied to the sheet.
+
+## Capture stdout support
+
+The module has support for capturing stdout and -later- using showing the captured output on a sheet.
+
+To do that:
+
+```makes it possible to capture stdout writes, which
+with xwu.capture_stdout():
+    ...
+```
+and then the captured output can be copied to the screen, like
+
+```can then be copied to a worksheet in a later stage.
+sheet.range(4,5).value = xwu.captured_stdout_as_value()
+```
+
+Clearing the captured stdout buffer can be done with `xwu.clear_captured_std_out`.
+
+Normally, stdout will also be sent to the xlwings lite UI panel. This can be suppressed with
+
+```
+with xwu.capture_stdout(include_print=False):
+    ...
+```
+
+## Contact info
+
+You can contact Ruud van der Ham, the core developer, via ruud@salabim.org .
+
+## Badges
+
+![PyPI](https://img.shields.io/pypi/v/xlwings-utils) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/xlwings-utils) ![PyPI - Implementation](https://img.shields.io/pypi/implementation/xlwings-utils)
+![PyPI - License](https://img.shields.io/pypi/l/xlwings-utils) ![ruff](https://img.shields.io/badge/style-ruff-41B5BE?style=flat) 
+![GitHub last commit](https://img.shields.io/github/last-commit/salabim/peek)
+