xlwings-utils 25.0.6.post5__py3-none-any.whl → 25.0.7__py3-none-any.whl

xlwings_utils/xlwings_utils.py

@@ -5,7 +5,7 @@
 #  /_/\_\|_|  \_/\_/  |_||_| |_| \__, ||___/ _____  \__,_| \__||_||_||___/
 #                                |___/      |_____|
 
-__version__ = "25.0.6"
+__version__ = "25.0.7"
 
 
 import dropbox
@@ -20,7 +20,6 @@ Pythonista = sys.platform == "ios"
 try:
     import xlwings
 
-    xlwings = True
 except ImportError:
     xlwings = False
 
@@ -268,6 +267,7 @@ 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)
@@ -291,9 +291,7 @@ class block:
         self.number_of_columns = number_of_columns
 
     @classmethod
-    def from_value(
-        cls, value, column_like=False, number_of_rows=missing, number_of_columns=missing
-    ):
+    def from_value(cls, value, column_like=False):
         """
         makes a block from a given value
 
@@ -331,14 +329,10 @@ class block:
                 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):
+    def from_range(cls, rng):
         """
         makes a block from a given range
 
@@ -358,16 +352,11 @@ class block:
         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,
-        )
+        bl = cls.from_value(rng.value, column_like=(number_of_columns == 1))
         return bl
 
     @classmethod
-    def from_xlrd_sheet(cls, sheet, number_of_rows=missing, number_of_columns=missing):
+    def from_xlrd_sheet(cls, sheet):
         """
         makes a block from a xlrd sheet
 
@@ -386,25 +375,16 @@ class block:
         -------
         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
-        )
+        v = [sheet.row_values(row_idx)[0 : sheet.ncols] for row_idx in range(0, sheet.nrows)]
+        return cls.from_value(v)
 
     @classmethod
-    def from_openpyxl_sheet(
-        cls, sheet, number_of_rows=missing, number_of_columns=missing
-    ):
+    def from_openpyxl_sheet(cls, sheet):
         v = [[cell.value for cell in row] for row in sheet.iter_rows()]
-        return cls.from_value(
-            v, number_of_rows=number_of_rows, number_of_columns=number_of_columns
-        )
+        return cls.from_value(v)
 
     @classmethod
-    def from_file(cls, filename, number_of_rows=missing, number_of_columns=missing):
+    def from_file(cls, filename):
         """
         makes a block from a file
 
@@ -425,12 +405,10 @@ class block:
         """
         with open(filename, "r") as f:
             v = [[line if line else missing] for line in f.read().splitlines()]
-        return cls.from_value(
-            v, number_of_rows=number_of_rows, number_of_columns=number_of_columns
-        )
+        return cls.from_value(v)
 
     @classmethod
-    def from_dataframe(cls, df, number_of_rows=missing, number_of_columns=missing):
+    def from_dataframe(cls, df):
         """
         makes a block from a given dataframe
 
@@ -450,9 +428,7 @@ class block:
         block : block
         """
         v = df.values.tolist()
-        return cls.from_value(
-            v, number_of_rows=number_of_rows, number_of_columns=number_of_columns
-        )
+        return cls.from_value(v)
 
     def to_openpyxl_sheet(self, sheet):
         """
@@ -476,38 +452,50 @@ class block:
         for row in self.value:
             sheet.append(row)
 
+    def reshape(self, number_of_rows=missing, number_of_columns=missing):
+        """
+        makes a new block with given dimensions
+
+        Parameters
+        ----------
+        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 number_of_rows is missing:
+            number_of_rows = self.number_of_rows
+        if number_of_columns is missing:
+            number_of_columns = self.number_of_columns
+        bl = block(number_of_rows=number_of_rows, number_of_columns=number_of_columns)
+        for (row, column), value in self.dict.items():
+            if row <= number_of_columns and column <= number_of_columns:
+                bl.dict[row, column] = value
+        return bl
+
     @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)
-        ]
+        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):
@@ -517,11 +505,7 @@ class block:
         minimized block : block
              uses highest_used_row_number and highest_used_column_number to minimize the block
         """
-        return block.from_value(
-            self,
-            number_of_rows=self.highest_used_row_number,
-            number_of_columns=self.highest_used_column_number,
-        )
+        return self.reshape(number_of_rows=self.highest_used_row_number, number_of_columns=self.highest_used_column_number)
 
     @property
     def number_of_rows(self):
@@ -576,9 +560,7 @@ 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):
         """
@@ -588,23 +570,12 @@ 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)
 
@@ -645,9 +616,7 @@ 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]")
@@ -712,16 +681,7 @@ 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)
 
@@ -762,9 +722,7 @@ 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")
@@ -773,9 +731,7 @@ 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
 
@@ -825,16 +781,7 @@ 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)
 
@@ -876,14 +823,7 @@ 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):
         """
@@ -894,11 +834,7 @@ 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
@@ -943,6 +879,7 @@ class block:
         row += 1
         return bl.minimized()
 
