feat(Table): Add 'get_table_from_sheet' option

requirements_dev.txt

@@ -1,4 +1,4 @@
 google-api-python-client>=1.7.4
 oauth2client>=4.1.2
 pytest
-coverage
+coverage

sheetfu/modules/table.py

@@ -1,3 +1,4 @@
+
 from sheetfu.model import Range
 from sheetfu.helpers import convert_coordinates_to_a1
 
@@ -35,6 +36,25 @@ def __iter__(self):
     def __getitem__(self, index):
         return self.items[index]
 
+    @staticmethod
+    def get_table_from_sheet(spreadsheet, sheet_name, notes=False, backgrounds=False, font_colors=False):
+        """
+        Method to create a table from a whole sheet of a spreadsheet.
+        This method assumes the header row is 1.
+
+        :param spreadsheet: spreadsheet in which the table is in.
+        :param sheet_name: specific sheet of the spreadsheet where the table is.
+        :param notes: parameter to include the notes of a sheet.
+        :param backgrounds: parameter to include the backgrounds of a sheet.
+        :param font_colors: parameter to include the font colors of a sheet.
+
+        :return: List of Items containing only filtered items or and empty List.
+
+        """
+        data_range = spreadsheet.get_sheet_by_name(sheet_name).get_data_range()
+        return Table(data_range, notes, backgrounds, font_colors)
+
+
     def get_items_range(self):
         # We need to check for the case where the table has no items, only the header row #
         full_range_num_rows = self.full_range.coordinates.number_of_rows

tests/conftest.py

@@ -0,0 +1,56 @@
+import pytest
+
+from sheetfu import SpreadsheetApp, Table
+from tests.utils import mock_google_sheets_responses
+
+
+@pytest.fixture()
+def full_spreadsheet():
+    http_mocks = mock_google_sheets_responses([
+        'table_get_sheets.json',
+        'table_check_data_range.json',
+        'table_values.json',
+        'table_values.json',
+        'table_notes.json',
+        'table_backgrounds.json',
+        'table_font_colors.json'
+    ])
+
+    return SpreadsheetApp(http=http_mocks)
+
+
+@pytest.fixture()
+def spreadsheet():
+    http_mocks = mock_google_sheets_responses([
+        'table_get_sheets.json',
+        'table_check_data_range.json',
+        'table_values.json',
+        'table_values.json',
+        'table_commit_reply.json',
+        'table_commit_reply.json',
+        'table_commit_reply.json',
+    ])
+
+    return SpreadsheetApp(http=http_mocks)
+
+
+@pytest.fixture()
+def table(spreadsheet):
+    table_range = spreadsheet.open_by_id('whatever').get_sheet_by_name('Sheet1').get_data_range()
+    return Table(
+        full_range=table_range,
+        notes=False,
+        backgrounds=False,
+        font_colors=False
+    )
+
+
+@pytest.fixture()
+def full_table(full_spreadsheet):
+    table_range = full_spreadsheet.open_by_id('whatever').get_sheet_by_name('Sheet1').get_data_range()
+    return Table(
+        full_range=table_range,
+        notes=True,
+        backgrounds=True,
+        font_colors=True
+    )

tests/test_table.py

@@ -1,54 +1,36 @@
-from sheetfu import Table
+import pytest
+
+from sheetfu import SpreadsheetApp, Table
+from sheetfu.model import Range
 from sheetfu.modules.table import Item
 from tests.utils import mock_google_sheets_responses
-from sheetfu import SpreadsheetApp
-from sheetfu.model import Range
 
 
 class TestTableRanges:
 
-    http_mocks = mock_google_sheets_responses([
-        'table_get_sheets.json',
-        'table_check_data_range.json',
-        'table_values.json',
-        'table_values.json',
-        'table_notes.json',
-        'table_backgrounds.json',
-        'table_font_colors.json'
-    ])
-
-    sa = SpreadsheetApp(http=http_mocks)
-    table_range = sa.open_by_id('whatever').get_sheet_by_name('Sheet1').get_data_range()
-    table = Table(
-        full_range=table_range,
-        notes=True,
-        backgrounds=True,
-        font_colors=True
-    )
-
-    def test_full_range_data(self):
-        for item in self.table.items:
+    def test_full_range_data(self, full_table):
+        for item in full_table.items:
             assert item.backgrounds is not None
             assert item.notes is not None
             assert item.font_colors is not None
             assert item.values is not None
