scriptplan 0.9.0__py3-none-any.whl

scriptplan/utils/message_handler.py

@@ -0,0 +1,515 @@
+"""MessageHandler module for managing application messages.
+
+Contains Message, MessageHandlerInstance singleton, and MessageHandler mixin
+for handling fatal errors, errors, warnings, info, and debug messages.
+"""
+
+import sys
+import threading
+from enum import Enum
+from datetime import datetime
+from typing import Optional, List, Dict, Any, Union
+
+from scriptplan.utils.logger import ANSIColor
+
+
+class TjRuntimeError(RuntimeError):
+    """TaskJuggler runtime error exception."""
+    pass
+
+
+class TjException(Exception):
+    """TaskJuggler exception for controlled abort."""
+    pass
+
+
+class SourceFileInfo:
+    """Holds information about a source file location.
+
+    This is a simplified version - full implementation would be in TextParser module.
+    """
+
+    def __init__(self, file_name: str, line_no: int = 0, column_no: int = 0):
+        self._file_name = file_name
+        self._line_no = line_no
+        self._column_no = column_no
+
+    @property
+    def fileName(self) -> str:
+        return self._file_name
+
+    @property
+    def lineNo(self) -> int:
+        return self._line_no
+
+    @property
+    def columnNo(self) -> int:
+        return self._column_no
+
+    def __repr__(self) -> str:
+        return f"SourceFileInfo({self._file_name}:{self._line_no}:{self._column_no})"
+
+
+class MessageType(Enum):
+    """Message severity types."""
+    FATAL = 'fatal'
+    ERROR = 'error'
+    CRITICAL = 'critical'
+    WARNING = 'warning'
+    INFO = 'info'
+    DEBUG = 'debug'
+
+
+class Message:
+    """Stores a single message with type, ID, content, and optional source info.
+
+    Supports five message types: fatal, error, warning, info, and debug.
+    Messages can include source file locations and specific line content for debugging.
+    """
+
+    VALID_TYPES = [MessageType.FATAL, MessageType.ERROR, MessageType.WARNING,
+                   MessageType.INFO, MessageType.DEBUG]
+
+    def __init__(self, msg_type: MessageType, msg_id: str, message: str,
+                 source_file_info: Optional[SourceFileInfo] = None,
+                 line: Optional[str] = None,
+                 data: Any = None,
+                 scenario: Any = None):
+        """Create a new Message object.
+
+        Args:
+            msg_type: Message type (fatal, error, warning, info, debug).
+            msg_id: Unique identifier for the message source.
+            message: The actual message content.
+            source_file_info: Optional source file location reference.
+            line: Optional line content from the source file.
+            data: Optional context-sensitive data.
+            scenario: Optional Scenario where the message originated.
+        """
+        if msg_type not in self.VALID_TYPES:
+            raise ValueError(f"Unknown message type: {msg_type}")
+        self._type = msg_type
+
+        self._id = msg_id
+
+        if message is not None and not isinstance(message, str):
+            raise TypeError(f"String object expected as message but got {type(message).__name__}")
+        self._message = message
+
+        if source_file_info is not None and not isinstance(source_file_info, SourceFileInfo):
+            raise TypeError(f"SourceFileInfo object expected but got {type(source_file_info).__name__}")
+        self._source_file_info = source_file_info
+
+        if line is not None and not isinstance(line, str):
+            raise TypeError(f"String object expected as line but got {type(line).__name__}")
+        self._line = line
+
+        self._data = data
+        self._scenario = scenario
+
+    @property
+    def type(self) -> MessageType:
+        return self._type
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def message(self) -> str:
+        return self._message
+
+    @property
+    def sourceFileInfo(self) -> Optional[SourceFileInfo]:
+        return self._source_file_info
+
+    @sourceFileInfo.setter
+    def sourceFileInfo(self, value: Optional[SourceFileInfo]):
+        self._source_file_info = value
+
+    @property
+    def line(self) -> Optional[str]:
+        return self._line
+
+    @property
+    def data(self) -> Any:
+        return self._data
+
+    @property
+    def scenario(self) -> Any:
+        return self._scenario
+
+    def __str__(self) -> str:
+        """Return formatted string with ANSI colors for console output."""
+        result = ""
+
+        if self._source_file_info:
+            result += f"{self._source_file_info.fileName}:{self._source_file_info.lineNo}: "
+
+        if self._scenario and hasattr(self._scenario, 'id'):
+            tag = f"{self._type.value.capitalize()} in scenario {self._scenario.id}: "
+        else:
+            tag = f"{self._type.value.capitalize()}: "
+
+        colors = {
+            MessageType.FATAL: ANSIColor.red,
+            MessageType.ERROR: ANSIColor.red,
+            MessageType.WARNING: ANSIColor.yellow,
+            MessageType.INFO: ANSIColor.blue,
+            MessageType.DEBUG: ANSIColor.green,
+        }
+
+        color_func = colors.get(self._type, lambda x: x)
+        result += color_func(tag + (self._message or ""))
+
+        if self._line:
+            result += "\n" + self._line
+
+        return result
+
+    def to_log(self) -> str:
+        """Return plain text string for log file output."""
+        result = ""
+
+        if self._source_file_info:
+            result += f"{self._source_file_info.fileName}:{self._source_file_info.lineNo}: "
+
+        if self._scenario and hasattr(self._scenario, 'id'):
+            result += f"Scenario {self._scenario.id}: "
+
+        result += self._message or ""
+
+        return result
+
+
+class MessageHandlerInstance:
+    """Singleton class for managing messages and logging.
+
+    Manages message storage and output, tracks error counts, and controls
+    output levels for both console and log files.
+    """
+
+    _instance = None
+    _lock = threading.Lock()
+
+    LOG_LEVELS = {
+        'none': 0,
+        MessageType.FATAL: 1,
+        MessageType.ERROR: 2,
+        MessageType.CRITICAL: 2,
+        MessageType.WARNING: 3,
+        MessageType.INFO: 4,
+        MessageType.DEBUG: 5,
+    }
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self._initialized = True
+        self.reset()
+
+    def reset(self):
+        """Reset all handler state to defaults."""
+        self._output_level = 4
+        self._log_level = 3
+        self._log_file: Optional[str] = None
+        self._hide_scenario = True
+        self._app_name = 'unknown'
+        self._abort_on_warning = False
+        self._baseline_sfi: Dict[int, SourceFileInfo] = {}
+        self._trap_setup: Dict[int, bool] = {}
+
+        self.clear()
+
+    @property
+    def messages(self) -> List[Message]:
+        return self._messages
+
+    @property
+    def errors(self) -> int:
+        return self._errors
+
+    @property
+    def logFile(self) -> Optional[str]:
+        return self._log_file
+
+    @logFile.setter
+    def logFile(self, value: Optional[str]):
+        self._log_file = value
+
+    @property
+    def appName(self) -> str:
+        return self._app_name
+
+    @appName.setter
+    def appName(self, value: str):
+        self._app_name = value
+
+    @property
+    def abortOnWarning(self) -> bool:
+        return self._abort_on_warning
+
+    @abortOnWarning.setter
+    def abortOnWarning(self, value: bool):
+        self._abort_on_warning = value
+
+    @property
+    def baselineSFI(self) -> Optional[SourceFileInfo]:
+        return self._baseline_sfi.get(threading.current_thread().ident)
+
+    @baselineSFI.setter
+    def baselineSFI(self, value: Optional[SourceFileInfo]):
+        self._baseline_sfi[threading.current_thread().ident] = value
+
+    @property
+    def trapSetup(self) -> bool:
+        return self._trap_setup.get(threading.current_thread().ident, False)
+
+    @trapSetup.setter
+    def trapSetup(self, value: bool):
+        self._trap_setup[threading.current_thread().ident] = value
+
+    def clear(self):
+        """Clear all stored messages and reset error count."""
+        self._errors = 0
+        self._messages: List[Message] = []
+
+    @property
+    def outputLevel(self) -> int:
+        return self._output_level
+
+    @outputLevel.setter
+    def outputLevel(self, level: Union[int, str, MessageType]):
+        self._output_level = self._check_level(level)
+
+    @property
+    def logLevel(self) -> int:
+        return self._log_level
+
+    @logLevel.setter
+    def logLevel(self, level: Union[int, str, MessageType]):
+        self._log_level = self._check_level(level)
+
+    @property
+    def hideScenario(self) -> bool:
+        return self._hide_scenario
+
+    @hideScenario.setter
+    def hideScenario(self, value: bool):
+        self._hide_scenario = value
+
+    def _check_level(self, level: Union[int, str, MessageType]) -> int:
+        """Validate and convert log level to integer."""
+        if isinstance(level, int):
+            if level < 0 or level > 5:
+                raise ValueError(f"Unsupported level {level}")
+            return level
+
+        if isinstance(level, MessageType):
+            return self.LOG_LEVELS.get(level, 0)
+
+        if isinstance(level, str):
+            level_lower = level.lower()
+            for key, val in self.LOG_LEVELS.items():
+                if isinstance(key, str) and key == level_lower:
+                    return val
+                elif isinstance(key, MessageType) and key.value == level_lower:
+                    return val
+
+        raise ValueError(f"Unsupported level {level}")
+
+    def _log(self, msg_type: MessageType, message: str):
+        """Write message to log file if configured."""
+        if not self._log_file:
+            return
+
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        import os
+        pid = os.getpid()
+
+        try:
+            with open(self._log_file, 'a') as f:
+                f.write(f"{timestamp} {msg_type.value} {self._app_name}[{pid}]: {message}\n")
+        except Exception as e:
+            print(f"Cannot write to log file {self._log_file}: {e}", file=sys.stderr)
+
+    def _add_message(self, msg_type: MessageType, msg_id: str, message: str,
+                     source_file_info: Optional[SourceFileInfo] = None,
+                     line: Optional[str] = None,
+                     data: Any = None,
+                     scenario: Any = None):
+        """Add a message and handle based on type."""
+        # Adjust source file info based on baseline
+        baseline_sfi = self.baselineSFI
+        if source_file_info and baseline_sfi:
+            source_file_info = SourceFileInfo(
+                baseline_sfi.fileName,
+                source_file_info.lineNo + baseline_sfi.lineNo - 1,
+                source_file_info.columnNo
+            )
+
+        # Create message - convert critical to error for display
+        display_type = MessageType.ERROR if msg_type == MessageType.CRITICAL else msg_type
+        msg = Message(
+            display_type, msg_id, message, source_file_info, line, data,
+            None if self._hide_scenario else scenario
+        )
+        self._messages.append(msg)
+
+        # Log if level is appropriate
+        if self._log_level >= self.LOG_LEVELS.get(msg_type, 0):
+            self._log(msg_type, msg.to_log())
+
+        # Output to stderr if level is appropriate
+        if self._output_level >= self.LOG_LEVELS.get(msg_type, 0):
+            print(str(msg), file=sys.stderr)
+
+        # Handle message type-specific actions
+        if msg_type == MessageType.WARNING:
+            if self._abort_on_warning:
+                raise TjException("")
+        elif msg_type == MessageType.CRITICAL:
+            self._errors += 1
+        elif msg_type == MessageType.ERROR:
+            self._errors += 1
+            if self.trapSetup:
+                raise TjRuntimeError()
+            else:
+                sys.exit(1)
+        elif msg_type == MessageType.FATAL:
+            raise RuntimeError(message)
+
+    def fatal(self, msg_id: str, message: str,
+              source_file_info: Optional[SourceFileInfo] = None,
+              line: Optional[str] = None,
+              data: Any = None,
+              scenario: Any = None):
+        """Log a fatal error and raise RuntimeError."""
+        self._add_message(MessageType.FATAL, msg_id, message,
+                          source_file_info, line, data, scenario)
+
+    def error(self, msg_id: str, message: str,
+              source_file_info: Optional[SourceFileInfo] = None,
+              line: Optional[str] = None,
+              data: Any = None,
+              scenario: Any = None):
+        """Log an error. Will exit or raise TjRuntimeError based on trapSetup."""
+        self._add_message(MessageType.ERROR, msg_id, message,
+                          source_file_info, line, data, scenario)
+
+    def critical(self, msg_id: str, message: str,
+                 source_file_info: Optional[SourceFileInfo] = None,
+                 line: Optional[str] = None,
+                 data: Any = None,
+                 scenario: Any = None):
+        """Log a critical error. Increments error count but does not exit."""
+        self._add_message(MessageType.CRITICAL, msg_id, message,
+                          source_file_info, line, data, scenario)
+
+    def warning(self, msg_id: str, message: str,
+                source_file_info: Optional[SourceFileInfo] = None,
+                line: Optional[str] = None,
+                data: Any = None,
+                scenario: Any = None):
+        """Log a warning. May raise TjException if abortOnWarning is set."""
+        self._add_message(MessageType.WARNING, msg_id, message,
+                          source_file_info, line, data, scenario)
+
+    def info(self, msg_id: str, message: str,
+             source_file_info: Optional[SourceFileInfo] = None,
+             line: Optional[str] = None,
+             data: Any = None,
+             scenario: Any = None):
+        """Log an info message."""
+        self._add_message(MessageType.INFO, msg_id, message,
+                          source_file_info, line, data, scenario)
+
+    def debug(self, msg_id: str, message: str,
+              source_file_info: Optional[SourceFileInfo] = None,
+              line: Optional[str] = None,
+              data: Any = None,
+              scenario: Any = None):
+        """Log a debug message."""
+        self._add_message(MessageType.DEBUG, msg_id, message,
+                          source_file_info, line, data, scenario)
+
+    def __str__(self) -> str:
+        """Return all messages as a single string."""
+        return ''.join(str(msg) for msg in self._messages)
+
+
+# Singleton accessor
+def get_message_handler_instance() -> MessageHandlerInstance:
+    """Return the MessageHandlerInstance singleton."""
+    return MessageHandlerInstance()
+
+
+class MessageHandler:
+    """Mixin class providing message handling methods.
+
+    Classes that inherit from MessageHandler can use fatal, error, critical,
+    warning, info, and debug methods to send messages through the global
+    MessageHandlerInstance singleton.
+    """
+
+    def fatal(self, msg_id: str, message: str,
+              source_file_info: Optional[SourceFileInfo] = None,
+              line: Optional[str] = None,
+              data: Any = None,
+              scenario: Any = None):
+        """Log a fatal error and raise RuntimeError."""
+        MessageHandlerInstance().fatal(msg_id, message, source_file_info,
+                                        line, data, scenario)
+
+    def error(self, msg_id: str, message: str,
+              source_file_info: Optional[SourceFileInfo] = None,
+              line: Optional[str] = None,
+              data: Any = None,
+              scenario: Any = None):
+        """Log an error."""
+        MessageHandlerInstance().error(msg_id, message, source_file_info,
+                                        line, data, scenario)
+
+    def critical(self, msg_id: str, message: str,
+                 source_file_info: Optional[SourceFileInfo] = None,
+                 line: Optional[str] = None,
+                 data: Any = None,
+                 scenario: Any = None):
+        """Log a critical error."""
+        MessageHandlerInstance().critical(msg_id, message, source_file_info,
+                                           line, data, scenario)
+
+    def warning(self, msg_id: str, message: str,
+                source_file_info: Optional[SourceFileInfo] = None,
+                line: Optional[str] = None,
+                data: Any = None,
+                scenario: Any = None):
+        """Log a warning."""
+        MessageHandlerInstance().warning(msg_id, message, source_file_info,
+                                          line, data, scenario)
+
+    def info(self, msg_id: str, message: str,
+             source_file_info: Optional[SourceFileInfo] = None,
+             line: Optional[str] = None,
+             data: Any = None,
+             scenario: Any = None):
+        """Log an info message."""
+        MessageHandlerInstance().info(msg_id, message, source_file_info,
+                                       line, data, scenario)
+
+    def debug(self, msg_id: str, message: str,
+              source_file_info: Optional[SourceFileInfo] = None,
+              line: Optional[str] = None,
+              data: Any = None,
+              scenario: Any = None):
+        """Log a debug message."""
+        MessageHandlerInstance().debug(msg_id, message, source_file_info,
+                                        line, data, scenario)

