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

aspose/cells/formula/tokenizer.py

@@ -0,0 +1,340 @@
+"""
+Excel Formula Tokenizer - Based on opencells tokenizer
+Converts Excel formulas into token streams for evaluation.
+"""
+
+import re
+from typing import List, Optional
+
+
+class Token:
+    """Represents a single token in a formula."""
+    
+    # Token types
+    LITERAL = "LITERAL"
+    OPERAND = "OPERAND" 
+    FUNCTION = "FUNCTION"
+    SUBEXPR = "SUBEXPR"
+    ARGUMENT = "ARGUMENT"
+    OPERATOR = "OPERATOR"
+    WHITESPACE = "WHITESPACE"
+    ERROR = "ERROR"
+    
+    # Token subtypes
+    TEXT = "TEXT"
+    NUMBER = "NUMBER"
+    LOGICAL = "LOGICAL"
+    RANGE = "RANGE"
+    REFERENCE = "REFERENCE"
+    NAME = "NAME"
+    
+    # Operator types
+    MATH = "MATH"
+    CONCAT = "CONCAT"
+    INTERSECT = "INTERSECT"
+    UNION = "UNION"
+    
+    def __init__(self, value: str, type_: str, subtype: str = ""):
+        self.value = value
+        self.type = type_
+        self.subtype = subtype
+    
+    def __repr__(self):
+        return f"Token({self.value!r}, {self.type}, {self.subtype})"
+
+
+class Tokenizer:
+    """Tokenizer for Excel formulas."""
+    
+    # Regex patterns
+    CELL_REF_PATTERN = re.compile(r'^(\$?)([A-Z]+)(\$?)(\d+)$')
+    RANGE_PATTERN = re.compile(r'^(\$?[A-Z]+\$?\d+):(\$?[A-Z]+\$?\d+)$')
+    FUNCTION_PATTERN = re.compile(r'^[A-Z_][A-Z0-9_.]*$')
+    NUMBER_PATTERN = re.compile(r'^-?\d+(\.\d*)?([Ee][+-]?\d+)?$|^-?\d*\.\d+([Ee][+-]?\d+)?$')
+    
+    # Excel error codes
+    ERROR_CODES = {'#NULL!', '#DIV/0!', '#VALUE!', '#REF!', '#NAME?', '#NUM!', '#N/A'}
+    
+    def __init__(self, formula: str):
+        self.formula = formula.strip()
+        self.tokens: List[Token] = []
+        self.position = 0
+        self._tokenize()
+    
+    def _tokenize(self):
+        """Parse the formula into tokens."""
+        if not self.formula:
+            return
+        
+        # Skip leading = if present
+        if self.formula.startswith('='):
+            self.position = 1
+        
+        while self.position < len(self.formula):
+            self._skip_whitespace()
+            if self.position >= len(self.formula):
+                break
+                
+            if self._try_string():
+                continue
+            elif self._try_number():
+                continue
+            elif self._try_operator():
+                continue
+            elif self._try_function():
+                continue
+            elif self._try_reference():
+                continue
+            elif self._try_error():
+                continue
+            elif self._try_parenthesis():
+                continue
+            elif self._try_separator():
+                continue
+            else:
+                # Unknown character, treat as text
+                self._consume_text()
+    
+    def _current_char(self) -> Optional[str]:
+        """Get current character."""
+        if self.position < len(self.formula):
+            return self.formula[self.position]
+        return None
+    
+    def _peek_char(self, offset: int = 1) -> Optional[str]:
+        """Peek ahead at character."""
+        pos = self.position + offset
+        if pos < len(self.formula):
+            return self.formula[pos]
+        return None
+    
+    def _skip_whitespace(self):
+        """Skip whitespace characters."""
+        while self.position < len(self.formula) and self.formula[self.position].isspace():
+            self.position += 1
+    
+    def _try_string(self) -> bool:
+        """Try to parse a quoted string."""
+        char = self._current_char()
+        if char not in ('"', "'"):
+            return False
+        
+        quote_char = char
+        start_pos = self.position
+        self.position += 1  # Skip opening quote
+        value = ''
+        
+        while self.position < len(self.formula):
+            char = self._current_char()
+            if char == quote_char:
+                # Check for escaped quote (doubled quotes)
+                if self._peek_char() == quote_char:
+                    value += quote_char
+                    self.position += 2
+                else:
+                    self.position += 1  # Skip closing quote
+                    break
+            else:
+                value += char
+                self.position += 1
+        
+        self.tokens.append(Token(value, Token.OPERAND, Token.TEXT))
+        return True
+    
+    def _try_number(self) -> bool:
+        """Try to parse a number."""
+        start_pos = self.position
+        value = ''
+        
+        # Only handle negative sign if it's at the start or after an operator/opening paren
+        can_be_negative = (
+            len(self.tokens) == 0 or  # Start of formula
+            self.tokens[-1].type in (Token.OPERATOR, Token.SUBEXPR, Token.ARGUMENT)
+        )
+        
+        # Handle negative sign only in valid contexts
+        if self._current_char() == '-' and can_be_negative:
+            value += '-'
+            self.position += 1
+        elif self._current_char() == '-':
+            # It's likely a subtraction operator, not a negative number
+            return False
+        
+        # Collect digits and decimal points
+        while self.position < len(self.formula):
+            char = self._current_char()
+            if char.isdigit() or char == '.':
+                value += char
+                self.position += 1
+            elif char in 'Ee' and value and value[-1].isdigit():
+                # Scientific notation
+                value += char
+                self.position += 1
+                # Handle optional +/- after E
+                if self._current_char() in '+-':
+                    value += self._current_char()
+                    self.position += 1
+            else:
+                break
+        
+        if value and self.NUMBER_PATTERN.match(value):
+            self.tokens.append(Token(value, Token.OPERAND, Token.NUMBER))
+            return True
+        else:
+            # Not a valid number, reset position
+            self.position = start_pos
+            return False
+    
+    def _try_operator(self) -> bool:
+        """Try to parse an operator."""
+        char = self._current_char()
+        operators = {
+            '+': (Token.OPERATOR, Token.MATH),
+            '-': (Token.OPERATOR, Token.MATH),
+            '*': (Token.OPERATOR, Token.MATH),
+            '/': (Token.OPERATOR, Token.MATH),
+            '^': (Token.OPERATOR, Token.MATH),
+            '&': (Token.OPERATOR, Token.CONCAT),
+            '=': (Token.OPERATOR, Token.MATH),
+            '<': (Token.OPERATOR, Token.MATH),
+            '>': (Token.OPERATOR, Token.MATH),
+            '%': (Token.OPERATOR, Token.MATH),
+        }
+        
+        if char in operators:
+            # Check for multi-character operators
+            next_char = self._peek_char()
+            if char == '<' and next_char == '>':
+                self.tokens.append(Token('<>', Token.OPERATOR, Token.MATH))
+                self.position += 2
+            elif char == '<' and next_char == '=':
+                self.tokens.append(Token('<=', Token.OPERATOR, Token.MATH))
+                self.position += 2
+            elif char == '>' and next_char == '=':
+                self.tokens.append(Token('>=', Token.OPERATOR, Token.MATH))
+                self.position += 2
+            else:
+                type_, subtype = operators[char]
+                self.tokens.append(Token(char, type_, subtype))
+                self.position += 1
+            return True
+        return False
+    
+    def _try_function(self) -> bool:
+        """Try to parse a function name."""
+        start_pos = self.position
+        value = ''
+        
+        # Functions start with letter or underscore
+        char = self._current_char()
+        if not (char.isalpha() or char == '_'):
+            return False
+        
+        # Collect function name
+        while self.position < len(self.formula):
+            char = self._current_char()
+            if char.isalnum() or char in '_.':
+                value += char
+                self.position += 1
+            else:
+                break
+        
+        # Check if followed by opening parenthesis
+        self._skip_whitespace()
+        if self._current_char() == '(':
+            if self.FUNCTION_PATTERN.match(value.upper()):
+                self.tokens.append(Token(value.upper(), Token.FUNCTION))
+                return True
+        
+        # Not a function, reset position
+        self.position = start_pos
+        return False
+    
+    def _try_reference(self) -> bool:
+        """Try to parse a cell reference or range."""
+        start_pos = self.position
+        value = ''
+        
+        # Collect potential reference
+        while self.position < len(self.formula):
+            char = self._current_char()
+            if char.isalnum() or char in '$:':
+                value += char
+                self.position += 1
+            else:
+                break
+        
+        if value:
+            # Check for range (contains colon)
+            if ':' in value and self.RANGE_PATTERN.match(value.upper()):
+                self.tokens.append(Token(value.upper(), Token.OPERAND, Token.RANGE))
+                return True
+            # Check for single cell reference
+            elif self.CELL_REF_PATTERN.match(value.upper()):
+                self.tokens.append(Token(value.upper(), Token.OPERAND, Token.REFERENCE))
+                return True
+        
+        # Not a reference, reset position
+        self.position = start_pos
+        return False
+    
+    def _try_error(self) -> bool:
+        """Try to parse an error value."""
+        start_pos = self.position
+        if self._current_char() != '#':
+            return False
+        
+        value = ''
+        while self.position < len(self.formula):
+            char = self._current_char()
+            if char.isalnum() or char in '#!/?':
+                value += char
+                self.position += 1
+            else:
+                break
+        
+        if value in self.ERROR_CODES:
+            self.tokens.append(Token(value, Token.OPERAND, Token.ERROR))
+            return True
+        else:
+            self.position = start_pos
+            return False
+    
+    def _try_parenthesis(self) -> bool:
+        """Try to parse parentheses."""
+        char = self._current_char()
+        if char == '(':
+            self.tokens.append(Token('(', Token.SUBEXPR, "OPEN"))
+            self.position += 1
+            return True
+        elif char == ')':
+            self.tokens.append(Token(')', Token.SUBEXPR, "CLOSE"))
+            self.position += 1
+            return True
+        return False
+    
+    def _try_separator(self) -> bool:
+        """Try to parse separators (comma, semicolon)."""
+        char = self._current_char()
+        if char in (',', ';'):
+            self.tokens.append(Token(char, Token.ARGUMENT))
+            self.position += 1
+            return True
+        return False
+    
+    def _consume_text(self):
+        """Consume remaining text as literal."""
+        value = ''
+        while self.position < len(self.formula):
+            char = self._current_char()
+            if char.isspace() or char in '()+-*/^&=<>%,;':
+                break
+            value += char
+            self.position += 1
+        
+        if value:
+            self.tokens.append(Token(value, Token.OPERAND, Token.TEXT))
+    
+    def __iter__(self):
+        """Iterate over tokens."""
+        return iter(self.tokens)

