xlwings-utils 0.0.3__tar.gz → 0.0.5__tar.gz

{xlwings_utils-0.0.3 → xlwings_utils-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xlwings_utils
-Version: 0.0.3
+Version: 0.0.5
 Summary: xlwings_utils
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://github.com/salabim/xlwings_utils

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

xlwings_utils-0.0.5/tests/test_xlwings_utils.py

@@ -0,0 +1,98 @@
+import math
+import itertools
+import os
+import sys
+import re
+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
+
+
+
+if __name__ == "__main__":
+    pytest.main(["-vv", "-s", "-x", __file__])

{xlwings_utils-0.0.3 → xlwings_utils-0.0.5}/xlwings_utils/xlwings_utils.py

@@ -5,12 +5,11 @@
 #  /_/\_\|_|  \_/\_/  |_||_| |_| \__, ||___/ _____  \__,_| \__||_||_||___/
 #                                |___/      |_____|
 
-__version__ = "0.0.3"
+__version__ = "0.0.5"
 
 
 import dropbox
 from pathlib import Path
-import sys
 import os
 
 _captured_stdout = []
@@ -18,7 +17,7 @@ dbx = None
 
 
 def dropbox_init(refresh_token=None, app_key=None, app_secret=None):
-    '''
+    """
     dropbox initialize
 
     This function has to be called prior to using any dropbox function
@@ -29,13 +28,13 @@ def dropbox_init(refresh_token=None, app_key=None, app_secret=None):
         oauth2 refreshntoken
 
         if omitted: use the environment variable REFRESH_TOKEN
-        
+
     app_key : str
         app key
 
         if omitted: use the environment variable APP_KEY
 
-                
+
     app_secret : str
         app secret
 
@@ -44,41 +43,42 @@ def dropbox_init(refresh_token=None, app_key=None, app_secret=None):
     Returns
     -------
     -
-    '''
+    """
     if refresh_token is None:
-        refresh_token =os.environ["REFRESH_TOKEN"]
+        refresh_token = os.environ["REFRESH_TOKEN"]
     if app_key is None:
-        app_key=os.environ["APP_KEY"]
+        app_key = os.environ["APP_KEY"]
     if app_secret is None:
-        app_secret =os.environ["APP_SECRET"]
+        app_secret = os.environ["APP_SECRET"]
 
     global dbx
     dbx = dropbox.Dropbox(oauth2_refresh_token=refresh_token, app_key=app_key, app_secret=app_secret)
-    
+
+
 def _check_dbx():
     if dbx is None:
-        raise ValueError('not initialized. Please call dropbox_init()')
+        raise ValueError("not initialized. Please call dropbox_init()")
 
 
 def list_dropbox(path="", recursive=False):
-    '''
+    """
     list_dropbox
-    
+
     returns all dropbox files in path
-    
+
     Parameters
     ----------
     path : str or Pathlib.Path
         path from which to list all files (default: '')
-        
-        
+
+
     recursive : bool
         if True, recursively list files. if False (default) no recursion
-        
+
     Returns
     -------
     files, relative to path : list
-    '''
+    """
     _check_dbx()
     out = []
     result = dbx.files_list_folder(path, recursive=recursive)
@@ -97,20 +97,20 @@ def list_dropbox(path="", recursive=False):
 
 
 def read_dropbox(dropbox_path):
-    '''
+    """
     read_dropbox
-    
+
     read from dopbox at given path
-    
+
     Parameters
     ----------
-    path : str or Pathlib.Path
+    dropbox_path : str or Pathlib.Path
         path to read from
-        
+
     Returns
     -------
     contents of the dropbox file : bytes
-    '''
+    """
 
     _check_dbx()
     metadata, response = dbx.files_download(dropbox_path)
@@ -120,85 +120,177 @@ def read_dropbox(dropbox_path):
 
 def write_dropbox(dropbox_path, contents):
     _check_dbx()
+    """
+    write_dropbox
+    
+    write from dopbox at given path
+    
+    Parameters
+    ----------
+    dropbox_path : str or Pathlib.Path
+        path to write to
+
+    contents : bytes
+        contents to be written
+        
+    """
     dbx.files_upload(contents, dropbox_path, mode=dropbox.files.WriteMode.overwrite)
 
 
-def list_pyodide(path):
+def list_local(path):
     path = Path(path)
     return list(path.iterdir())
 
 
-def write_pyodide(path, contents):
+def write_local(path, contents):
     path = Path(path)
     path.parent.mkdir(parents=True, exist_ok=True)
     with open(path, "wb") as f:
         f.write(contents)
 
 
-def read_pyodide(path):
+def read_local(path):
     path = Path(path)
     with open(path, "rb") as f:
         contents = f.read()
     return contents
 
+
 class block:
-    def __init__(self, number_of_rows,number_of_columns):
-        self.dict={}
-        self.number_of_columns=number_of_columns
-        self.number_of_rows=number_of_rows
+    """
+    block is 2 dimensional data structure with 1 as lowest index (like xlwings range)
+
+    Parameters
+    ----------
+    number_of_rows : int
+        number of rows
+
+    number_of_columns : int
+        number of columns
+
+    Returns
+    -------
+    block
+    """
+
+    def __init__(self, number_of_rows, number_of_columns):
+        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):
-        if not isinstance(list_of_lists[0],list):
+        """
+        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]
+                list_of_lists = [[value] for value in list_of_lists]
             else:
-                list_of_lists=[list_of_lists]
+                list_of_lists = [list_of_lists]
 
-        self=cls(0,0)
+        self = cls(1, 1)
 
-        self.number_of_rows=len(list_of_lists)
-        self.number_of_columns=0
-        
+        self.number_of_rows = len(list_of_lists)
+        self._number_of_columns = 0
 
-        for row,row_contents in enumerate(list_of_lists,1):
-            for column,value in enumerate(row_contents,1):
+        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)  
+                    self.dict[row, column] = value
+                    self._number_of_columns = max(self.number_of_columns, column)
         return self
-    
+
     def __setitem__(self, row_column, value):
-        row,column=row_column
-        if row<1 or row>self.number_of_rows:
-            raise IndexError
-        if column<1 or column>self.number_of_columns:
-            raise IndexError
-        self.dict[row,column]=value
+        row, column = row_column
+        if row < 1 or row > self.number_of_rows:
+            raise IndexError(f"row must be between 1 and {self.number_of_rows} not {row}")
+        if column < 1 or column > self.number_of_columns:
+            raise IndexError(f"column must be between 1 and {self.number_of_columns} not {column}")
+        self.dict[row, column] = value
 
     def __getitem__(self, row_column):
-        row,column=row_column
-        if row<1 or row>self.number_of_rows:
-            raise IndexError
-        if column<1 or column>self.number_of_columns:
-            raise IndexError
-        return self.dict.get((row,column))
+        row, column = row_column
+        if row < 1 or row > self.number_of_rows:
+            raise IndexError(f"row must be between 1 and {self.number_of_rows} not {row}")
+        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)]
-    
+        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):
-        number_of_rows=max(row for row,column in self.dict)
-        number_of_columns=max(column for row,column in self.dict)
-        return [[self.dict.get((row,column)) for column in range(1,number_of_columns+1)] for row in range(1,number_of_rows+1)]
+        return [[self.dict.get((row, column)) for column in range(1, self.maximum_column + 1)] for row in range(1, self.maximum_row + 1)]
+
+    @property
+    def number_of_rows(self):
+        return self._number_of_rows
+
+    @number_of_rows.setter
+    def number_of_rows(self, value):
+        if value<1:
+            raise ValueError(f"number_of_rows should be >=1, not {value}")
+        self._number_of_rows = value
+        for row, column in list(self.dict):
+            if row > self._number_of_rows:
+                del self.dict[row, column]
 
+    @property
+    def number_of_columns(self):
+        return self._number_of_columns
+
+    @number_of_columns.setter
+    def number_of_columns(self, value):
+        if value<1:
+            raise ValueError(f"number_of_columns should be >=1, not {value}")
+        self._number_of_columns = value
+        for row, column in list(self.dict):
+            if column > self._number_of_columns:
+                del self.dict[row, column]
+
+    @property
+    def maximum_row(self):
+        if self.dict:
+            return max(row for (row, column) in self.dict)
+        else:
+            return 1
+
+    @property
+    def maximum_column(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})"
 
+
 def clear_captured_stdout():
     """
     empties the captured stdout
