aspose-cells-foss 25.12.1__py3-none-any.whl

aspose/cells/io/interfaces.py

@@ -0,0 +1,48 @@
+"""
+Unified interfaces for format handlers.
+"""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..workbook import Workbook
+    from .models import WorkbookData
+
+
+class IFormatHandler(ABC):
+    """Unified interface for format handlers."""
+    
+    @abstractmethod
+    def load_workbook(self, workbook: 'Workbook', file_path: str, **options) -> None:
+        """
+        Load file into workbook object.
+        Maintains compatibility with existing interface.
+        """
+        pass
+    
+    @abstractmethod
+    def save_workbook(self, workbook: 'Workbook', file_path: str, **options) -> None:
+        """
+        Save workbook object to file.
+        Maintains compatibility with existing interface.
+        """
+        pass
+    
+    def read_to_data(self, file_path: str, **options) -> 'WorkbookData':
+        """Read file and return unified data model."""
+        from ..workbook import Workbook
+        from .models import WorkbookData
+        
+        temp_workbook = Workbook()
+        # Clear default sheet since we're loading from file
+        temp_workbook._worksheets.clear()
+        temp_workbook._active_sheet = None
+        
+        self.load_workbook(temp_workbook, file_path, **options)
+        return WorkbookData.from_workbook(temp_workbook)
+    
+    def write_from_data(self, data: 'WorkbookData', file_path: str, **options) -> None:
+        """Write unified data model to file."""
+        workbook = data.to_workbook()
+        self.save_workbook(workbook, file_path, **options)

aspose/cells/io/json/__init__.py

@@ -0,0 +1,8 @@
+"""
+JSON I/O operations.
+"""
+
+from .reader import JsonReader
+from .writer import JsonWriter
+
+__all__ = ["JsonReader", "JsonWriter"]

aspose/cells/io/json/reader.py

