xlwings-utils 25.0.0.post1__tar.gz → 25.0.0.post2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xlwings_utils
-Version: 25.0.0.post1
+Version: 25.0.0.post2
 Summary: xlwings_utils
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://github.com/salabim/xlwings_utils
@@ -119,6 +119,54 @@ sheet.range(10,1).value = this_block.minimized().value
 
 In this case, only the really processed rows are copied to the sheet.
 
+With blocks, it is easy to use a sheet as an input for a project / scenario.
+
+Like, something like
+
+
+Of course we could access the various input fields with absolute ranges, but if something
+changes later (like adding a row), all references have to be updated.
+
+If we read the project sheet (partly) into a block, lookup methods are available to access 'fields' easily and future proof.
+
+Let's see how this works with the above sheet. The block (bl) looks like
+
+```
+  |   1                2                3                4                5
+--+-------------------------------------------------------------------------------     
+1 |   Project          Factory1
+2 |   Name             Mega1
+3 |   Start date       2025-05-17
+4 |   End date         2026-02-01
+5 | 
+6 |   Parts            Width            Length           Height           Weight
+7 |   A                10               5                5                100
+8 |   B                11               5                8                102
+9 |   C                12               2                3                91        
+10|   
+
+Now we can do
+project  = bl.lookup("Project")
+name = bl.lookup("Start date")
+start_date = bl.lookup("Start date")
+end_date = bl.lookup("End date")
+row1 = bl.lookup_row("Parts")
+parts=[]
+for row2 in range(row1 + 1, bl.highest_used_row_number + 1):
+    if not (part_name := bl.hlookup("Part",row1=row1, row2=row2)):
+        # stop when reach a 'blank' part_name
+        break
+    width = bl.hlookup("Width",row1=row1, row2=row2)
+    length = bl.hlookup("Length",row1=row1, row2=row2)  
+    height = bl.hlookup("HeightL",row1=row1, row2=row2)  
+    weight = bl.hlookup("Weight",row1=row1, row2=row2)         
+    parts.append(Part(part_name, width, length, height, weight))
+       
+You see lookup, which is vertical lookup, which just scans column 1 for the given label and then returns the corresponding value from column 2.
+
+Then, there's lookup_row, which also scans column1 for the given label (Parts), but returns the corresponding row (6). Store it in row1.
+And then we just read the following rows (with hlookup) and access the required values.
+
 ## Capture stdout support
 
 The module has support for capturing stdout and -later- using showing the captured output on a sheet.

xlwings_utils-25.0.0.post1/PKG-INFO → xlwings_utils-25.0.0.post2/README.md

@@ -1,163 +1,197 @@
-Metadata-Version: 2.4
-Name: xlwings_utils
-Version: 25.0.0.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.
-
-This is rather important as printing in xlwings lite to the UI pane is rather slow.
-
-In order to capture stdout output, use
-
-
-```
-with xwu.capture:
-    """
-    code with print statements
-    """
-```
-
-and then the captured output can be copied to a sheet, like
-
-```
-sheet.range(4,5).value = xwu.capture.value
-```
-Upon reading the value, the capture buffer will be emptied.
-
-If you don't want the buffer to be emptied after accessing the value, use `xwu.capture.value_keep`.
-
-The capture buffer can also be retrieved as a string with `xwu.capture.str` and `xwu.capture.str_keep`.
-
-Clearing the captured stdout buffer can be done at any time with `xwu.capture.clear()`.
-
-Normally, stdout will not be sent to the xlwings lite UI panel when captured with the `xwu.capture` context manager. However, if you specify `xwu.capture.include_print = True`, the output will be sent to the UI panel as well. Note that this setting remains active until a `xwu.capture.include_print = False` is issued.
-
-
-## 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)
-
+ <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.
+
+With blocks, it is easy to use a sheet as an input for a project / scenario.
+
+Like, something like
+
+
+Of course we could access the various input fields with absolute ranges, but if something
+changes later (like adding a row), all references have to be updated.
+
+If we read the project sheet (partly) into a block, lookup methods are available to access 'fields' easily and future proof.
+
+Let's see how this works with the above sheet. The block (bl) looks like
+
+```
+  |   1                2                3                4                5
+--+-------------------------------------------------------------------------------     
+1 |   Project          Factory1
+2 |   Name             Mega1
+3 |   Start date       2025-05-17
+4 |   End date         2026-02-01
+5 | 
+6 |   Parts            Width            Length           Height           Weight
+7 |   A                10               5                5                100
+8 |   B                11               5                8                102
+9 |   C                12               2                3                91        
+10|   
+
+Now we can do
+project  = bl.lookup("Project")
+name = bl.lookup("Start date")
+start_date = bl.lookup("Start date")
+end_date = bl.lookup("End date")
+row1 = bl.lookup_row("Parts")
+parts=[]
+for row2 in range(row1 + 1, bl.highest_used_row_number + 1):
+    if not (part_name := bl.hlookup("Part",row1=row1, row2=row2)):
+        # stop when reach a 'blank' part_name
+        break
+    width = bl.hlookup("Width",row1=row1, row2=row2)
+    length = bl.hlookup("Length",row1=row1, row2=row2)  
+    height = bl.hlookup("HeightL",row1=row1, row2=row2)  
+    weight = bl.hlookup("Weight",row1=row1, row2=row2)         
+    parts.append(Part(part_name, width, length, height, weight))
+       
+You see lookup, which is vertical lookup, which just scans column 1 for the given label and then returns the corresponding value from column 2.
+
+Then, there's lookup_row, which also scans column1 for the given label (Parts), but returns the corresponding row (6). Store it in row1.
+And then we just read the following rows (with hlookup) and access the required values.
+
+## Capture stdout support
+
+The module has support for capturing stdout and -later- using showing the captured output on a sheet.
+
+This is rather important as printing in xlwings lite to the UI pane is rather slow.
+
+In order to capture stdout output, use
+
+
+```
+with xwu.capture:
+    """
+    code with print statements
+    """
+```
+
+and then the captured output can be copied to a sheet, like
+
+```
+sheet.range(4,5).value = xwu.capture.value
+```
+Upon reading the value, the capture buffer will be emptied.
+
+If you don't want the buffer to be emptied after accessing the value, use `xwu.capture.value_keep`.
+
+The capture buffer can also be retrieved as a string with `xwu.capture.str` and `xwu.capture.str_keep`.
+
+Clearing the captured stdout buffer can be done at any time with `xwu.capture.clear()`.
+
+Normally, stdout will not be sent to the xlwings lite UI panel when captured with the `xwu.capture` context manager. However, if you specify `xwu.capture.include_print = True`, the output will be sent to the UI panel as well. Note that this setting remains active until a `xwu.capture.include_print = False` is issued.
+
+
+## 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-25.0.0.post1 → xlwings_utils-25.0.0.post2}/pyproject.toml

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

