opt(table): Update database properties & rows sorting

Author: kaedea

notion_page.py

@@ -1050,6 +1050,8 @@ def _parse_collection(self, page_blocks: typing.List[PageBaseBlock], block):
             # Parse column weight configuration from description
             description = database.get('description', [])
             column_weights = self._parse_column_weights(description)
+            if column_weights:
+                print(f"[Database Parsing] Found property-order config: {column_weights}")
 
             # Prepare HTTP client
             http_client_req = None
@@ -1076,13 +1078,25 @@ def _parse_collection(self, page_blocks: typing.List[PageBaseBlock], block):
 
             # Determine sorting logic using utility class
             from utils.database_utils import DatabaseColumnOrderingUtils
-            sorts = DatabaseColumnOrderingUtils.get_database_sorts(properties)
-        
-            # If properties are empty (common with Inline Databases), we miss schema info for sorting.
-            # Perform a pre-query to infer schema from the first row to check for 'Order' column.
-            is_default_sort = len(sorts) == 1 and sorts[0].get('timestamp') == 'created_time'
+            
+            # Check for page-order configuration in description first
+            description_text = NotionUtils.get_plain_text(description)
+            page_order_sorts = DatabaseColumnOrderingUtils.parse_page_order(description_text)
+            
+            if page_order_sorts:
+                print(f"[Database Parsing] Found page-order config: {page_order_sorts}")
+                sorts = page_order_sorts
+                # Bypassing pre-query if page-order is configured
+                is_default_sort = False
+            else:
+                sorts = DatabaseColumnOrderingUtils.get_database_sorts(properties)
+                print(f"[Database Parsing] Using schema-based/default sorts: {sorts}")
+                # If properties are empty (common with Inline Databases), we miss schema info for sorting.
+                # Perform a pre-query to infer schema from the first row to check for 'Order' column.
+                is_default_sort = len(sorts) == 1 and sorts[0].get('timestamp') == 'created_time'
 
             if not properties and is_default_sort:
