scriptplan 0.9.0__py3-none-any.whl

scriptplan/core/scenario.py

@@ -0,0 +1,5 @@
+from scriptplan.core.property import PropertyTreeNode
+
+class Scenario(PropertyTreeNode):
+    def __init__(self, project, id, name, parent):
+        super().__init__(project.scenarios, id, name, parent)

scriptplan/core/scenario_data.py

@@ -0,0 +1,39 @@
+from scriptplan.utils.message_handler import MessageHandler
+
+class ScenarioData:
+    def __init__(self, property_node, idx, attributes):
+        self.property = property_node
+        self.project = property_node.project
+        self.scenarioIdx = idx
+        self.attributes = attributes
+        self.messageHandler = MessageHandler() # Should be singleton in real app
+
+        # Register the scenario with the property.
+        if self.property.data is None:
+             # Initialize if not present, assuming it's a list
+             # In PropertyTreeNode we initialized it as list of None
+             self.property.data = [None] * (self.project.scenarioCount() if hasattr(self.project, 'scenarioCount') else 1)
+        
+        # Ensure list is big enough
+        while len(self.property.data) <= idx:
+            self.property.data.append(None)
+
+        self.property.data[idx] = self
+
+    def deep_clone(self):
+        return self
+
+    def a(self, attributeName):
+        return self.attributes[attributeName].get()
+
+    def error(self, id, text, sourceFileInfo=None, property_node=None):
+        # Delegating to message handler
+        # Simplified context passing
+        self.messageHandler.error(id, text, sourceFileInfo or self.property.sourceFileInfo)
+
+    def warning(self, id, text, sourceFileInfo=None, property_node=None):
+        self.messageHandler.warning(id, text, sourceFileInfo or self.property.sourceFileInfo)
+    
+    def info(self, id, text, sourceFileInfo=None, property_node=None):
+        # Assuming info exists
+        print(f"INFO: {text}")

scriptplan/core/shift.py

@@ -0,0 +1,71 @@
+"""Shift module implementing work schedule definitions.
+
+A shift is a definition of working hours for each day of the week.
+It may also contain a list of intervals that define off-duty periods or leaves.
+"""
+
+from scriptplan.core.property import PropertyTreeNode
+from scriptplan.core.scenario_data import ScenarioData
+
+
+class ShiftScenario(ScenarioData):
+    """Handles the scenario-specific features of a Shift object."""
+
+    def __init__(self, shift, scenarioIdx, attributes):
+        super().__init__(shift, scenarioIdx, attributes)
+
+    def _get(self, attrName):
+        """Get attribute value using property's attribute access."""
+        return self.property.get(attrName, self.scenarioIdx)
+
+    def onShift(self, date):
+        """Returns True if the shift has working time defined for the date."""
+        workinghours = self._get('workinghours')
+        if workinghours:
+            return workinghours.onShift(date)
+        return False
+
+    def replace(self):
+        """Returns the replace attribute value."""
+        return self._get('replace')
+
+    def onLeave(self, date):
+        """Returns True if the shift has a vacation/leave defined for the date."""
+        leaves = self._get('leaves')
+        if leaves:
+            for leave in leaves:
+                if hasattr(leave, 'interval') and leave.interval.contains(date):
+                    return True
+        return False
+
+
+class Shift(PropertyTreeNode):
+    """A shift is a definition of working hours for each day of the week.
+
+    It may also contain a list of intervals that define off-duty periods or leaves.
+    """
+
+    def __init__(self, project, id, name, parent):
+        super().__init__(project.shifts, id, name, parent)
+        project.addShift(self)
+
+        # Initialize scenario data array
+        self.data = [None] * project.scenarioCount()
+        for i in range(project.scenarioCount()):
+            ShiftScenario(self, i, self._scenarioAttributes[i])
+
+    def scenario(self, scenarioIdx):
+        """Return a reference to the scenarioIdx-th scenario."""
+        return self.data[scenarioIdx]
+
+    def onShift(self, scenarioIdx, date):
+        """Check if shift is active on given date for the scenario."""
+        return self.data[scenarioIdx].onShift(date)
+
+    def onLeave(self, scenarioIdx, date):
+        """Check if there is leave defined for the date in the scenario."""
+        return self.data[scenarioIdx].onLeave(date)
+
+    def replace(self, scenarioIdx):
+        """Get the replace attribute for the scenario."""
+        return self.data[scenarioIdx].replace()

scriptplan/core/task.py

@@ -0,0 +1,77 @@
+from scriptplan.core.property import PropertyTreeNode
+from scriptplan.core.task_scenario import TaskScenario
+# from scriptplan.utils.rich_text import RichText, RTFHandlers # To be implemented
+
+class Task(PropertyTreeNode):
+    def __init__(self, project, id, name, parent):
+        # super init calls project.tasks.addProperty(self)
+        super().__init__(project.tasks, id, name, parent)
+        
+        # In Ruby: project.addTask(self)
+        # But PropertyTreeNode.__init__ already adds to propertySet.
+        # project.tasks IS the propertySet for tasks.
+        # So it might be redundant or project specific logic.
+        # We'll assume super() handles registration with project.tasks
+        
+        # Initialize scenarios
+        scenario_count = self.project.scenarioCount() if hasattr(self.project, 'scenarioCount') else 1
+        self.data = [None] * scenario_count
+        
+        for i in range(scenario_count):
+             # @scenarioAttributes is initialized in PropertyTreeNode
+             TaskScenario(self, i, self._scenarioAttributes[i])
+
+    def readyForScheduling(self, scenarioIdx):
+        if self.data[scenarioIdx]:
+            return self.data[scenarioIdx].readyForScheduling()
+        return False
+
+    def prepareScheduling(self, scenarioIdx):
+        if self.data[scenarioIdx]:
+            # self.data[scenarioIdx] is TaskScenario
+            # TaskScenario doesn't implement prepareScheduling? 
+            # Wait, ScenarioData might? Or TaskScenario should.
+            if hasattr(self.data[scenarioIdx], 'prepareScheduling'):
+                self.data[scenarioIdx].prepareScheduling()
+
+    def finishScheduling(self, scenarioIdx):
+        if self.data[scenarioIdx]:
+            if hasattr(self.data[scenarioIdx], 'finishScheduling'):
+                self.data[scenarioIdx].finishScheduling()
+
+    def schedule(self, scenarioIdx):
+        if self.data[scenarioIdx]:
+            return self.data[scenarioIdx].schedule()
+        return False
+
+    def journalText(self, query, longVersion, recursive):
+        # Implementation of journalText logic
+        # Depends on project.journal, RichText, etc.
+        
+        r_text = ""
+        
+        # Mocking journal retrieval
+        journal = self.project.attributes.get('journal')
+        if not journal:
+             return None
+        
+        if recursive:
+            # entries = journal.entriesByTaskR(...)
+            entries = []
+        else:
+             # entries = journal.entriesByTask(...)
+             entries = []
+        
+        # Sorting logic would go here
+        
+        for entry in entries:
+             # Build r_text similar to Ruby
+             pass
+        
+        if not r_text:
+             return None
+        
+        # Rich Text generation
+        # rti = RichText(r_text, ...).generateIntermediateFormat()
+        # query.rti = rti
+        pass