{xlwings_utils-25.0.0.post1 → xlwings_utils-25.0.0.post2}/xlwings_utils/xlwings_utils.py

@@ -12,6 +12,7 @@ import dropbox
 from pathlib import Path
 import os
 import sys
+import math
 
 dbx = None
 Pythonista = sys.platform == "ios"
@@ -287,6 +288,17 @@ class block:
             if number_of_columns is not None:
                 self.number_of_columns = number_of_columns
 
+    @classmethod
+    def from_xlrd_sheet(cls,sheet, number_of_rows=None, number_of_columns=None):
+        v = [sheet.row_values(row_idx)[0 : sheet.ncols] for row_idx in range(0, sheet.nrows)]
+        return cls(v, number_of_rows=number_of_rows, number_of_columns=number_of_columns)
+
+
+    @classmethod
+    def from_dataframe(cls,df, number_of_rows=None, number_of_columns=None):
+        v=df.values.tolist()
+        return cls(v, number_of_rows=number_of_rows, 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)]
@@ -306,7 +318,7 @@ class block:
 
         for row, row_contents in enumerate(value, 1):
             for column, item in enumerate(row_contents, 1):
-                if item is not None:
+                if item and not (isinstance(item,float) and math.isnan(item)):
                     self.dict[row, column] = item
                     self._number_of_columns = max(self.number_of_columns, column)
 
@@ -327,6 +339,12 @@ class block:
         return self.dict.get((row, column))
 
     def minimized(self):
+        """
+        Returns
+        -------
+        minimized block : block
+             uses highest_used_row_number and highest_used_column_number to minimize the block
+        """
         return block(self, number_of_rows=self.highest_used_row_number, number_of_columns=self.highest_used_column_number)
 
     @property
@@ -385,6 +403,42 @@ class block:
             raise ValueError(f"{name}={column} > number_of_columns={self.number_of_columns}")
 
     def vlookup(self, s, *, row_from=1, row_to=None, column1=1, column2=None):
