xlwings-utils 25.0.6.post4__tar.gz → 25.0.6.post5__tar.gz

{xlwings_utils-25.0.6.post4 → xlwings_utils-25.0.6.post5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xlwings_utils
-Version: 25.0.6.post4
+Version: 25.0.6.post5
 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-25.0.6.post4 → xlwings_utils-25.0.6.post5}/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.6.post4"
+version = "25.0.6.post5"
 readme = "README.md"
 requires-python = ">=3.9"
 dependencies = [

{xlwings_utils-25.0.6.post4 → xlwings_utils-25.0.6.post5}/tests/test_xlwings_utils.py

@@ -42,7 +42,7 @@ def test_block0():
 
 
 def test_block1():
-    this_block = xwu.block([[1, 2, 3], [4, 5, 6]])
+    this_block = xwu.block.from_value([[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]]
@@ -57,26 +57,26 @@ def test_block1():
 
 
 def test_block2():
-    this_block = xwu.block([[1, 2, 3], [4, 5, 6]], number_of_rows=1)
+    this_block = xwu.block.from_value([[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)
+    this_block = xwu.block.from_value([[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)
+    this_block = xwu.block.from_value([[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])
+    this_block = xwu.block.from_value([1, 2, 3])
     assert this_block.value == [[1, 2, 3]]
 
-    this_block = xwu.block([1, 2, 3], column_like=True)
+    this_block = xwu.block.from_value([1, 2, 3], column_like=True)
     assert this_block.value == [[1], [2], [3]]
 
 
 def test_block_scalar():
-    this_block = xwu.block(1)
+    this_block = xwu.block.from_value(1)
     assert this_block.value == [[1]]
 
 
@@ -103,7 +103,7 @@ def test_raise():
         this_block[1, 7] = 1
 
 def test_lookup():
-    bl=xwu.block([[1,"One", "Un"],[2, "Two", "Deux"],[3,"Three","Trois"]])
+    bl=xwu.block.from_value([[1,"One", "Un"],[2, "Two", "Deux"],[3,"Three","Trois"]])
     assert bl.lookup(1)=="One"
     assert bl.lookup(3, column2=3)=="Trois"
     with pytest.raises(ValueError):
@@ -117,7 +117,7 @@ def test_lookup():
     assert bl.lookup_row(3)==3
 
 def test_vookup():
-    bl=xwu.block([[1,"One", "Un"],[2, "Two", "Deux"],[3,"Three","Trois"]])
+    bl=xwu.block.from_value([[1,"One", "Un"],[2, "Two", "Deux"],[3,"Three","Trois"]])
     assert bl.vlookup(1)=="One"
     assert bl.vlookup(3, column2=3)=="Trois"
     with pytest.raises(ValueError):
@@ -129,7 +129,7 @@ def test_vookup():
         bl.vlookup(1, column1=3)
 
 def test_hlookup():
-    bl=xwu.block([[1,2,3],"One Two Three".split(), "Un Deux Trois".split()])
+    bl=xwu.block.from_value([[1,2,3],"One Two Three".split(), "Un Deux Trois".split()])
                  
     assert bl.hlookup(1)=="One"
     assert bl.hlookup(3, row2=3)=="Trois"

{xlwings_utils-25.0.6.post4 → xlwings_utils-25.0.6.post5}/xlwings_utils/xlwings_utils.py

@@ -268,7 +268,6 @@ def read_local(path):
         contents = f.read()
     return contents
 
-
 class block:
     """
     block is 2 dimensional data structure with 1 as lowest index (like xlwings range)
@@ -276,98 +275,239 @@ class block:
     Parameters
     ----------
     number_of_rows : int
-        number of rows
+        number of rows (dedault 1)
 
     number_of_columns : int
-        number of columns
+        number of columns (default 1)
 
     Returns
     -------
     block
     """
 
-    def __init__(self, value=missing, *, number_of_rows=missing, number_of_columns=missing, column_like=False):
+    def __init__(self, number_of_rows=1, number_of_columns=1):
         self.dict = {}
-        self.column_like = column_like
-        if value is missing:
-            if number_of_rows is missing:
-                number_of_rows = 1
-            if number_of_columns is missing:
-                number_of_columns = 1
-            self.number_of_rows = number_of_rows
-            self.number_of_columns = number_of_columns
+        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 missing:
-                self.number_of_rows = number_of_rows
-            if number_of_columns is not missing:
-                self.number_of_columns = number_of_columns
+    @classmethod
+    def from_value(
+        cls, value, column_like=False, number_of_rows=missing, number_of_columns=missing
+    ):
+        """
+        makes a block from a given value
+
+        Parameters
+        ----------
+        value : scaler, list of scalars, list of lists of scalars or block
+            value to be used in block, possibly expanded to a list of lists of scalars
+
+        column_like : boolean
+            if value is a list of scalars, values is interpreted as a column if True, as a row otherwise
+
+        number_of_rows : int
+            if given, expand or shrink to the given number of rows
+
+        number_of_columns : int
+            if given, expand or shrink to the given number of columns
+
+        Returns
+        -------
+        block : block
+        """
+        if isinstance(value, block):
+            value = value.value
+        if not isinstance(value, list):
+            value = [[value]]
+        if not isinstance(value[0], list):
+            if column_like:
+                value = [[item] for item in value]
+            else:
+                value = [value]
+        bl = cls(len(value), 1)
+
+        for row, row_contents in enumerate(value, 1):
+            for column, item in enumerate(row_contents, 1):
+                if item and not (isinstance(item, float) and math.isnan(item)):
+                    bl.dict[row, column] = item
+                    bl._number_of_columns = max(bl.number_of_columns, column)
+        if number_of_rows is not missing:
+            bl.number_of_rows = number_of_rows
+        if number_of_columns is not missing:
+            bl.number_of_columns = number_of_columns
+        return bl
+
+    @classmethod
+    def from_range(cls, rng, number_of_rows=missing, number_of_columns=missing):
+        """
+        makes a block from a given range
+
+        Parameters
+        ----------
+        rng : xlwings.Range
+            range to be used be used in block
+
+        number_of_rows : int
+            if given, expand or shrink to the given number of rows
+
+        number_of_columns : int
+            if given, expand or shrink to the given number of columns
+
+        Returns
+        -------
+        block : block
+        """
+        number_of_rows, number_of_columns = rng.shape
+        bl = cls.from_value(
+            rng.value,
+            column_like=(number_of_columns == 1),
+            number_of_rows=number_of_rows,
+            number_of_columns=number_of_columns,
+        )
+        return bl
 
     @classmethod
     def from_xlrd_sheet(cls, sheet, number_of_rows=missing, number_of_columns=missing):
-        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)
+        """
+        makes a block from a xlrd sheet
+
+        Parameters
+        ----------
+        sheet : xlrd sheet
+            sheet to be used be used in block
+
+        number_of_rows : int
+            if given, expand or shrink to the given number of rows
+
+        number_of_columns : int
+            if given, expand or shrink to the given number of columns
+
+        Returns
+        -------
+        block : block
+        """
+        v = [
+            sheet.row_values(row_idx)[0 : sheet.ncols]
+            for row_idx in range(0, sheet.nrows)
+        ]
+        return cls.from_value(
+            v, number_of_rows=number_of_rows, number_of_columns=number_of_columns
+        )
 
     @classmethod
-    def from_openpyxl_sheet(cls, sheet, number_of_rows=missing, number_of_columns=missing):
+    def from_openpyxl_sheet(
+        cls, sheet, number_of_rows=missing, number_of_columns=missing
+    ):
         v = [[cell.value for cell in row] for row in sheet.iter_rows()]
-        return cls(v, number_of_rows=number_of_rows, number_of_columns=number_of_columns)
+        return cls.from_value(
+            v, number_of_rows=number_of_rows, number_of_columns=number_of_columns
+        )
 
     @classmethod
     def from_file(cls, filename, number_of_rows=missing, number_of_columns=missing):
+        """
+        makes a block from a file
+
+        Parameters
+        ----------
+        filename : str
+            file to be used be used in block
+
+        number_of_rows : int
+            if given, expand or shrink to the given number of rows
+
+        number_of_columns : int
+            if given, expand or shrink to the given number of columns
+
+        Returns
+        -------
+        block : block
+        """
         with open(filename, "r") as f:
             v = [[line if line else missing] for line in f.read().splitlines()]
-        return cls(v, number_of_rows=number_of_rows, number_of_columns=number_of_columns)
+        return cls.from_value(
+            v, number_of_rows=number_of_rows, number_of_columns=number_of_columns
+        )
 
     @classmethod
     def from_dataframe(cls, df, number_of_rows=missing, number_of_columns=missing):
+        """
+        makes a block from a given dataframe
+
+        Parameters
+        ----------
+        df : pandas dataframe
+            dataframe to be used be used in block
+
+        number_of_rows : int
+            if given, expand or shrink to the given number of rows
+
+        number_of_columns : int
+            if given, expand or shrink to the given number of columns
+
+        Returns
+        -------
+        block : block
+        """
         v = df.values.tolist()
-        return cls(v, number_of_rows=number_of_rows, number_of_columns=number_of_columns)
+        return cls.from_value(
+            v, number_of_rows=number_of_rows, number_of_columns=number_of_columns
+        )
 
     def to_openpyxl_sheet(self, sheet):
+        """
+        makes a block from a given openpyxl sheet
+
+        Parameters
+        ----------
+        sheet: openpyxl sheet
+            sheet to be used be used in block
+
+        number_of_rows : int
+            if given, expand or shrink to the given number of rows
+
+        number_of_columns : int
+            if given, expand or shrink to the given number of columns
+
+        Returns
+        -------
+        block : block
+        """
         for row in self.value:
             sheet.append(row)
 
     @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:
-                value = [value]
-
-        self.number_of_rows = len(value)
-        self._number_of_columns = 0
-
-        for row, row_contents in enumerate(value, 1):
-            for column, item in enumerate(row_contents, 1):
-                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)
+        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)
+        ]
 
     def __setitem__(self, 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}")
+            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}")
+            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(f"row must be between 1 and {self.number_of_rows} not {row}")
+            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}")
+            raise IndexError(
+                f"column must be between 1 and {self.number_of_columns} not {column}"
+            )
         return self.dict.get((row, column))
 
     def minimized(self):
@@ -377,7 +517,11 @@ class block:
         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)