aspose/cells/io/__init__.py

@@ -0,0 +1,27 @@
+"""
+I/O module for Excel file reading and writing with unified format support.
+"""
+
+# Format-specific readers and writers
+from .csv import CsvReader, CsvWriter
+from .json import JsonReader, JsonWriter
+from .md import MarkdownReader, MarkdownWriter
+from .xlsx import XlsxReader, XlsxWriter
+
+# Unified architecture components
+from .models import WorkbookData
+from .interfaces import IFormatHandler
+from .factory import FormatHandlerFactory
+
+__all__ = [
+    # Format-specific components
+    "CsvReader", "CsvWriter",
+    "JsonReader", "JsonWriter", 
+    "MarkdownReader", "MarkdownWriter",
+    "XlsxReader", "XlsxWriter",
+    
+    # Unified architecture components
+    "WorkbookData",
+    "IFormatHandler", 
+    "FormatHandlerFactory"
+]

aspose/cells/io/csv/__init__.py

@@ -0,0 +1,8 @@
+"""
+CSV I/O operations.
+"""
+
+from .reader import CsvReader
+from .writer import CsvWriter
+
+__all__ = ["CsvReader", "CsvWriter"]

aspose/cells/io/csv/reader.py

@@ -0,0 +1,88 @@
+"""
+CSV file reader for loading CSV data into workbook format.
+"""
+
+import csv
+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 CsvReader:
+    """Reader for CSV files."""
+    
+    def __init__(self):
+        pass
+    
+    def read(self, file_path: str, **kwargs) -> List[List[CellValue]]:
+        """Read CSV file and return data as list of rows."""
+        delimiter = kwargs.get('delimiter', ',')
+        quotechar = kwargs.get('quotechar', '"')
+        encoding = kwargs.get('encoding', 'utf-8')
+        has_header = kwargs.get('has_header', False)
+        
+        try:
+            with open(file_path, 'r', encoding=encoding, newline='') as file:
+                reader = csv.reader(file, delimiter=delimiter, quotechar=quotechar)
+                
+                data = []
+                for row in reader:
+                    # Convert each cell value
+                    converted_row = []
+                    for cell in row:
+                        converted_row.append(self._convert_cell_value(cell))
+                    data.append(converted_row)
+                
+                return data
+                
+        except FileNotFoundError:
+            raise FileNotFoundError(f"CSV file not found: {file_path}")
+        except Exception as e:
+            raise ValueError(f"Error reading CSV file: {e}")
+    
+    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 CSV file into workbook object."""
+        data = self.read(file_path, **options)
+        
+        # Clear existing worksheets
+        workbook._worksheets.clear()
+        workbook._active_sheet = None
+        
+        # Create single worksheet
+        worksheet = workbook.create_sheet("Sheet1")
+        
+        # Populate worksheet with CSV data
+        for row_idx, row_data in enumerate(data, 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/csv/writer.py

@@ -0,0 +1,98 @@
+"""
+CSV file writer for saving workbook data to CSV format.
+"""
+
+import csv
+import io
+from typing import List, Optional, TYPE_CHECKING
+from ...formats import CellValue
+
+if TYPE_CHECKING:
+    from ...workbook import Workbook
+    from ...worksheet import Worksheet
+
+
+class CsvWriter:
+    """Writer for CSV files."""
+    
+    def __init__(self):
+        pass
+    
+    def write(self, file_path: str, data: List[List[CellValue]], **kwargs) -> None:
+        """Write data to CSV file."""
+        delimiter = kwargs.get('delimiter', ',')
+        quotechar = kwargs.get('quotechar', '"')
+        encoding = kwargs.get('encoding', 'utf-8')
+        
+        try:
+            with open(file_path, 'w', newline='', encoding=encoding) as file:
+                writer = csv.writer(file, delimiter=delimiter, quotechar=quotechar, 
+                                   quoting=csv.QUOTE_MINIMAL)
+                
+                for row in data:
+                    formatted_row = []
+                    for cell in row:
+                        formatted_row.append(self._format_cell_value(cell))
+                    writer.writerow(formatted_row)
+                    
+        except Exception as e:
+            raise ValueError(f"Error writing CSV file: {e}")
+    
+    def write_workbook(self, file_path: str, workbook: 'Workbook', **kwargs) -> None:
+        """Write workbook data to CSV file."""
+        sheet_name = kwargs.get('sheet_name')
+        
+        # Get target worksheet
+        if sheet_name and sheet_name in workbook._worksheets:
+            worksheet = workbook._worksheets[sheet_name]
+        else:
+            worksheet = workbook.active
+        
+        if not worksheet or not worksheet._cells:
+            # Write empty file
+            with open(file_path, 'w', newline='', encoding=kwargs.get('encoding', 'utf-8')) as file:
+                pass
+            return
+        
+        # Convert worksheet to data
+        data = self._worksheet_to_data(worksheet)
+        self.write(file_path, data, **kwargs)
+    
+    def _worksheet_to_data(self, worksheet: 'Worksheet') -> List[List[CellValue]]:
+        """Convert worksheet to list of rows."""
+        max_row = worksheet.max_row
+        max_col = worksheet.max_column
+        
+        if max_row == 0 or max_col == 0:
+            return []
+        
+        data = []
+        for row in range(1, max_row + 1):
+            row_data = []
+            for col in range(1, max_col + 1):
+                cell = worksheet._cells.get((row, col))
+                if cell and cell.value is not None:
+                    row_data.append(cell.value)
+                else:
+                    row_data.append(None)
+            
+            # Skip completely empty rows unless they're in the middle
+            if any(val is not None for val in row_data) or row < max_row:
+                data.append(row_data)
+        
+        return data
+    
+    def _format_cell_value(self, value: CellValue) -> str:
+        """Format cell value for CSV output."""
+        if value is None:
+            return ""
+        elif isinstance(value, bool):
+            return "TRUE" if value else "FALSE"
+        elif isinstance(value, (int, float)):
+            return str(value)
+        else:
+            return str(value)
+    
+    def save_workbook(self, workbook: 'Workbook', file_path: str, **options) -> None:
+        """Save workbook to CSV file - unified interface method."""
+        self.write_workbook(file_path, workbook, **options)

aspose/cells/io/factory.py

@@ -0,0 +1,138 @@
+"""
+Format handler factory for unified file processing.
+"""
+
+from typing import Dict, Optional, Type, List
+from pathlib import Path
+from .interfaces import IFormatHandler
+
+
+class FormatHandlerFactory:
+    """Factory for managing format handlers."""
+    
+    _handlers: Dict[str, Type[IFormatHandler]] = {}
+    _instances: Dict[str, IFormatHandler] = {}
+    
+    @classmethod
+    def register(cls, extension: str, handler_class: Type[IFormatHandler]) -> None:
+        """Register format handler for file extension."""
+        if not extension.startswith('.'):
+            extension = '.' + extension
+        cls._handlers[extension.lower()] = handler_class
+        # Clear instance cache when registering new handler
+        if extension.lower() in cls._instances:
+            del cls._instances[extension.lower()]
+    
+    @classmethod
+    def get_handler(cls, file_path: str) -> Optional[IFormatHandler]:
+        """Get format handler for file extension."""
+        ext = Path(file_path).suffix.lower()
+        
+        if ext not in cls._handlers:
+            return None
+        
+        # Use singleton pattern for handler instances
+        if ext not in cls._instances:
+            cls._instances[ext] = cls._handlers[ext]()
+        
+        return cls._instances[ext]
+    
+    @classmethod
+    def get_supported_formats(cls) -> List[str]:
+        """Get list of supported file extensions."""
+        return list(cls._handlers.keys())
+    
+    @classmethod
+    def is_supported(cls, file_path: str) -> bool:
+        """Check if file format is supported."""
+        ext = Path(file_path).suffix.lower()
+        return ext in cls._handlers
+    
+    @classmethod
+    def clear_cache(cls) -> None:
+        """Clear handler instance cache."""
+        cls._instances.clear()
+
+
+def _register_builtin_formats():
+    """Register built-in format handlers."""
+    
+    # XLSX Handler
+    class XlsxHandler(IFormatHandler):
+        """Handler for XLSX format."""
+        
+        def __init__(self):
+            from .xlsx.reader import XlsxReader
+            from .xlsx.writer import XlsxWriter
+            self._reader = XlsxReader()
+            self._writer = XlsxWriter()
+        
+        def load_workbook(self, workbook, file_path: str, **options):
+            return self._reader.load_workbook(workbook, file_path, **options)
+        
+        def save_workbook(self, workbook, file_path: str, **options):
+            return self._writer.save_workbook(workbook, file_path, **options)
+    
+    FormatHandlerFactory.register('.xlsx', XlsxHandler)
+    FormatHandlerFactory.register('.xlsm', XlsxHandler)
+    FormatHandlerFactory.register('.xltx', XlsxHandler)
+    FormatHandlerFactory.register('.xltm', XlsxHandler)
+    
+    # JSON Handler
+    class JsonHandler(IFormatHandler):
+        """Handler for JSON format."""
+        
+        def __init__(self):
+            from .json.reader import JsonReader
+            from .json.writer import JsonWriter
+            self._reader = JsonReader()
+            self._writer = JsonWriter()
+        
+        def load_workbook(self, workbook, file_path: str, **options):
+            return self._reader.load_workbook(workbook, file_path, **options)
+        
+        def save_workbook(self, workbook, file_path: str, **options):
+            return self._writer.save_workbook(workbook, file_path, **options)
+    
+    FormatHandlerFactory.register('.json', JsonHandler)
+    
+    # CSV Handler
+    class CsvHandler(IFormatHandler):
+        """Handler for CSV format."""
+        
+        def __init__(self):
+            from .csv.reader import CsvReader
+            from .csv.writer import CsvWriter
+            self._reader = CsvReader()
+            self._writer = CsvWriter()
+        
+        def load_workbook(self, workbook, file_path: str, **options):
+            return self._reader.load_workbook(workbook, file_path, **options)
+        
+        def save_workbook(self, workbook, file_path: str, **options):
+            return self._writer.save_workbook(workbook, file_path, **options)
+    
+    FormatHandlerFactory.register('.csv', CsvHandler)
+    
+    # Markdown Handler
+    class MarkdownHandler(IFormatHandler):
+        """Handler for Markdown format."""
+        
+        def __init__(self):
+            from .md.reader import MarkdownReader
+            from .md.writer import MarkdownWriter
+            self._reader = MarkdownReader()
+            self._writer = MarkdownWriter()
+        
+        def load_workbook(self, workbook, file_path: str, **options):
+            return self._reader.load_workbook(workbook, file_path, **options)
+        
+        def save_workbook(self, workbook, file_path: str, **options):
+            return self._writer.save_workbook(workbook, file_path, **options)
+    
+    FormatHandlerFactory.register('.md', MarkdownHandler)
+    FormatHandlerFactory.register('.markdown', MarkdownHandler)
+
+
+# Initialize built-in formats
+_register_builtin_formats()