scriptplan/utils/time.py

@@ -0,0 +1,195 @@
+from datetime import datetime, timedelta, timezone
+import time
+import math
+import calendar
+
+class TjTime:
+    MON_MAX = [ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ]
+    _tz = 'UTC'
+
+    def __init__(self, t=None):
+        if t is None:
+            self.time = datetime.now(timezone.utc)
+        elif isinstance(t, datetime):
+            if t.tzinfo is None:
+                # Assume local? Or UTC? TaskJuggler defaults to UTC mostly or system
+                # Ruby Time.new creates local time.
+                # If we follow strict Ruby behavior, assumes local if no TZ.
+                # But here we try to keep things UTC aware internally.
+                self.time = t.replace(tzinfo=timezone.utc) # Simplified assumption: inputs are UTC if naive
+            else:
+                self.time = t
+        elif isinstance(t, TjTime):
+            self.time = t.time
+        elif isinstance(t, str):
+            self.parse(t)
+        elif isinstance(t, (list, tuple)):
+            # year, month, day, hour, min, sec, usec
+            # Ruby Time.mktime interpreted in local time
+            # For now assuming UTC for simplicity or explicit timezone handling needed
+            dt = datetime(*t[:6])
+            self.time = dt.replace(tzinfo=timezone.utc) 
+        elif isinstance(t, (int, float)):
+            self.time = datetime.fromtimestamp(t, tz=timezone.utc)
+        else:
+            raise ValueError(f"Unknown type for TjTime init: {type(t)}")
+
+    @staticmethod
+    def checkTimeZone(zone):
+        if zone == 'UTC': return True
+        if '/' not in zone: return False
+        # Basic validation not fully implemented against OS db
+        return True
+
+    @classmethod
+    def setTimeZone(cls, zone):
+        if not cls.checkTimeZone(zone):
+            raise ValueError(f"Illegal time zone {zone}")
+        old = cls._tz
+        cls._tz = zone
+        return old
+
+    @classmethod
+    def timeZone(cls):
+        return cls._tz
+
+    def align(self, clock):
+        # clock is seconds
+        ts = self.time.timestamp()
+        aligned_ts = (int(ts) // clock) * clock
+        return TjTime(aligned_ts)
+
+    def utc(self):
+        return TjTime(self.time.astimezone(timezone.utc))
+
+    def secondsOfDay(self):
+        # Assuming local time relative to set timezone?
+        # Simplified: just return UTC seconds of day for now unless we implement full TZ handling
+        return self.time.hour * 3600 + self.time.minute * 60 + self.time.second
+
+    def __add__(self, secs):
+        return TjTime(self.time + timedelta(seconds=secs))
+
+    def __sub__(self, arg):
+        if isinstance(arg, TjTime):
+            return (self.time - arg.time).total_seconds()
+        else:
+            return TjTime(self.time - timedelta(seconds=arg))
+
+    def __lt__(self, other): return self.time < other.time
+    def __le__(self, other): return self.time <= other.time
+    def __gt__(self, other): return self.time > other.time
+    def __ge__(self, other): return self.time >= other.time
+    def __eq__(self, other): return self.time == other.time
+    
+    def upto(self, endDate, step=1):
+        t = self
+        while t < endDate:
+            yield t
+            t += step
+
+    def beginOfHour(self):
+        return TjTime(self.time.replace(minute=0, second=0, microsecond=0))
+
+    def midnight(self):
+        return TjTime(self.time.replace(hour=0, minute=0, second=0, microsecond=0))
+
+    def beginOfWeek(self, startMonday):
+        # startMonday bool
+        dt = self.time
+        weekday = dt.weekday() # Mon=0, Sun=6
+        # If startMonday=True, we want Monday. weekday is already 0-based from Monday.
+        # If startMonday=False (Sunday), we want Sunday.
+        
+        if startMonday:
+            days_to_subtract = weekday
+        else:
+            # If today is Sunday (6), subtract 0. If Mon (0), subtract 1.
+            days_to_subtract = (weekday + 1) % 7
+            
+        start_of_week = dt - timedelta(days=days_to_subtract)
+        return TjTime(start_of_week).midnight()
+
+    def beginOfMonth(self):
+        return TjTime(self.time.replace(day=1, hour=0, minute=0, second=0, microsecond=0))
+
+    def beginOfQuarter(self):
+        month = self.time.month
+        quarter_month = ((month - 1) // 3) * 3 + 1
+        return TjTime(self.time.replace(month=quarter_month, day=1, hour=0, minute=0, second=0, microsecond=0))
+
+    def beginOfYear(self):
+        return TjTime(self.time.replace(month=1, day=1, hour=0, minute=0, second=0, microsecond=0))
+
+    def hoursLater(self, hours):
+        return self + (hours * 3600)
+
+    def sameTimeNextDay(self):
+        return self + (24 * 3600) # Simple approx, ignores DST shifts if just adding seconds?
+        # Better: add timedelta(days=1) which handles calendar date change
+        # return TjTime(self.time + timedelta(days=1))
+
+    def sameTimeNextWeek(self):
+        return TjTime(self.time + timedelta(weeks=1))
+
+    def sameTimeNextMonth(self):
+        # Python doesn't have direct month add.
+        # Simple logic:
+        year = self.time.year
+        month = self.time.month + 1
+        if month > 12:
+            month = 1
+            year += 1
+        
+        day = self.time.day
+        # Clamp day
+        _, max_days = calendar.monthrange(year, month)
+        day = min(day, max_days)
+        
+        return TjTime(self.time.replace(year=year, month=month, day=day))
+
+    def sameTimeNextYear(self):
+        year = self.time.year + 1
+        day = self.time.day
+        # Handle leap year feb 29
+        if self.time.month == 2 and self.time.day == 29:
+            if not calendar.isleap(year):
+                day = 28
+        return TjTime(self.time.replace(year=year, day=day))
+
+    def strftime(self, fmt):
+        return self.time.strftime(fmt)
+
+    def to_s(self, fmt=None, tz=None):
+        if not fmt:
+            fmt = '%Y-%m-%d-%H:%M'
+        return self.time.strftime(fmt)
+
+    def parse(self, t):
+        # format YYYY-MM-DD-HH:MM:SS-ZZZZ?
+        # Ruby impl splits by '-'
+        parts = t.split('-')
+        # Handle various parts length
+        # Expected: Year, Month, Day, [Time, [Zone]]
+        year = int(parts[0])
+        month = int(parts[1])
+        day = int(parts[2])
+        hour = 0
+        minute = 0
+        second = 0
+        
+        if len(parts) > 3:
+            time_part = parts[3]
+            if ':' in time_part:
+                h, m, s = time_part.split(':')
+                hour = int(h)
+                minute = int(m)
+                second = int(s) if s else 0
+        
+        # Ignore zone for now or handle if present
+        self.time = datetime(year, month, day, hour, minute, second, tzinfo=timezone.utc)
+
+class TimeInterval:
+    def __init__(self, start, end):
+        self.start = start
+        self.end = end