+        """
+        searches in column1 for row between row_from and row_to for s and returns the value found at (that row, column2)
+        
+        Parameters
+        ----------
+        s : any
+            value to seach for
+            
+        row_from : int
+             row to start search (default 1)
+             
+             should be between 1 and number_of_rows
+     
+        row_to : int
+             row to end search (default number_of_rows)
+             
+             should be between 1 and number_of_rows         
+             
+        column1 : int
+             column to search in (default 1)
+             
+             should be between 1 and number_of_columns
+             
+        column2 : int
+             column to return looked up value from (default column1 + 1)
+             
+             should be between 1 and number_of_columns             
+             
+        Returns
+        -------
+        block[found row number, column2] : any
+        
+        Note
+        ----
+        If s is not found, a ValueError is raised
+        """
         if column2 is None:
             column2 = column1 + 1
         self._check_column(column2, "column2")
@@ -392,6 +446,40 @@ class block:
         return self[row, column2]
 
     def lookup_row(self, s, *, row_from=1, row_to=None, column1=1):
+        """
+        searches in column1 for row between row_from and row_to for s and returns that row number
+        
+        Parameters
+        ----------
+        s : any
+            value to seach for
+            
+        row_from : int
+             row to start search (default 1)
+             
+             should be between 1 and number_of_rows
+     
+        row_to : int
+             row to end search (default number_of_rows)
+             
+             should be between 1 and number_of_rows         
+             
+        column1 : int
+             column to search in (default 1)
+             
+             should be between 1 and number_of_columns
+             
+        column2 : int
+             column to return looked up value from (default column1 + 1)
+             
+        Returns
+        -------
+        row number where block[row nunber, column1] == s : int  
+             
+        Note
+        ----
+        If s is not found, a ValueError is raised
+        """
         if row_to is None:
             row_to = self.highest_used_row_number
         self._check_row(row_from, "row_from")
@@ -404,13 +492,83 @@ class block:
         raise ValueError(f"{s} not found")
 
     def hlookup(self, s, *, column_from=1, column_to=None, row1=1, row2=None):
-        if row2 is None:
+        """
+        searches in row1 for column between column_from and column_to for s and returns the value found at (that column, row2)
+        
+        Parameters
+        ----------
+        s : any
+            value to seach for
+            
+        column_from : int
+             column to start search (default 1)
+             
+             should be between 1 and number_of_columns
+     
+        column_to : int
+             column to end search (default number_of_columns)
+             
+             should be between 1 and number_of_columns         
+             
+        row1 : int
+             row to search in (default 1)
+             
+             should be between 1 and number_of_rows
+             
+        row2 : int
+             row to return looked up value from (default row1 + 1)
+             
+             should be between 1 and number_of_rows             
+             
+        Returns
+        -------
+        block[row, found column, row2] : any
+        
+        Note
+        ----
+        If s is not found, a ValueError is raised
+        """
+        if column2 is None:
             row2 = row1 + 1
         self._check_row(row2, "row2")
         column = self.lookup_column(s, column_from=column_from, column_to=column_to, row1=row1)
         return self[row2, column]
 
     def lookup_column(self, s, *, column_from=1, column_to=None, row1=1):
+        """
+        searches in row1 for column between column_from and column_to for s and returns that column number
+        
+        Parameters
+        ----------
+        s : any
+            value to seach for
+            
+        column_from : int
+             column to start search (default 1)
+             
+             should be between 1 and number_of_columns
+     
+        column_to : int
+             column to end search (default number_of_columns)
+             
+             should be between 1 and number_of_columns         
+             
+        row1 : int
+             row to search in (default 1)
+             
+             should be between 1 and number_of_rows
+             
+        row2 : int
+             row to return looked up value from (default row1 + 1)
+             
+        Returns
+        -------
+        column number where block[row1, column number] == s : int  
+             
+        Note
+        ----
+        If s is not found, a ValueError is raised
+        """
         if column_to is None:
             column_to = self.highest_used_column_number
         self._check_column(column_from, "column_from")
@@ -423,6 +581,44 @@ class block:
         raise ValueError(f"{s} not found")
 
     def lookup(self, s, *, row_from=1, row_to=None, column1=1, column2=None):
+        """
+        searches in column1 for row between row_from and row_to for s and returns the value found at (that row, column2)
+        
+        Parameters
+        ----------
+        s : any
+            value to seach for
+            
+        row_from : int
+             row to start search (default 1)
+             
+             should be between 1 and number_of_rows
+     
+        row_to : int
+             row to end search (default number_of_rows)
+             
+             should be between 1 and number_of_rows         
+             
+        column1 : int
+             column to search in (default 1)
+             
+             should be between 1 and number_of_columns
+             
+        column2 : int
+             column to return looked up value from (default column1 + 1)
+             
+             should be between 1 and number_of_columns             
+             
+        Returns
+        -------
+        block[found row number, column2] : any
+        
+        Note
+        ----
+        If s is not found, a ValueError is raised
+        
+        This is exactly the same as vlookup.
+        """
         return self.vlookup(s, row_from=row_from, row_to=row_to, column1=column1, column2=column2)
 
 

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

