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

xlwings_utils-0.0.7/PKG-INFO

@@ -0,0 +1,132 @@
+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)
+

xlwings_utils-0.0.7/README.md

@@ -0,0 +1,118 @@
+ <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)
+

{xlwings_utils-0.0.6 → xlwings_utils-0.0.7}/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.6"
+version = "0.0.7"
 readme = "README.md"
 requires-python = ">=3.9"
 dependencies = [

xlwings_utils-0.0.7/tests/test_xlwings_utils.py

@@ -0,0 +1,128 @@
+import os
+import sys
+from pathlib import Path
+
+if __name__ == "__main__":  # to make the tests run without the pytest cli
+    file_folder = os.path.dirname(__file__)
+    os.chdir(file_folder)
+    sys.path.insert(0, file_folder + "/../xlwings_utils")
+
+import pytest
+
+import xlwings_utils as xwu
+
+
+def test_block0():
+    this_block = xwu.block(number_of_rows=4, number_of_columns=6)
+    this_block[1, 2] = 2
+    this_block[2, 5] = 25
+    assert this_block.dict == {(1, 2): 2, (2, 5): 25}
+    assert this_block.value == [
+        [None, 2, None, None, None, None],
+        [None, None, None, None, 25, None],
+        [None, None, None, None, None, None],
+        [None, None, None, None, None, None],
+    ]
+    assert this_block.minimized().value == [[None, 2, None, None, None], [None, None, None, None, 25]]
+    assert this_block.number_of_rows == 4
+    assert this_block.number_of_columns == 6
+    assert this_block.highest_used_row_number == 2
+    assert this_block.highest_used_column_number == 5
+
+    this_block.number_of_rows = 99
+    this_block.number_of_columns = 99
+    assert this_block.highest_used_row_number == 2
+    assert this_block.highest_used_column_number == 5
+
+    this_block.number_of_rows = 1
+    this_block.number_of_columns = 3
+    assert this_block.value == [[None, 2, None]]
+    assert this_block.minimized().value == [[None, 2]]
+
+
+def test_block1():
+    this_block = xwu.block([[1, 2, 3], [4, 5, 6]])
+    assert this_block.dict == {(1, 1): 1, (1, 2): 2, (1, 3): 3, (2, 1): 4, (2, 2): 5, (2, 3): 6}
+    assert this_block.value == [[1, 2, 3], [4, 5, 6]]
+    assert this_block.minimized().value == [[1, 2, 3], [4, 5, 6]]
+    with pytest.raises(ValueError):
+        this_block.number_of_rows = 0
+    with pytest.raises(ValueError):
+        this_block.number_of_columns = 0
+    with pytest.raises(ValueError):
+        this_block = xwu.block(number_of_rows=0, number_of_columns=1)
+    with pytest.raises(ValueError):
+        this_block = xwu.block(number_of_rows=1, number_of_columns=0)
+
+
+def test_block2():
+    this_block = xwu.block([[1, 2, 3], [4, 5, 6]], number_of_rows=1)
+    assert this_block.value == [[1, 2, 3]]
+
+    this_block = xwu.block([[1, 2, 3], [4, 5, 6]], number_of_rows=1, number_of_columns=2)
+    assert this_block.value == [[1, 2]]
+
+    this_block = xwu.block([[1, 2, 3], [4, 5, 6]], number_of_rows=3, number_of_columns=4)
+    assert this_block.value == [[1, 2, 3, None], [4, 5, 6, None], [None, None, None, None]]
+
+
+def test_block_one_dimension():
+    this_block = xwu.block([1, 2, 3])
+    assert this_block.value == [[1, 2, 3]]
+
+    this_block = xwu.block([1, 2, 3], column_like=True)
+    assert this_block.value == [[1], [2], [3]]
+
+
+def test_block_scalar():
+    this_block = xwu.block(1)
+    assert this_block.value == [[1]]
+
+
+def test_raise():
+    this_block = xwu.block(number_of_rows=4, number_of_columns=6)
+    with pytest.raises(IndexError):
+        a = this_block[0, 1]
+    with pytest.raises(IndexError):
+        a = this_block[5, 1]
+
+    with pytest.raises(IndexError):
+        a = this_block[1, 0]
+    with pytest.raises(IndexError):
+        a = this_block[1, 7]
+
+    with pytest.raises(IndexError):
+        this_block[0, 1] = 1
+    with pytest.raises(IndexError):
+        this_block[5, 1] = 1
+
+    with pytest.raises(IndexError):
+        this_block[1, 0] = 1
+    with pytest.raises(IndexError):
+        this_block[1, 7] = 1
+
+
+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"]]
+
+    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__":
+    pytest.main(["-vv", "-s", "-x", __file__])
+

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

@@ -5,7 +5,7 @@
 #  /_/\_\|_|  \_/\_/  |_||_| |_| \__, ||___/ _____  \__,_| \__||_||_||___/
 #                                |___/      |_____|
 
-__version__ = "0.0.6"
+__version__ = "0.0.7"
 
 
 import dropbox
@@ -268,55 +268,51 @@ class block:
     block
     """
 
-    def __init__(self, number_of_rows, number_of_columns):
+    def __init__(self, value=None, *, number_of_rows=None, number_of_columns=None,column_like=False):
         self.dict = {}
-        self.number_of_columns = number_of_columns
-        self.number_of_rows = number_of_rows
-
-    @classmethod
-    def from_list_of_lists(cls, list_of_lists, column_like=False):
-        """
-        from_list_of_lists
-
-        Parameters
-        ----------
-        list_of_lists : list of lists
-            to be used to fill the block
-
-        columns_like : bool
-            if False (default), one dimenional lists will be treated as a 1 high range (row-like)
-
-            if True, one dimenional lists will be treated as a 1 wide range (column-like)
-
-            This parameter is not used for proper 2 dimensional list of lists or scalars
-
-        Returns
-        -------
-        block
-
-        Note
-        ----
-        number_of_rows and number_of_columns will be retrieved from list_of_lists dimension
-        """
-        if not isinstance(list_of_lists, list):
-            list_of_lists = [[list_of_lists]]
-        if not isinstance(list_of_lists[0], list):
-            if column_like:
-                list_of_lists = [[value] for value in list_of_lists]
+        self.column_like=column_like
+        if value is None:
+            if number_of_rows is None:
+                 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                 
+            
+        else:
+            if isinstance(value,block):
+                value=value.value
+            self.value=value
+            if number_of_rows is not None:
+                self.number_of_rows=number_of_rows
+            if number_of_columns is not None:
+                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): 
+        if not isinstance(value, list):
+            value = [[value]]
+        if not isinstance(value[0], list):
+            if self.column_like:
+                value = [[item] for item in value]
             else:
-                list_of_lists = [list_of_lists]
+                value = [value]
 
-        self = cls(1, 1)
 
-        self.number_of_rows = len(list_of_lists)
+        self.number_of_rows = len(value)
         self._number_of_columns = 0
 
-        for row, row_contents in enumerate(list_of_lists, 1):
-            for column, value in enumerate(row_contents, 1):
-                if value is not None:
-                    self.dict[row, column] = value
-                    self._number_of_columns = max(self.number_of_columns, column)
-        return self
+        for row, row_contents in enumerate(value, 1):
+            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)                
+
 
     def __setitem__(self, row_column, value):
         row, column = row_column
@@ -333,14 +329,9 @@ 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))
-
-    @property
-    def as_list_of_lists(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)]
-
-    @property
-    def as_minimal_list_of_lists(self):
-        return [[self.dict.get((row, column)) for column in range(1, self.maximum_column + 1)] for row in range(1, self.maximum_row + 1)]
+        
+    def minimized(self):
+        return block(self, number_of_rows=self.highest_used_row_number, number_of_columns=self.highest_used_column_number)
 
     @property
     def number_of_rows(self):
@@ -367,23 +358,24 @@ class block:
         for row, column in list(self.dict):
             if column > self._number_of_columns:
                 del self.dict[row, column]
+    
 
     @property
-    def maximum_row(self):
+    def highest_used_row_number(self):
         if self.dict:
             return max(row for (row, column) in self.dict)
         else:
             return 1
 
     @property
-    def maximum_column(self):
+    def highest_used_column_number(self):
         if self.dict:
             return max(column for (row, column) in self.dict)
         else:
             return 1
 
     def __repr__(self):
-        return f"block.from_list_of_lists({self.as_list_of_lists})"
+        return f"block({self.value})"
 
 
 def clear_captured_stdout():
@@ -406,7 +398,7 @@ def captured_stdout_as_str():
     return "".join(_captured_stdout)
 
 
-def captured_stdout_as_list_of_lists():
+def captured_stdout_as_value():
     """
     returns the captured stdout as a list of lists
 

xlwings_utils-0.0.7/xlwings_utils.egg-info/PKG-INFO

@@ -0,0 +1,132 @@
+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)
+

