scriptplan 0.9.0__py3-none-any.whl

scriptplan/report/report_base.py

@@ -0,0 +1,397 @@
+"""
+ReportBase - Abstract base class for report content generators.
+
+This module provides the ReportBase class which is the abstract base for all
+kinds of report content generators. Derived classes must implement the
+generate_intermediate_format function as well as to_html, to_csv, etc.
+"""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Optional, List, Any, Dict
+
+if TYPE_CHECKING:
+    from scriptplan.report.report import Report
+    from scriptplan.core.project import Project
+    from scriptplan.core.property import PropertyList
+
+
+class ReportBase(ABC):
+    """
+    Abstract base class for all report content generators.
+
+    This class provides common functionality for filtering property lists
+    and generating the intermediate format that can be converted to
+    various output formats (HTML, CSV, etc.).
+
+    Attributes:
+        report: Reference to the parent Report object
+        project: Reference to the Project object
+    """
+
+    def __init__(self, report: 'Report'):
+        """
+        Initialize the ReportBase.
+
+        Args:
+            report: The parent Report object
+        """
+        self.report = report
+        self.project = report.project
+
+    def a(self, attribute: str) -> Any:
+        """
+        Convenience function to access a report attribute.
+
+        Args:
+            attribute: Name of the attribute to access
+
+        Returns:
+            The attribute value
+        """
+        return self.report.get(attribute)
+
+    def get_scenario_indices(self) -> List[int]:
+        """
+        Get scenario indices from the report's scenarios attribute.
+
+        The 'scenarios' attribute can contain either scenario names (strings)
+        or scenario indices (integers). This method resolves all names to
+        their corresponding indices.
+
+        Returns:
+            List of scenario indices (integers). Defaults to [0] if not set.
+        """
+        scenarios = self.a('scenarios') or []
+        if not scenarios:
+            return [0]
+
+        result = []
+        for scen in scenarios:
+            if isinstance(scen, int):
+                result.append(scen)
+            elif isinstance(scen, str):
+                # Resolve scenario name to index
+                for idx, proj_scen in enumerate(self.project.scenarios):
+                    if proj_scen.id == scen:
+                        result.append(idx)
+                        break
+                else:
+                    # Scenario name not found, try to parse as int
+                    try:
+                        result.append(int(scen))
+                    except ValueError:
+                        # Skip unknown scenarios
+                        pass
+
+        return result if result else [0]
+
+    @abstractmethod
+    def generate_intermediate_format(self) -> None:
+        """
+        Generate the intermediate format representation.
+
+        This method must be implemented by derived classes to generate
+        an output-format-agnostic representation of the report data.
+        """
+        # Process RichText elements like header, footer, etc.
+        query = None
+        if self.project.reportContexts:
+            query = self.project.reportContexts[-1].query
+
+        for name in ['header', 'left', 'center', 'right', 'footer',
+                     'prolog', 'headline', 'caption', 'epilog']:
+            text = self.a(name)
+            if text and query and hasattr(text, 'setQuery'):
+                text.setQuery(query)
+
+    @abstractmethod
+    def to_html(self) -> Optional[str]:
+        """
+        Convert the intermediate format to HTML.
+
+        Returns:
+            HTML string representation or None
+        """
+        pass
+
+    def to_csv(self) -> Optional[List[List[str]]]:
+        """
+        Convert the intermediate format to CSV.
+
+        Returns:
+            List of rows (each row is a list of column values)
+        """
+        return None
+
+    def filter_account_list(self, account_list: 'PropertyList',
+                           hide_expr: Any = None,
+                           rollup_expr: Any = None,
+                           open_nodes: Optional[List] = None) -> 'PropertyList':
+        """
+        Filter an account list based on hide/rollup expressions.
+
+        Takes the complete account list and removes all accounts that are
+        matching the hide expression, the rollup expression or are not a
+        descendant of accountroot.
+
+        Args:
+            account_list: List of accounts to filter
+            hide_expr: Expression to determine which accounts to hide
+            rollup_expr: Expression to determine which accounts to roll up
+            open_nodes: List of nodes to keep expanded
+
+        Returns:
+            Filtered PropertyList
+        """
+        from scriptplan.core.property import PropertyList
+
+        result = PropertyList(account_list)
+
+        account_root = self.a('accountRoot')
+        if account_root:
+            # Remove accounts not descended from accountRoot
+            result.delete_if(lambda acc: not self._is_child_of(acc, account_root))
+
+        return self._standard_filter_ops(result, hide_expr, rollup_expr,
+                                         open_nodes, None, account_root)
+
+    def filter_task_list(self, task_list: 'PropertyList',
+                        resource: Any = None,
+                        hide_expr: Any = None,
+                        rollup_expr: Any = None,
+                        open_nodes: Optional[List] = None) -> 'PropertyList':
+        """
+        Filter a task list based on hide/rollup expressions.
+
+        Takes the complete task list and removes all tasks that are matching
+        the hide expression, the rollup expression or are not a descendant
+        of taskroot. If resource is not None, a task is only included if
+        the resource is allocated to it.
+
+        Args:
+            task_list: List of tasks to filter
+            resource: Optional resource filter
+            hide_expr: Expression to determine which tasks to hide
+            rollup_expr: Expression to determine which tasks to roll up
+            open_nodes: List of nodes to keep expanded
+
+        Returns:
+            Filtered PropertyList
+        """
+        from scriptplan.core.property import PropertyList
+
+        result = PropertyList(task_list)
+
+        task_root = self.a('taskRoot')
+        if task_root:
+            result.delete_if(lambda task: not self._is_child_of(task, task_root))
+
+        if resource:
+            # Filter to tasks that have the resource allocated
+            scenario_indices = self.get_scenario_indices()
+            start = self.a('start')
+            end = self.a('end')
+
+            def has_resource(task):
+                for scenario_idx in scenario_indices:
+                    if hasattr(task, 'hasResourceAllocated'):
+                        if task.hasResourceAllocated(scenario_idx, (start, end), resource):
+                            return True
+                return False
+
+            result.delete_if(lambda task: not has_resource(task))
+
+        return self._standard_filter_ops(result, hide_expr, rollup_expr,
+                                         open_nodes, resource, task_root)
+
+    def filter_resource_list(self, resource_list: 'PropertyList',
+                            task: Any = None,
+                            hide_expr: Any = None,
+                            rollup_expr: Any = None,
+                            open_nodes: Optional[List] = None) -> 'PropertyList':
+        """
+        Filter a resource list based on hide/rollup expressions.
+
+        Takes the complete resource list and removes all resources that are
+        matching the hide expression, the rollup expression or are not a
+        descendant of resourceroot. If task is not None, a resource is only
+        included if it is assigned to the task.
+
+        Args:
+            resource_list: List of resources to filter
+            task: Optional task filter
+            hide_expr: Expression to determine which resources to hide
+            rollup_expr: Expression to determine which resources to roll up
+            open_nodes: List of nodes to keep expanded
+
+        Returns:
+            Filtered PropertyList
+        """
+        from scriptplan.core.property import PropertyList
+
+        result = PropertyList(resource_list)
+
+        resource_root = self.a('resourceRoot')
+        if resource_root:
+            result.delete_if(lambda res: not self._is_child_of(res, resource_root))
+
+        if task:
+            # Filter to resources assigned to the task
+            scenario_indices = self.get_scenario_indices()
+            start = self.a('start')
+            end = self.a('end')
+
+            def is_assigned(resource):
+                for scenario_idx in scenario_indices:
+                    if hasattr(task, 'hasResourceAllocated'):
+                        if task.hasResourceAllocated(scenario_idx, (start, end), resource):
+                            return True
+                return False
+
+            result.delete_if(lambda res: not is_assigned(res))
+
+        return self._standard_filter_ops(result, hide_expr, rollup_expr,
+                                         open_nodes, task, resource_root)
+
+    def _standard_filter_ops(self, items: 'PropertyList',
+                            hide_expr: Any,
+                            rollup_expr: Any,
+                            open_nodes: Optional[List],
+                            scope_property: Any,
+                            root: Any) -> 'PropertyList':
+        """
+        Apply standard filtering operations to a property list.
+
+        Args:
+            items: The property list to filter
+            hide_expr: Expression determining what to hide
+            rollup_expr: Expression determining what to roll up
+            open_nodes: List of explicitly open nodes
+            scope_property: The scope property for queries
+            root: The root property
+
+        Returns:
+            Filtered PropertyList
+        """
+        # Get query copy for evaluating expressions
+        query = None
+        if self.project.reportContexts:
+            query = self.project.reportContexts[-1].query.copy()
+            query.scope_property = scope_property
+
+        # Remove hidden properties
+        if hide_expr and query:
+            def should_hide(prop):
+                query.property = prop
+                return self._eval_expression(hide_expr, query)
+            items.delete_if(should_hide)
+
+        # Remove children of rolled-up properties
+        if rollup_expr or open_nodes:
+            def should_remove_child(prop):
+                parent = prop.parent
+                while parent:
+                    query.property = parent if query else None
+
+                    if open_nodes:
+                        # If open_nodes specified, only listed nodes are unrolled
+                        if [parent, scope_property] not in open_nodes:
+                            return True
+                    elif rollup_expr:
+                        # Roll up based on expression
+                        if self._eval_expression(rollup_expr, query):
+                            return True
+
+                    parent = parent.parent
+                return False
+
+            items.delete_if(should_remove_child)
+
+        # Re-add parents in tree mode (if applicable)
+        if hasattr(items, 'tree_mode') and items.tree_mode():
+            parents = []
+            for prop in items:
+                parent = prop.parent
+                while parent:
+                    if parent not in items and parent not in parents:
+                        parents.append(parent)
+                    if parent == root:
+                        break
+                    parent = parent.parent
+            items.extend(parents)
+
+        return items
+
+    def _is_child_of(self, node: Any, parent: Any) -> bool:
+        """
+        Check if node is a descendant of parent.
+
+        Args:
+            node: The potential child node
+            parent: The potential parent node
+
+        Returns:
+            True if node is a descendant of parent
+        """
+        if hasattr(node, 'isChildOf'):
+            return node.isChildOf(parent)
+
+        # Manual check
+        current = node
+        while current:
+            if current == parent:
+                return True
+            current = current.parent if hasattr(current, 'parent') else None
+        return False
+
+    def _eval_expression(self, expr: Any, query: Any) -> bool:
+        """
+        Evaluate a logical expression.
+
+        Args:
+            expr: The expression to evaluate
+            query: The query context
+
+        Returns:
+            Boolean result of expression evaluation
+        """
+        if hasattr(expr, 'eval'):
+            return expr.eval(query)
+        if callable(expr):
+            return expr(query)
+        return bool(expr)
+
+    def _generate_html_table_frame(self) -> str:
+        """
+        Generate the HTML table frame with headline.
+
+        Returns:
+            HTML string for table frame start
+        """
+        html = ['<table class="tj_table_frame" cellspacing="1">']
+
+        # Add headline if present
+        headline = self.a('headline')
+        if headline:
+            headline_html = self._rich_text_to_html(headline)
+            html.append('<tr><td>')
+            html.append(f'<div class="tj_table_headline">{headline_html}</div>')
+            html.append('</td></tr>')
+
+        return '\n'.join(html)
+
+    def _rich_text_to_html(self, text: Any) -> str:
+        """
+        Convert RichText to HTML.
+
+        Args:
+            text: RichText object or string
+
+        Returns:
+            HTML string
+        """
+        if text is None:
+            return ''
+        if hasattr(text, 'to_html'):
+            return text.to_html()
+        return str(text)