@@ -0,0 +1,126 @@
+"""
+JSON file reader for loading JSON data into workbook format.
+"""
+
+import json
+from typing import Dict, List, Optional, Union, Any, TYPE_CHECKING
+from pathlib import Path
+from ...formats import CellValue
+
+if TYPE_CHECKING:
+    from ...workbook import Workbook
+
+
+class JsonReader:
+    """Reader for JSON files."""
+    
+    def __init__(self):
+        pass
+    
+    def read(self, file_path: str, **kwargs) -> Union[List[List[CellValue]], Dict[str, List[List[CellValue]]]]:
+        """Read JSON file and return data in tabular format."""
+        encoding = kwargs.get('encoding', 'utf-8')
+        
+        try:
+            with open(file_path, 'r', encoding=encoding) as file:
+                data = json.load(file)
+            
+            return self._convert_json_to_tabular(data)
+                
+        except FileNotFoundError:
+            raise FileNotFoundError(f"JSON file not found: {file_path}")
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON format: {e}")
+        except Exception as e:
+            raise ValueError(f"Error reading JSON file: {e}")
+    
+    def _convert_json_to_tabular(self, data: Any) -> Union[List[List[CellValue]], Dict[str, List[List[CellValue]]]]:
+        """Convert JSON data to tabular format."""
+        if isinstance(data, dict):
+            # Check if it's a multi-sheet format (keys are sheet names)
+            if all(isinstance(v, list) for v in data.values()):
+                result = {}
+                for sheet_name, sheet_data in data.items():
+                    result[sheet_name] = self._convert_list_to_rows(sheet_data)
+                return result
+            else:
+                # Single object, convert to single row
+                return self._convert_dict_to_rows(data)
+        elif isinstance(data, list):
+            return self._convert_list_to_rows(data)
+        else:
+            # Single value, create single cell
+            return [[self._convert_value(data)]]
+    
+    def _convert_list_to_rows(self, data_list: List[Any]) -> List[List[CellValue]]:
+        """Convert list of objects/values to rows."""
+        if not data_list:
+            return []
+        
+        if isinstance(data_list[0], dict):
+            # List of objects - create header from keys
+            headers = list(data_list[0].keys()) if data_list else []
+            rows = [headers]  # Add header row
+            
+            for item in data_list:
+                row = []
+                for header in headers:
+                    value = item.get(header) if isinstance(item, dict) else None
+                    row.append(self._convert_value(value))
+                rows.append(row)
+            
+            return rows
+        else:
+            # List of simple values - convert to single column
+            return [[self._convert_value(item)] for item in data_list]
+    
+    def _convert_dict_to_rows(self, data_dict: Dict[str, Any]) -> List[List[CellValue]]:
+        """Convert dictionary to rows (key-value pairs)."""
+        rows = []
+        for key, value in data_dict.items():
+            if isinstance(value, (list, dict)):
+                # Complex value, convert to JSON string
+                value_str = json.dumps(value, ensure_ascii=False)
+                rows.append([key, value_str])
+            else:
+                rows.append([key, self._convert_value(value)])
+        return rows
+    
+    def _convert_value(self, value: Any) -> CellValue:
+        """Convert JSON value to appropriate cell value."""
+        if value is None:
+            return None
+        elif isinstance(value, bool):
+            return value
+        elif isinstance(value, (int, float)):
+            return value
+        elif isinstance(value, str):
+            return value
+        else:
+            # Complex types, convert to JSON string
+            return json.dumps(value, ensure_ascii=False)
+    
+    def load_workbook(self, workbook: 'Workbook', file_path: str, **options) -> None:
+        """Load JSON file into workbook object."""
+        data = self.read(file_path, **options)
+        
+        # Clear existing worksheets
+        workbook._worksheets.clear()
+        workbook._active_sheet = None
+        
+        if isinstance(data, dict):
+            # Multi-sheet format
+            for sheet_name, sheet_rows in data.items():
+                worksheet = workbook.create_sheet(sheet_name)
+                self._populate_worksheet(worksheet, sheet_rows)
+        else:
+            # Single sheet format
+            worksheet = workbook.create_sheet("Sheet1")
+            self._populate_worksheet(worksheet, data)
+    
+    def _populate_worksheet(self, worksheet, rows: List[List[CellValue]]) -> None:
+        """Populate worksheet with row data."""
+        for row_idx, row_data in enumerate(rows, 1):
+            for col_idx, cell_value in enumerate(row_data, 1):
+                if cell_value is not None:
+                    worksheet.cell(row_idx, col_idx, cell_value)

aspose/cells/io/json/writer.py