xlwings_utils-0.0.6/PKG-INFO

@@ -1,52 +0,0 @@
-Metadata-Version: 2.4
-Name: xlwings_utils
-Version: 0.0.6
-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_logo1.png"> 
-
-## Introduction
-
-This module provides some useful functions to be used in xlwings lite.
-
-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 systen. And
-therefore, it is possible to indirectly use the local file system.
-
-The module contains support for a useful 2 dimensional data structure: block.
-Thjs can be useful to manipulate a range without accessing the range directly,
-which is expensive in terms of memory and execution time.
-
-On top of that, this module makes it possible to capture stdout writes, which
-can then be copied to a worksheet in a later stage.
-
-## Installation
-
-Just add xlwings-utils to the requirement tab. It might be required to add ssl.
-
-## Dropbox support
-
-xlwings_lite only works with full access dropbox apps.
-
-In order to use dropbox functionality, is is necessary to initialize the module with credentials.
-
-```xwu.dropbox_init()```
-If called without parameters, the refresh_token is
-
-## Capture stdout support
-
- 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.6/README.md

@@ -1,38 +0,0 @@
- <img src="https://www.salabim.org/xlwings_utils_logo1.png"> 
-
-## Introduction
-
-This module provides some useful functions to be used in xlwings lite.
-
-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 systen. And
-therefore, it is possible to indirectly use the local file system.
-
-The module contains support for a useful 2 dimensional data structure: block.
-Thjs can be useful to manipulate a range without accessing the range directly,
-which is expensive in terms of memory and execution time.
-
-On top of that, this module makes it possible to capture stdout writes, which
-can then be copied to a worksheet in a later stage.
-
-## Installation
-
-Just add xlwings-utils to the requirement tab. It might be required to add ssl.
-
-## Dropbox support
-
-xlwings_lite only works with full access dropbox apps.
-
-In order to use dropbox functionality, is is necessary to initialize the module with credentials.
-
-```xwu.dropbox_init()```
-If called without parameters, the refresh_token is
-
-## Capture stdout support
-
- 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.6/tests/test_xlwings_utils.py