-            assert len(item.header) == len(self.table.header)
+            assert len(item.header) == len(full_table.header)
 
-    def test_items(self):
-        assert self.table.items is not None
-        assert type(self.table.items) == list
-        assert len(self.table.items) == self.table.full_range.coordinates.number_of_rows - 1
+    def test_items(self, full_table):
+        assert full_table.items is not None
+        assert type(full_table.items) == list
+        assert len(full_table.items) == full_table.full_range.coordinates.number_of_rows - 1
 
-    def test_items_instance(self):
-        for item in self.table.items:
+    def test_items_instance(self, full_table):
+        for item in full_table.items:
             assert isinstance(item, Item)
             assert isinstance(item.get_range(), Range)
 
-    def test_table_length(self):
-        assert len(self.table) == len(self.table.items)
+    def test_table_length(self, full_table):
+        assert len(full_table) == len(full_table.items)
 
-    def test_for_loops(self):
-        for item in self.table:
+    def test_for_loops(self, full_table):
+        for item in full_table:
             assert isinstance(item, Item)
 
 
@@ -98,106 +80,75 @@ def test_get_field_font_colors(self):
 
 
 class TestTableItemRanges:
-    http_mocks = mock_google_sheets_responses([
-        'table_get_sheets.json',
-        'table_check_data_range.json',
-        'table_values.json',
-        'table_values.json',
-        'table_notes.json',
-        'table_backgrounds.json',
-        'table_font_colors.json'
-    ])
-
-    sa = SpreadsheetApp(http=http_mocks)
-    table_range = sa.open_by_id('whatever').get_sheet_by_name('Sheet1').get_data_range()
-    table = Table(
-        full_range=table_range,
-        notes=True,
-        backgrounds=True,
-        font_colors=True
-    )
 
-    def test_table_range(self):
-        assert self.table.full_range.a1 == 'Sheet1!A1:C6'
+    def test_table_range(self, full_table):
+        assert full_table.full_range.a1 == 'Sheet1!A1:C6'
 
-    def test_table_items_range(self):
-        assert self.table.items_range.a1 == 'Sheet1!A2:C6'
+    def test_table_items_range(self, full_table):
+        assert full_table.items_range.a1 == 'Sheet1!A2:C6'
 
-    def test_first_item_range(self):
-        first_item = self.table[0]
+    def test_first_item_range(self, full_table):
+        first_item = full_table[0]
         assert isinstance(first_item, Item)
         assert first_item.get_range().a1 == 'Sheet1!A2:C2'
 
-    def test_field_ranges_type(self):
-        second_item = self.table[1]
+    def test_field_ranges_type(self, full_table):
+        second_item = full_table[1]
         assert isinstance(second_item, Item)
         assert second_item.get_range().a1 == 'Sheet1!A3:C3'
 
         for field in ['name', 'surname', 'age']:
             field_range = second_item.get_field_range(field)
             assert isinstance(field_range, Range)
 
-    def test_field_ranges(self):
-        third_item = self.table[2]
+    def test_field_ranges(self, full_table):
+        third_item = full_table[2]
         assert third_item.get_field_range('name').a1 == 'Sheet1!A4'
         assert third_item.get_field_range('surname').a1 == 'Sheet1!B4'
         assert third_item.get_field_range('age').a1 == 'Sheet1!C4'
 
 
 class TestTableCRUD:
-    http_mocks = mock_google_sheets_responses([
-        'table_get_sheets.json',
-        'table_check_data_range.json',
-        'table_values.json',
-        'table_values.json',
-        'table_commit_reply.json',
-        'table_commit_reply.json',
-        'table_commit_reply.json',
-    ])
-
-    sa = SpreadsheetApp(http=http_mocks)
-    table_range = sa.open_by_id('whatever').get_sheet_by_name('Sheet1').get_data_range()
-    table = Table(
-        full_range=table_range,
-        notes=False,
-        backgrounds=False,
-        font_colors=False
-    )
-
-    def test_add_one_item(self):
-        assert self.table.full_range.a1 == "Sheet1!A1:C6"
-        assert self.table.items_range.a1 == "Sheet1!A2:C6"
-        assert len(self.table.items) == 5
-        self.table.add_one({"name": "Alex", "surname": "Muelas", "age": 1})
-        assert self.table.full_range.a1 == "Sheet1!A1:C7"
-        assert self.table.items_range.a1 == "Sheet1!A2:C7"
-        assert len(self.table.batches) == 1
-        assert len(self.table.items) == 6
-        self.table.commit()
-        assert len(self.table.batches) == 0
-        assert len(self.table.items) == 6
-
-    def test_add_several_items(self):
-        assert len(self.table.items) == 6
-        assert self.table.full_range.a1 == "Sheet1!A1:C7"
-        assert self.table.items_range.a1 == "Sheet1!A2:C7"
-        self.table.add_one({"name": "John", "surname": "Snpw", "age": 2})
-        self.table.add_one({"name": "Ned", "surname": "Stark", "age": 3})
-        self.table.add_one({"name": "Tyrion", "surname": "Lannister", "age": 4})
-        assert len(self.table.batches) == 3
-        assert len(self.table.items) == 9
-        self.table.commit()
-        assert len(self.table.batches) == 0
-        assert len(self.table.items) == 9
-        assert self.table.full_range.a1 == "Sheet1!A1:C10"
-        assert self.table.items_range.a1 == "Sheet1!A2:C10"
-
-    def test_sort_table(self):
-        assert len(self.table.items) == 9
-        self.table.sort("age")
-        assert len(self.table.items) == 9
-        assert self.table.items[0].get_field_value("name") == "Alex"
-        assert self.table.items[8].get_field_value("name") == "philippe"
-        assert self.table.needs_full_table_syncro == True
-
 
+    def test_add_one_item(self, table):
+        assert table.full_range.a1 == "Sheet1!A1:C6"
+        assert table.items_range.a1 == "Sheet1!A2:C6"
+        assert len(table.items) == 5
+        table.add_one({"name": "Alex", "surname": "Muelas", "age": 1})
+        assert table.full_range.a1 == "Sheet1!A1:C7"
+        assert table.items_range.a1 == "Sheet1!A2:C7"
+        assert len(table.batches) == 1
+        assert len(table.items) == 6
+        table.commit()
+        assert len(table.batches) == 0
+        assert len(table.items) == 6
+
+    def test_add_several_items(self, table):
+        assert len(table.items) == 5
+        assert table.full_range.a1 == "Sheet1!A1:C6"
+        assert table.items_range.a1 == "Sheet1!A2:C6"
+        table.add_one({"name": "John", "surname": "Snpw", "age": 2})
+        table.add_one({"name": "Ned", "surname": "Stark", "age": 3})
+        table.add_one({"name": "Tyrion", "surname": "Lannister", "age": 4})
+        assert len(table.batches) == 3
+        assert len(table.items) == 8
+        table.commit()
+        assert len(table.batches) == 0
+        assert len(table.items) == 8
+        assert table.full_range.a1 == "Sheet1!A1:C9"
+        assert table.items_range.a1 == "Sheet1!A2:C9"
+
+    def test_sort_table(self, table):
+        assert len(table.items) == 5
+        table.sort("name")
+        assert len(table.items) == 5
+        assert table.items[0].get_field_value("name") == "jane"
+        assert table.items[4].get_field_value("name") == "random"
+        assert table.needs_full_table_syncro == True
+        table.sort("name", reverse=True)
+        assert table.items[0].get_field_value("name") == "random"
+        assert table.items[4].get_field_value("name") == "jane"
+
+    def get_table_from_sheet(self, spreadsheet):
+        table = Table.get_table_from_sheet(spreadsheet, "Sheet1")
+        assert len(table.items) == 5