@@ -0,0 +1,119 @@
+"""
+JSON file writer for saving workbook data to JSON format.
+"""
+
+import json
+from typing import Dict, List, Optional, Union, TYPE_CHECKING
+from ...formats import CellValue
+
+if TYPE_CHECKING:
+    from ...workbook import Workbook
+    from ...worksheet import Worksheet
+
+
+class JsonWriter:
+    """Writer for JSON files."""
+    
+    def __init__(self):
+        pass
+    
+    def write(self, file_path: str, data: Union[List[Dict], Dict], **kwargs) -> None:
+        """Write data to JSON file."""
+        pretty_print = kwargs.get('pretty_print', False)
+        encoding = kwargs.get('encoding', 'utf-8')
+        
+        try:
+            with open(file_path, 'w', encoding=encoding) as file:
+                if pretty_print:
+                    json.dump(data, file, indent=2, ensure_ascii=False)
+                else:
+                    json.dump(data, file, ensure_ascii=False)
+                    
+        except Exception as e:
+            raise ValueError(f"Error writing JSON file: {e}")
+    
+    def write_workbook(self, file_path: str, workbook: 'Workbook', **kwargs) -> None:
+        """Write workbook data to JSON file."""
+        include_empty_cells = kwargs.get('include_empty_cells', False)
+        all_sheets = kwargs.get('all_sheets', False)
+        sheet_name = kwargs.get('sheet_name')
+        
+        if sheet_name:
+            # Export specific sheet
+            if sheet_name in workbook._worksheets:
+                worksheet = workbook._worksheets[sheet_name]
+                result = self._convert_worksheet(worksheet, include_empty_cells)
+            else:
+                result = []
+        elif all_sheets:
+            # Export all sheets with sheet names as keys
+            result = {}
+            for name, worksheet in workbook._worksheets.items():
+                sheet_data = self._convert_worksheet(worksheet, include_empty_cells)
+                result[name] = sheet_data
+        else:
+            # Export only active sheet as simple list
+            result = self._convert_worksheet(workbook.active, include_empty_cells)
+        
+        self.write(file_path, result, **kwargs)
+    
+    def _convert_worksheet(self, worksheet: 'Worksheet', include_empty_cells: bool = False) -> List[Dict[str, Union[str, int, float, bool, None]]]:
+        """Convert worksheet to list of row dictionaries."""
+        if not worksheet._cells and not include_empty_cells:
+            return []
+        
+        # Find actual data bounds
+        if not worksheet._cells:
+            return []
+        
+        max_row = worksheet.max_row
+        max_col = worksheet.max_column
+        
+        if max_row == 0 or max_col == 0:
+            return []
+        
+        # Convert to list of dictionaries
+        result = []
+        
+        # Generate column headers (A, B, C, etc.)
+        headers = []
+        for col in range(1, max_col + 1):
+            col_name = ""
+            temp_col = col - 1
+            while temp_col >= 0:
+                col_name = chr(ord('A') + (temp_col % 26)) + col_name
+                temp_col = temp_col // 26 - 1
+            headers.append(col_name)
+        
+        # Process all data rows
+        for row in range(1, max_row + 1):
+            row_data = {}
+            has_data = False
+            
+            for col in range(1, max_col + 1):
+                cell = worksheet._cells.get((row, col))
+                header = headers[col - 1] if col <= len(headers) else f"Column{col}"
+                
+                if cell and cell.value is not None:
+                    row_data[header] = self._convert_cell_value(cell.value)
+                    has_data = True
+                elif include_empty_cells:
+                    row_data[header] = None
+            
+            if has_data or include_empty_cells:
+                result.append(row_data)
+        
+        return result
+    
+    def _convert_cell_value(self, value: CellValue) -> Union[str, int, float, bool, None]:
+        """Convert cell value to JSON-serializable format."""
+        if value is None:
+            return None
+        elif isinstance(value, (str, int, float, bool)):
+            return value
+        else:
+            return str(value)
+    
+    def save_workbook(self, workbook: 'Workbook', file_path: str, **options) -> None:
+        """Save workbook to JSON file - unified interface method."""
+        self.write_workbook(file_path, workbook, **options)

aspose/cells/io/md/__init__.py

@@ -0,0 +1,8 @@
+"""
+Markdown I/O operations.
+"""
+
+from .reader import MarkdownReader
+from .writer import MarkdownWriter
+
+__all__ = ["MarkdownReader", "MarkdownWriter"]

aspose/cells/io/md/reader.py