@@ -1,149 +1,211 @@
- <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.
-
-This is rather important as printing in xlwings lite to the UI pane is rather slow.
-
-In order to capture stdout output, use
-
-
-```
-with xwu.capture:
-    """
-    code with print statements
-    """
-```
-
-and then the captured output can be copied to a sheet, like
-
-```
-sheet.range(4,5).value = xwu.capture.value
-```
-Upon reading the value, the capture buffer will be emptied.
-
-If you don't want the buffer to be emptied after accessing the value, use `xwu.capture.value_keep`.
-
-The capture buffer can also be retrieved as a string with `xwu.capture.str` and `xwu.capture.str_keep`.
-
-Clearing the captured stdout buffer can be done at any time with `xwu.capture.clear()`.
-
-Normally, stdout will not be sent to the xlwings lite UI panel when captured with the `xwu.capture` context manager. However, if you specify `xwu.capture.include_print = True`, the output will be sent to the UI panel as well. Note that this setting remains active until a `xwu.capture.include_print = False` is issued.
-
-
-## 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)
-
+Metadata-Version: 2.4
+Name: xlwings_utils
+Version: 25.0.0.post2
+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.
+
+With blocks, it is easy to use a sheet as an input for a project / scenario.
+
+Like, something like
+
+
+Of course we could access the various input fields with absolute ranges, but if something
+changes later (like adding a row), all references have to be updated.
+
+If we read the project sheet (partly) into a block, lookup methods are available to access 'fields' easily and future proof.
+
+Let's see how this works with the above sheet. The block (bl) looks like
+
+```
+  |   1                2                3                4                5
+--+-------------------------------------------------------------------------------     
+1 |   Project          Factory1
+2 |   Name             Mega1
+3 |   Start date       2025-05-17
+4 |   End date         2026-02-01
+5 | 
+6 |   Parts            Width            Length           Height           Weight
+7 |   A                10               5                5                100
+8 |   B                11               5                8                102
+9 |   C                12               2                3                91        
+10|   
+
+Now we can do
+project  = bl.lookup("Project")
+name = bl.lookup("Start date")
+start_date = bl.lookup("Start date")
+end_date = bl.lookup("End date")
+row1 = bl.lookup_row("Parts")
+parts=[]
+for row2 in range(row1 + 1, bl.highest_used_row_number + 1):
+    if not (part_name := bl.hlookup("Part",row1=row1, row2=row2)):
+        # stop when reach a 'blank' part_name
+        break
+    width = bl.hlookup("Width",row1=row1, row2=row2)
+    length = bl.hlookup("Length",row1=row1, row2=row2)  
+    height = bl.hlookup("HeightL",row1=row1, row2=row2)  
+    weight = bl.hlookup("Weight",row1=row1, row2=row2)         
+    parts.append(Part(part_name, width, length, height, weight))
+       
+You see lookup, which is vertical lookup, which just scans column 1 for the given label and then returns the corresponding value from column 2.
+
+Then, there's lookup_row, which also scans column1 for the given label (Parts), but returns the corresponding row (6). Store it in row1.
+And then we just read the following rows (with hlookup) and access the required values.
+
+## Capture stdout support
+
+The module has support for capturing stdout and -later- using showing the captured output on a sheet.
+
+This is rather important as printing in xlwings lite to the UI pane is rather slow.
+
+In order to capture stdout output, use
+
+
+```
+with xwu.capture:
+    """
+    code with print statements
+    """
+```
+
+and then the captured output can be copied to a sheet, like
+
+```
+sheet.range(4,5).value = xwu.capture.value
+```
+Upon reading the value, the capture buffer will be emptied.
+
+If you don't want the buffer to be emptied after accessing the value, use `xwu.capture.value_keep`.
+
+The capture buffer can also be retrieved as a string with `xwu.capture.str` and `xwu.capture.str_keep`.
+
+Clearing the captured stdout buffer can be done at any time with `xwu.capture.clear()`.
+
+Normally, stdout will not be sent to the xlwings lite UI panel when captured with the `xwu.capture` context manager. However, if you specify `xwu.capture.include_print = True`, the output will be sent to the UI panel as well. Note that this setting remains active until a `xwu.capture.include_print = False` is issued.
+
+
+## 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)
+