+        return block.from_value(
+            self,
+            number_of_rows=self.highest_used_row_number,
+            number_of_columns=self.highest_used_column_number,
+        )
 
     @property
     def number_of_rows(self):
@@ -432,7 +576,9 @@ class block:
         if column < 1:
             raise ValueError(f"{name}={column} < 1")
         if column > self.number_of_columns:
-            raise ValueError(f"{name}={column} > number_of_columns={self.number_of_columns}")
+            raise ValueError(
+                f"{name}={column} > number_of_columns={self.number_of_columns}"
+            )
 
     def transpose(self):
         """
@@ -442,12 +588,23 @@ class block:
         -------
         transposed block : block
         """
-        bl = block(number_of_rows=self.number_of_columns, number_of_columns=self.number_of_rows)
+        bl = block(
+            number_of_rows=self.number_of_columns, number_of_columns=self.number_of_rows
+        )
         for (row, column), value in self.dict.items():
             bl[column, row] = value
         return bl
 
-    def vlookup(self, s, *, row_from=1, row_to=missing, column1=1, column2=missing, default=missing):
+    def vlookup(
+        self,
+        s,
+        *,
+        row_from=1,
+        row_to=missing,
+        column1=1,
+        column2=missing,
+        default=missing,
+    ):
         """
         searches in column1 for row between row_from and row_to for s and returns the value found at (that row, column2)
 
@@ -488,7 +645,9 @@ class block:
         if column2 is missing:
             column2 = column1 + 1
         self._check_column(column2, "column2")
-        row = self.lookup_row(s, row_from=row_from, row_to=row_to, column1=column1, default=-1)
+        row = self.lookup_row(
+            s, row_from=row_from, row_to=row_to, column1=column1, default=-1
+        )
         if row == -1:
             if default is missing:
                 raise ValueError(f"{s} not found]")
@@ -553,7 +712,16 @@ class block:
         else:
             return default
 
-    def hlookup(self, s, *, column_from=1, column_to=missing, row1=1, row2=missing, default=missing):
+    def hlookup(
+        self,
+        s,
+        *,
+        column_from=1,
+        column_to=missing,
+        row1=1,
+        row2=missing,
+        default=missing,
+    ):
         """
         searches in row1 for column between column_from and column_to for s and returns the value found at (that column, row2)
 