+                print(f"[Database Parsing] Schema properties empty & default sort detected. Attempting Pre-query inference...")
                 # Pre-query one row to check schema
                 pre_query_body = {
                     "page_size": 1,
@@ -1096,9 +1110,14 @@ def _parse_collection(self, page_blocks: typing.List[PageBaseBlock], block):
                     if pre_results:
                         # Infer properties from row data
                         inferred_props = pre_results[0].get('properties', {})
+                        print(f"[Database Parsing] Inferred properties from Pre-query: {list(inferred_props.keys())}")
+                        # Re-calculate sorts with inferred properties
                         sorts = DatabaseColumnOrderingUtils.get_database_sorts(inferred_props)
+                        print(f"[Database Parsing] Recalculated sorts after inference: {sorts}")
+                    else:
+                        print("[Database Parsing] Pre-query returned no results. Cannot infer schema.")
                 except Exception as e:
-                    print(f"Failed to infer schema for sorting: {e}")
+                    print(f"[Database Parsing] Failed to infer schema for sorting: {e}")
 
             query_body = {
                 "sorts": sorts
@@ -1108,16 +1127,22 @@ def _parse_collection(self, page_blocks: typing.List[PageBaseBlock], block):
 
             response.raise_for_status()
             results = response.json().get('results', [])
+            print(f"[Database Parsing] Query returned {len(results)} rows.")
 
             headers = list(properties.keys()) if properties else []
             if not headers and results:
                 # Infer headers from the first row if schema properties are empty
                 first_row_props = results[0].get('properties', {})
                 headers = list(first_row_props.keys())
+                print(f"[Database Parsing] Inferred headers from first row: {headers}")
 
             # Apply column ordering
             if headers and column_weights:
+                # Only apply weighted ordering if explicitly configured
                 headers = self._sort_columns_by_weight(headers, column_weights)
+                print(f"[Database Parsing] Applied column weights. Final headers: {headers}")
+            elif headers:
+                 print(f"[Database Parsing] No column weights config. Using default headers: {headers}")
 
             rows = []
             for page in results:

tests/notion-sdk-py-official-apis/test_database_parsing.py

@@ -248,5 +248,57 @@ def test_database_row_sorting(self):
 
         print("✓ All row sorting tests passed")
 
+    def test_page_order_configuration(self):
+        """Test parsing of page-order configuration."""
+        print("\n[Test] Page Order Configuration")
+        from utils.database_utils import DatabaseColumnOrderingUtils
+
+        # Test 1: Simple page-order
+        desc_1 = "Some text\npage-order: Order1, Created\nMore text"
+        sorts_1 = DatabaseColumnOrderingUtils.parse_page_order(desc_1)
+        print(f"Test 1 - Simple: {sorts_1}")
+        self.assertEqual(len(sorts_1), 2)
+        self.assertEqual(sorts_1[0]['property'], 'Order1')
+        self.assertEqual(sorts_1[1]['timestamp'], 'created_time')
+
+        # Test 2: Multi-line and case insensitive
+        desc_2 = "page-order: Priority, Name, CREATED"
+        sorts_2 = DatabaseColumnOrderingUtils.parse_page_order(desc_2)
+        print(f"Test 2 - Multi keys: {sorts_2}")
+        self.assertEqual(len(sorts_2), 3)
+        self.assertEqual(sorts_2[0]['property'], 'Priority')
+        self.assertEqual(sorts_2[2]['timestamp'], 'created_time')
+
+        # Test 3: No config
+        desc_3 = "Just description"
+        sorts_3 = DatabaseColumnOrderingUtils.parse_page_order(desc_3)
+        self.assertIsNone(sorts_3)
+        
+        print("✓ All page-order tests passed")
+
+    def test_column_hiding(self):
+        """Test hiding columns via negative weights."""
+        print("\n[Test] Column Hiding")
+        from utils.database_utils import DatabaseColumnOrderingUtils
+
+        headers = ['Title', 'Tags', 'Secret', 'Date']
+        weights = {
+            'Title': 100,
+            'Secret': -1,  # Should be hidden
+            'Tags': 50
+        }
+        
+        sorted_headers = DatabaseColumnOrderingUtils.sort_columns_by_weight(headers, weights)
+        print(f"Original: {headers}")
+        print(f"Weights: {weights}")
+        print(f"Result: {sorted_headers}")
+        
+        self.assertNotIn('Secret', sorted_headers)
+        self.assertEqual(sorted_headers[0], 'Title')
+        self.assertEqual(sorted_headers[1], 'Tags')
+        self.assertIn('Date', sorted_headers) # Default weight 0
+        
+        print("✓ Column hiding tests passed")
+
 if __name__ == '__main__':
     unittest.main()

utils/database_utils.py

@@ -57,38 +57,83 @@ def parse_column_weights(description_text: str) -> Optional[Dict[str, int]]:
 
         return weights if weights else None
 
+    @staticmethod
+    def parse_page_order(description_text: str) -> Optional[List[Dict[str, str]]]:
+        """
+        Parses page-order configuration from description text.
+        Format: page-order: Order1, Order2, Created
+        Returned format: Notion API sorts parameter
+        """
+        if not description_text:
+            return None
+            
+        pattern = r'(?:^|\n)\s*page-order:\s*(.+?)(?:\n|$)'
+        match = re.search(pattern, description_text, re.IGNORECASE | re.MULTILINE)
+        
+        if not match:
+            return None
+            
+        config_line = match.group(1).strip()
+        if not config_line:
+            return None
+            
+        sorts = []
+        parts = [p.strip() for p in config_line.split(',')]
+        
+        for part in parts:
+            if not part:
+                continue
+                
+            if part.lower() == 'created':
+                sorts.append({
+                    "timestamp": "created_time",
+                    "direction": "ascending"
+                })
+            else:
+                sorts.append({
+                    "property": part,
+                    "direction": "ascending"
+                })
+                
+        return sorts if sorts else None
+
     @staticmethod
     def sort_columns_by_weight(headers: List[str], weights: Optional[Dict[str, int]]) -> List[str]:
-        """Sort columns based on weight configuration.
+        """
+        Sorts the headers based on the weights.
         
-        Columns with higher weights appear first. Columns not in the weights dict
-        get a default weight of 0. Stable sort is used to preserve original order
-        for columns with the same weight.
+        If weights is provided, headers are sorted descending by weight.
+        Headers not in weights get a default weight of 0.
+        Negative weights mean the column should be hidden (removed).
         
         Args:
             headers: List of column names
-            weights: dict of {column_name: weight}, or None
+            weights: dict of {column_name: weight}
             
         Returns:
-            Sorted list of column names (higher weight first)
+            Sorted and filtered list of column names
             
-        Examples:
-            >>> headers = ['ID', 'Status', 'Name', 'Age', 'Email']
-            >>> weights = {'Name': 100, 'Email': 90, 'Status': 80}
-            >>> DatabaseColumnOrderingUtils.sort_columns_by_weight(headers, weights)
-            ['Name', 'Email', 'Status', 'ID', 'Age']
+        Example: 
+            >>> headers = ['Title', 'Tags', 'Secret']
+            >>> weights = {'Title': 100, 'Secret': -1}
+            >>> result = sort_columns_by_weight(headers, weights)
+            ['Title', 'Tags']
         """
         if not weights:
             return headers
-        
-        # Assign weight to each column (default 0 for unspecified)
-        def get_weight(col_name: str) -> int:
-            return weights.get(col_name, 0)
-        
-        # Sort by weight descending (higher weight = earlier position)
-        # Use stable sort to preserve original order for same-weight columns
-        sorted_headers = sorted(headers, key=get_weight, reverse=True)
-        
+
+        # Default weight for unassigned headers is 0
+        def get_weight(header):
+            return weights.get(header, 0)
+        
+        # Filter out headers with negative weights
+        visible_headers = [
+            h for h in headers 
+            if get_weight(h) >= 0
+        ]
+
+        # Use a stable sort to keep relative order of items with same weight
+        sorted_headers = sorted(visible_headers, key=get_weight, reverse=True)
         return sorted_headers
 
     @staticmethod