@@ -0,0 +1,161 @@
+"""
+Markdown table reader for loading Markdown table data into workbook format.
+"""
+
+import re
+from typing import Dict, List, Optional, Union, TYPE_CHECKING
+from pathlib import Path
+from ...formats import CellValue
+
+if TYPE_CHECKING:
+    from ...workbook import Workbook
+
+
+class MarkdownReader:
+    """Reader for Markdown table files."""
+    
+    def __init__(self):
+        pass
+    
+    def read(self, file_path: str, **kwargs) -> Union[List[List[CellValue]], Dict[str, List[List[CellValue]]]]:
+        """Read Markdown file and extract table data."""
+        encoding = kwargs.get('encoding', 'utf-8')
+        
+        try:
+            with open(file_path, 'r', encoding=encoding) as file:
+                content = file.read()
+            
+            return self._parse_markdown_tables(content)
+                
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Markdown file not found: {file_path}")
+        except Exception as e:
+            raise ValueError(f"Error reading Markdown file: {e}")
+    
+    def _parse_markdown_tables(self, content: str) -> Union[List[List[CellValue]], Dict[str, List[List[CellValue]]]]:
+        """Parse markdown content and extract tables."""
+        sections = self._split_by_headers(content)
+        
+        if len(sections) == 1 and sections[0]['name'] == 'default':
+            # Single table, return as list
+            return self._extract_tables_from_text(sections[0]['content'])
+        else:
+            # Multiple sections, return as dict
+            result = {}
+            for section in sections:
+                tables = self._extract_tables_from_text(section['content'])
+                if tables:  # Only add sections with tables
+                    result[section['name']] = tables
+            return result if result else [[]]
+    
+    def _split_by_headers(self, content: str) -> List[Dict[str, str]]:
+        """Split content by markdown headers."""
+        lines = content.split('\n')
+        sections = []
+        current_section = {'name': 'default', 'content': ''}
+        
+        for line in lines:
+            header_match = re.match(r'^#+\s+(.+)$', line.strip())
+            if header_match:
+                # Save current section if it has content
+                if current_section['content'].strip():
+                    sections.append(current_section)
+                # Start new section
+                current_section = {
+                    'name': header_match.group(1).strip(),
+                    'content': ''
+                }
+            else:
+                current_section['content'] += line + '\n'
+        
+        # Add final section
+        if current_section['content'].strip():
+            sections.append(current_section)
+        
+        return sections if sections else [{'name': 'default', 'content': content}]
+    
+    def _extract_tables_from_text(self, text: str) -> List[List[CellValue]]:
+        """Extract table data from text content."""
+        lines = text.split('\n')
+        table_rows = []
+        in_table = False
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                if in_table:
+                    break  # End of table
+                continue
+            
+            # Check if this is a table row (starts and ends with |)
+            if line.startswith('|') and line.endswith('|'):
+                # Skip separator lines (contain only |, -, :, and spaces)
+                if re.match(r'^[\|\-:\s]+$', line):
+                    continue
+                
+                in_table = True
+                # Parse table row
+                cells = [cell.strip() for cell in line[1:-1].split('|')]
+                converted_row = []
+                for cell in cells:
+                    # Unescape markdown special characters
+                    cell = cell.replace('\\|', '|')
+                    converted_row.append(self._convert_cell_value(cell))
+                table_rows.append(converted_row)
+            elif in_table:
+                # End of table
+                break
+        
+        return table_rows
+    
+    def _convert_cell_value(self, value: str) -> CellValue:
+        """Convert string value to appropriate Python type."""
+        if not value or value.strip() == "":
+            return None
+        
+        value = value.strip()
+        
+        # Try boolean first
+        if value.upper() in ('TRUE', 'FALSE'):
+            return value.upper() == 'TRUE'
+        
+        # Try integer
+        try:
+            if '.' not in value and 'e' not in value.lower():
+                return int(value)
+        except ValueError:
+            pass
+        
+        # Try float
+        try:
+            return float(value)
+        except ValueError:
+            pass
+        
+        # Return as string
+        return value
+    
+    def load_workbook(self, workbook: 'Workbook', file_path: str, **options) -> None:
+        """Load Markdown file into workbook object."""
+        data = self.read(file_path, **options)
+        
+        # Clear existing worksheets
+        workbook._worksheets.clear()
+        workbook._active_sheet = None
+        
+        if isinstance(data, dict):
+            # Multi-sheet format (multiple headers/sections)
+            for sheet_name, table_data in data.items():
+                worksheet = workbook.create_sheet(sheet_name)
+                self._populate_worksheet(worksheet, table_data)
+        else:
+            # Single table format
+            worksheet = workbook.create_sheet("Sheet1")
+            self._populate_worksheet(worksheet, data)
+    
+    def _populate_worksheet(self, worksheet, rows: List[List[CellValue]]) -> None:
+        """Populate worksheet with table data."""
+        for row_idx, row_data in enumerate(rows, 1):
+            for col_idx, cell_value in enumerate(row_data, 1):
+                if cell_value is not None:
+                    worksheet.cell(row_idx, col_idx, cell_value)