+
 class Capture:
     """
     specifies how to capture stdout

{xlwings_utils-25.0.6.post5.dist-info → xlwings_utils-25.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xlwings_utils
-Version: 25.0.6.post5
+Version: 25.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
@@ -87,14 +87,20 @@ xwu.write_dropbox('/downloads/file1.gif')
 The module contains a useful 2-dimensional data structure: *block*.
 This can be useful for manipulating a range without accessing it 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]`
+So, `my_block[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` or `block.value_keep`. 
+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
+Converting of a range to a block can be done like
 
 ```
-my_block = xwu.block.from_value(range.value)
+rng = book.sheets.active.range((5,7),(8,100))
+my_block = xwu.block.from_range(rng
+```
+
+A value of a range (list of lists, list of scalars or scalar can be converted to a block with
+```
+my_block = xwu.block.from_value(rng.value)
 ```
 The dimensions (number of rows and number of columns) are automatically set.
 
@@ -115,9 +121,10 @@ block = xwu.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
+It is also possible to get a copy of a block with different dimensions:
+
 ```
-range.value = block.value
+bl = my.block.reshape(number_of_rows=2, number_of_columns=10)
 ```
 
 The property `block.highest_used_row_number` returns the row number of the highest non-None cell.
@@ -152,7 +159,7 @@ Of course, we could access the various input fields with absolute ranges, but if
 If we read the project sheet (partly) into a block, lookup methods are available to access *fields* easily and future-proof:
 
 ```
-bl = xwu.block.from_value(sheet.range((0,0),(100,10)).value)
+bl = xwu.block.from_range(sheet.range(1,1),(100,10)))
 ```
 
 Let's see how this works with the above sheet. The corresponding block (bl) looks like
@@ -171,7 +178,8 @@ Let's see how this works with the above sheet. The corresponding block (bl) look
 9 | 
 ```
 Now we can do
-```project  = bl.lookup("Project")
+```
+project  = bl.lookup("Project")
 project = bl.lookup("Project")
 start_date = bl.lookup("Start date")
 end_date = bl.lookup("End date")
@@ -194,11 +202,11 @@ We then read the following rows (using hlookups) and access the required values.
 
 ### Filling a block from other sources
 
-The advantage of using a block instead of accessing these sources is that they are one-based, just like in Excel.
+The advantage of using a block instead of accessing these sources directly is that they are one-based, just like in Excel.
 
 It is possible to make a block from an xlrd worksheet with `block.from_xlrd_sheet`. 
 
-It is possible to create a block from a Pandas DataFrame using `block.from_dataframe`. Ensure that, if the dataframe is created by reading from an Excel sheet, headers=None is specified, e.g., `df = pd.read_excel(filename, header=None)`.
+It is possible to create a block from a panda dataFrame using `block.from_dataframe`. Ensure that, if the dataframe is created by reading from an Excel sheet, headers=None is specified, e.g., `df = pd.read_excel(filename, header=None)`.
 
 It is possible to make a block from an openpyxl worksheet with `block.from_openpyxl_sheet`. 
 
@@ -293,7 +301,7 @@ Just add the .bas file to a worksheet and call like
 Sub MacroToExecute()
     DecodeFile(Me, 10, 1)
 ```
-    
+
 In this example, the file *film1.mp4* will be downloaded into the current directory.
 
 The module xlwings_utils also contains code to encode a local file to a sheet:

xlwings_utils-25.0.7.dist-info/RECORD

@@ -0,0 +1,6 @@
+xlwings_utils/__init__.py,sha256=FdaRztevSu5akGL7KBUBRzqwLMRTdvVUuS2Kfp2f1Uc,68
+xlwings_utils/xlwings_utils.py,sha256=e8Lo40ceG0kSzSuytOpIT3cvJ_bhZRxLC2x69EE6k9Y,28725
+xlwings_utils-25.0.7.dist-info/METADATA,sha256=NVLthhuk58Inh4nNVC9Bvue1VEUXuRUYdjJYKlhEqyA,12418
+xlwings_utils-25.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xlwings_utils-25.0.7.dist-info/top_level.txt,sha256=kf5SEv0gZiRObPhUoYcc1O_iX_wwTOPeUIYvzyYeAM4,14
+xlwings_utils-25.0.7.dist-info/RECORD,,

xlwings_utils-25.0.6.post5.dist-info/RECORD

@@ -1,6 +0,0 @@
-xlwings_utils/__init__.py,sha256=FdaRztevSu5akGL7KBUBRzqwLMRTdvVUuS2Kfp2f1Uc,68
-xlwings_utils/xlwings_utils.py,sha256=2OxAeSEvIxSrj5aMMIxAsFYthYKk9yaYVvo8phtaf1c,29626
-xlwings_utils-25.0.6.post5.dist-info/METADATA,sha256=8Ub-c1wDWkoZcW5qXie2w2gqItVa3RMPLjpKaZN7pt8,12255
-xlwings_utils-25.0.6.post5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xlwings_utils-25.0.6.post5.dist-info/top_level.txt,sha256=kf5SEv0gZiRObPhUoYcc1O_iX_wwTOPeUIYvzyYeAM4,14
-xlwings_utils-25.0.6.post5.dist-info/RECORD,,