@@ -594,7 +762,9 @@ class block:
         if row2 is missing:
             row2 = row1 + 1
         self._check_row(row2, "row2")
-        column = self.lookup_column(s, column_from=column_from, column_to=column_to, row1=row1, default=-1)
+        column = self.lookup_column(
+            s, column_from=column_from, column_to=column_to, row1=row1, default=-1
+        )
         if column == -1:
             if default is missing:
                 raise ValueError(f"{s} not found")
@@ -603,7 +773,9 @@ class block:
         else:
             return self[row2, column]
 
-    def lookup_column(self, s, *, column_from=1, column_to=missing, row1=1, default=missing):
+    def lookup_column(
+        self, s, *, column_from=1, column_to=missing, row1=1, default=missing
+    ):
         """
         searches in row1 for column between column_from and column_to for s and returns that column number
 
@@ -653,7 +825,16 @@ class block:
         else:
             return default
 
-    def lookup(self, s, *, row_from=1, row_to=missing, column1=1, column2=missing, default=missing):
+    def lookup(
+        self,
+        s,
+        *,
+        row_from=1,
+        row_to=missing,
+        column1=1,
+        column2=missing,
+        default=missing,
+    ):
         """
         searches in column1 for row between row_from and row_to for s and returns the value found at (that row, column2)
 
@@ -695,7 +876,14 @@ class block:
         ----
         This is exactly the same as vlookup.
         """
-        return self.vlookup(s, row_from=row_from, row_to=row_to, column1=column1, column2=column2, default=default)
+        return self.vlookup(
+            s,
+            row_from=row_from,
+            row_to=row_to,
+            column1=column1,
+            column2=column2,
+            default=default,
+        )
 
     def decode_to_files(self):
         """
@@ -706,7 +894,11 @@ class block:
             row = 1
             bl = self.minimized()
             while row <= self.number_of_rows:
-                if self[row, column] and self[row, column].startswith("<file=") and self[row, column].endswith(">"):
+                if (
+                    self[row, column]
+                    and self[row, column].startswith("<file=")
+                    and self[row, column].endswith(">")
+                ):
                     filename = self[row, column][6:-1]
                     collect = []
                     row += 1
@@ -751,7 +943,6 @@ class block:
         row += 1
         return bl.minimized()
 
-
 class Capture:
     """
     specifies how to capture stdout

{xlwings_utils-25.0.6.post4 → xlwings_utils-25.0.6.post5}/xlwings_utils.egg-info/PKG-INFO

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