@@ -219,9 +311,9 @@ def captured_stdout_as_str():
     return "".join(_captured_stdout)
 
 
-def captured_stdout_as_range():
+def captured_stdout_as_list_of_lists():
     """
-    returns the captured stdout as a list of strings
+    returns the captured stdout as a list of lists
 
     Returns
     -------
@@ -274,31 +366,3 @@ class capture_stdout:
 
 if __name__ == "__main__":
     ...
-
-
-# @xw.script
-# def test_stdout(book: xw.Book):
-#     with capture_stdout():
-#         for i in range(10):
-#             print(10 * f'{i}')
-#     book.sheets.active.range("A1").value=captured_stdout_as_range()
-
-
-# @xw.script
-# def test(book: xw.Book):
-#     dropbox_init(
-#         refresh_token=REFRESH_TOKEN,
-#         app_key=APP_KEY,
-#         app_secret=APP_SECRET,
-#     )
-
-#     files =list_dropbox("/Downloads",recursive=True)
-#     peek(files)
-#     write_pyodide("Test/x.x", b"abc")
-#     files = list_pyodide("Test")
-
-#     # files=list_dropbox_files("/Downloads")
-#     # peek(files)
-#     contents = read_dropbox("/Downloads/dropbox setup.py")
-#     write_dropbox("/Downloads/dropbox setup1.py", contents)
-#     peek("done")

{xlwings_utils-0.0.3 → xlwings_utils-0.0.5}/xlwings_utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xlwings_utils
-Version: 0.0.3
+Version: 0.0.5
 Summary: xlwings_utils
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://github.com/salabim/xlwings_utils

{xlwings_utils-0.0.3 → xlwings_utils-0.0.5}/xlwings_utils.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 README.md
 pyproject.toml
+tests/test_xlwings_utils.py
 xlwings_utils/__init__.py
 xlwings_utils/xlwings_utils.py
 xlwings_utils.egg-info/PKG-INFO