scriptplan/report/report_context.py

@@ -0,0 +1,248 @@
+"""
+ReportContext - Manages context and state during report generation.
+
+This module provides the ReportContext class which holds settings used during
+report generation. Reports can be nested, so multiple ReportContext objects
+can exist at a time, but there is always one current context accessible via
+Project.reportContexts[-1].
+"""
+
+from typing import TYPE_CHECKING, Optional, List, Any, Dict
+
+if TYPE_CHECKING:
+    from scriptplan.core.project import Project
+    from scriptplan.core.property import PropertyList
+
+
+class Query:
+    """
+    Query object for accessing property attributes during report generation.
+
+    This class provides a unified interface for querying task/resource attributes
+    with proper formatting and scenario handling.
+    """
+
+    def __init__(self, attrs: Optional[Dict[str, Any]] = None):
+        self.project = None
+        self.property = None
+        self.scope_property = None
+        self.scenario_idx = None
+        self.attributeId = None  # Attribute ID to query
+        self.result = None       # Result of the query
+        self.load_unit = 'days'
+        self.number_format = None
+        self.time_format = '%Y-%m-%d'
+        self.currency_format = None
+        self.start = None
+        self.end = None
+        self.hide_journal_entry = None
+        self.journal_mode = None
+        self.journal_attributes = None
+        self.sort_journal_entries = None
+        self.cost_account = None
+        self.revenue_account = None
+
+        if attrs:
+            for key, value in attrs.items():
+                attr_name = self._camel_to_snake(key)
+                if hasattr(self, attr_name):
+                    setattr(self, attr_name, value)
+
+    def _camel_to_snake(self, name: str) -> str:
+        """Convert camelCase to snake_case."""
+        import re
+        s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
+        return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
+
+    def copy(self) -> 'Query':
+        """Create a copy of this Query."""
+        new_query = Query()
+        new_query.project = self.project
+        new_query.property = self.property
+        new_query.scope_property = self.scope_property
+        new_query.scenario_idx = self.scenario_idx
+        new_query.attributeId = self.attributeId
+        new_query.result = self.result
+        new_query.load_unit = self.load_unit
+        new_query.number_format = self.number_format
+        new_query.time_format = self.time_format
+        new_query.currency_format = self.currency_format
+        new_query.start = self.start
+        new_query.end = self.end
+        new_query.hide_journal_entry = self.hide_journal_entry
+        new_query.journal_mode = self.journal_mode
+        new_query.journal_attributes = self.journal_attributes
+        new_query.sort_journal_entries = self.sort_journal_entries
+        new_query.cost_account = self.cost_account
+        new_query.revenue_account = self.revenue_account
+        return new_query
+
+    def process(self) -> Any:
+        """
+        Process the query and return the result.
+
+        This is the main entry point for executing a query against a property.
+        """
+        if not self.property:
+            self.result = None
+            return None
+
+        # If attributeId is set, fetch the value from the property
+        if self.attributeId:
+            try:
+                # Use scenario_idx if available, otherwise just get the attribute
+                if self.scenario_idx is not None:
+                    # Ensure property supports scenario indexing
+                    # We pass scenario_idx as a tuple key if the property supports it
+                    # But property.get() usually takes (name, scIdx) or just name
+                    # Let's look at how PropertyTreeNode.get is implemented
+                    # It usually takes (attribute_name, scenario_idx)
+                    
+                    # Note: property.py logic sets self.scenarioIdx which maps to self.scenario_idx here
+                    # property.py calls self._query.process()
+                    
+                    val = self.property.get(self.attributeId, self.scenario_idx)
+                else:
+                    val = self.property.get(self.attributeId)
+                
+                self.result = val
+            except Exception:
+                self.result = None
+        
+        return self.result
+
+    def to_sort(self) -> Any:
+        """
+        Return a sortable representation of the query result.
+        """
+        return self.result
+
+
+class ReportContext:
+    """
+    Context object for report generation.
+
+    The ReportContext holds settings and state used during report generation.
+    Reports can be nested, creating a stack of contexts. The current context
+    is always accessible via Project.reportContexts[-1].
+
+    Attributes:
+        project: Reference to the Project object
+        report: Reference to the Report being generated
+        query: Query object for attribute access
+        tasks: List of tasks in scope for this report
+        resources: List of resources in scope for this report
+        dynamic_report_id: Unique identifier for nested reports
+        child_report_counter: Counter for generating child report IDs
+        attribute_backup: Backup of modified attributes for restoration
+    """
+
+    def __init__(self, project: 'Project', report: Any):
+        """
+        Initialize a new ReportContext.
+
+        Args:
+            project: The Project object
+            report: The Report object being generated
+        """
+        self.project = project
+        self.report = report
+        self.child_report_counter = 0
+        self.attribute_backup = None
+
+        # Build query attributes from report settings
+        query_attrs = {
+            'project': self.project,
+            'loadUnit': self._get_report_attr('loadUnit', 'days'),
+            'numberFormat': self._get_report_attr('numberFormat'),
+            'timeFormat': self._get_report_attr('timeFormat', '%Y-%m-%d'),
+            'currencyFormat': self._get_report_attr('currencyFormat'),
+            'start': self._get_report_attr('start'),
+            'end': self._get_report_attr('end'),
+            'hideJournalEntry': self._get_report_attr('hideJournalEntry'),
+            'journalMode': self._get_report_attr('journalMode'),
+            'journalAttributes': self._get_report_attr('journalAttributes'),
+            'sortJournalEntries': self._get_report_attr('sortJournalEntries'),
+            'costAccount': self._get_report_attr('costaccount'),
+            'revenueAccount': self._get_report_attr('revenueaccount'),
+        }
+        self.query = Query(query_attrs)
+
+        # Get parent context if exists
+        parent = project.reportContexts[-1] if project.reportContexts else None
+
+        if parent:
+            # For interactive/nested reports, generate a unique ID based on
+            # parent's ID and child counter
+            self.dynamic_report_id = f"{parent.dynamic_report_id}.{parent.child_report_counter}"
+            parent.child_report_counter += 1
+
+            # Inherit task and resource lists from parent
+            self.tasks = list(parent.tasks) if parent.tasks else []
+            self.resources = list(parent.resources) if parent.resources else []
+        else:
+            # Root context - ID is "0", get all tasks/resources from project
+            self.dynamic_report_id = "0"
+            self.tasks = list(project.tasks) if project.tasks else []
+            self.resources = list(project.resources) if project.resources else []
+
+    def _get_report_attr(self, attr_name: str, default: Any = None) -> Any:
+        """
+        Get an attribute from the report.
+
+        Args:
+            attr_name: Name of the attribute
+            default: Default value if attribute not found
+
+        Returns:
+            The attribute value or default
+        """
+        try:
+            if hasattr(self.report, 'get'):
+                val = self.report.get(attr_name)
+                return val if val is not None else default
+        except (ValueError, KeyError, AttributeError):
+            pass
+        return default
+
+    def push(self) -> 'ReportContext':
+        """
+        Push this context onto the project's context stack.
+
+        Returns:
+            self for chaining
+        """
+        self.project.reportContexts.append(self)
+        return self
+
+    def pop(self) -> 'ReportContext':
+        """
+        Pop this context from the project's context stack.
+
+        Returns:
+            self for chaining
+        """
+        if self.project.reportContexts and self.project.reportContexts[-1] is self:
+            self.project.reportContexts.pop()
+        return self
+
+    def backup_attributes(self, property_node: Any) -> None:
+        """
+        Backup attributes from a property node for later restoration.
+
+        Args:
+            property_node: The property node whose attributes to backup
+        """
+        if hasattr(property_node, 'backupAttributes'):
+            self.attribute_backup = property_node.backupAttributes()
+
+    def restore_attributes(self, property_node: Any) -> None:
+        """
+        Restore previously backed up attributes to a property node.
+
+        Args:
+            property_node: The property node to restore attributes to
+        """
+        if self.attribute_backup and hasattr(property_node, 'restoreAttributes'):
+            property_node.restoreAttributes(self.attribute_backup)
+            self.attribute_backup = None