@@ -1,113 +0,0 @@
-import os
-import sys
-from pathlib import Path
-
-if __name__ == "__main__":  # to make the tests run without the pytest cli
-    file_folder = os.path.dirname(__file__)
-    os.chdir(file_folder)
-    sys.path.insert(0, file_folder + "/../xlwings_utils")
-
-import pytest
-
-import xlwings_utils as xwu
-
-def test_block():
-    this_block = xwu.block(number_of_rows=4, number_of_columns=6)
-    this_block[1, 2] = 2
-    this_block[2, 5] = 25
-    assert this_block.dict == {(1, 2): 2, (2, 5): 25}
-    assert this_block.as_list_of_lists == [
-        [None, 2, None, None, None, None],
-        [None, None, None, None, 25, None],
-        [None, None, None, None, None, None],
-        [None, None, None, None, None, None],
-    ]
-    assert this_block.as_minimal_list_of_lists == [[None, 2, None, None, None], [None, None, None, None, 25]]
-    assert this_block.number_of_rows == 4
-    assert this_block.number_of_columns == 6
-    assert this_block.maximum_row == 2
-    assert this_block.maximum_column == 5
-
-    this_block.number_of_rows = 99
-    this_block.number_of_columns = 99
-    assert this_block.maximum_row == 2
-    assert this_block.maximum_column == 5
-
-    this_block.number_of_rows = 1
-    this_block.number_of_columns = 3
-    assert this_block.as_list_of_lists == [[None, 2, None]]
-    assert this_block.as_minimal_list_of_lists == [[None, 2]]
-
-
-def test_block_from_list_of_lists():
-    this_block = xwu.block.from_list_of_lists([[1, 2, 3], [4, 5, 6]])
-    assert this_block.dict == {(1, 1): 1, (1, 2): 2, (1, 3): 3, (2, 1): 4, (2, 2): 5, (2, 3): 6}
-    assert this_block.as_list_of_lists == [[1, 2, 3], [4, 5, 6]]
-    assert this_block.as_minimal_list_of_lists == [[1, 2, 3], [4, 5, 6]]
-    with pytest.raises(ValueError):
-        this_block.number_of_rows = 0
-    with pytest.raises(ValueError):
-        this_block.number_of_columns = 0
-    with pytest.raises(ValueError):
-        this_block = xwu.block(0, 1)
-    with pytest.raises(ValueError):
-        this_block = xwu.block(1, 0)
-
-
-def test_block_one_dimension():
-    this_block = xwu.block.from_list_of_lists([1, 2, 3])
-    assert this_block.as_list_of_lists == [[1, 2, 3]]
-
-    this_block = xwu.block.from_list_of_lists([1, 2, 3], column_like=True)
-    assert this_block.as_list_of_lists == [[1], [2], [3]]
-
-
-def test_block_scalar():
-    this_block = xwu.block.from_list_of_lists(1, column_like=True)
-    assert this_block.as_list_of_lists == [[1]]
-
-def test_raise():
-    this_block=xwu.block(4,6)
-    with pytest.raises(IndexError):
-        a=this_block[0,1]
-    with pytest.raises(IndexError):
-        a=this_block[5,1]
-
-    with pytest.raises(IndexError):
-        a=this_block[1,0]
-    with pytest.raises(IndexError):
-        a=this_block[1,7]
-
-    with pytest.raises(IndexError):
-        this_block[0,1]=1
-    with pytest.raises(IndexError):
-        this_block[5,1]=1
-
-    with pytest.raises(IndexError):
-        this_block[1,0]=1
-    with pytest.raises(IndexError):
-        this_block[1,7]=1
-
-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_list_of_lists()==[["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_list_of_lists()==[["ghi"],["jkl"]]    
-    out, err = capsys.readouterr()
-    assert out==""
-
-
-if __name__ == "__main__":
-    pytest.main(["-vv", "-s", "-x", __file__])

xlwings_utils-0.0.6/xlwings_utils.egg-info/PKG-INFO

@@ -1,52 +0,0 @@
-Metadata-Version: 2.4
-Name: xlwings_utils
-Version: 0.0.6
-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_logo1.png"> 
-
-## Introduction
-
-This module provides some useful functions to be used in xlwings lite.
-
-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 systen. And
-therefore, it is possible to indirectly use the local file system.
-
-The module contains support for a useful 2 dimensional data structure: block.
-Thjs can be useful to manipulate a range without accessing the range directly,
-which is expensive in terms of memory and execution time.
-
-On top of that, this module makes it possible to capture stdout writes, which
-can then be copied to a worksheet in a later stage.
-
-## Installation
-
-Just add xlwings-utils to the requirement tab. It might be required to add ssl.
-
-## Dropbox support
-
-xlwings_lite only works with full access dropbox apps.
-
-In order to use dropbox functionality, is is necessary to initialize the module with credentials.
-
-```xwu.dropbox_init()```
-If called without parameters, the refresh_token is
-
-## Capture stdout support
-
- 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)
-