Private instance vars, public get properties

sia/repeat_entry.py

@@ -9,12 +9,6 @@ from .util import escape_text_for_xml
 class RepeatEntry(Entry):
     """
     Entry type for scripts that are executed on every update.
-    
-    Attributes:
-        script: The script/command to execute
-        stdout: Captured standard output from most recent execution
-        stderr: Captured standard error from most recent execution
-        exit_code: Process exit code from most recent execution
     """
     
     def __init__(self, script: str, id: str, timestamp: datetime):
@@ -27,10 +21,30 @@ class RepeatEntry(Entry):
             timestamp: Creation timestamp for this entry
         """
         super().__init__(id, timestamp)
-        self.script = script
-        self.stdout = ""
-        self.stderr = ""
-        self.exit_code: Optional[int] = None
+        self._script = script
+        self._stdout = ""
+        self._stderr = ""
+        self._exit_code: Optional[int] = None
+
+    @property
+    def script(self) -> str:
+        """Get the script/command being executed."""
+        return self._script
+
+    @property
+    def stdout(self) -> str:
+        """Get the captured standard output."""
+        return self._stdout
+
+    @property
+    def stderr(self) -> str:
+        """Get the captured standard error."""
+        return self._stderr
+
+    @property
+    def exit_code(self) -> Optional[int]:
+        """Get the exit code of the process (None if still running)."""
+        return self._exit_code
         
     def update(self) -> None:
         """
@@ -40,28 +54,28 @@ class RepeatEntry(Entry):
         try:
             # Run script and capture output
             process = subprocess.run(
-                self.script,
+                self._script,
                 shell=True,
                 capture_output=True,
                 text=True
             )
             
             # Store results
-            self.stdout = process.stdout
-            self.stderr = process.stderr
-            self.exit_code = process.returncode
+            self._stdout = process.stdout
+            self._stderr = process.stderr
+            self._exit_code = process.returncode
             
         except subprocess.SubprocessError as e:
             # Handle subprocess errors by capturing the error message
-            self.stdout = ""
-            self.stderr = str(e)
-            self.exit_code = -1
+            self._stdout = ""
+            self._stderr = str(e)
+            self._exit_code = -1
             
         except Exception as e:
             # Handle any other errors
-            self.stdout = ""
-            self.stderr = f"Error executing script: {str(e)}"
-            self.exit_code = -1
+            self._stdout = ""
+            self._stderr = f"Error executing script: {str(e)}"
+            self._exit_code = -1
 
     def generate_context(self) -> ET.Element:
         """
@@ -73,7 +87,7 @@ class RepeatEntry(Entry):
         # Create root element
         element = ET.Element("repeat", {
             "id": self.id,
-            "exit_code": str(self.exit_code) if self.exit_code is not None else "-1"
+            "exit_code": str(self._exit_code) if self._exit_code is not None else "-1"
         })
         
         # Add script as CDATA or escaped text
@@ -81,10 +95,10 @@ class RepeatEntry(Entry):
         
         # Add stdout element
         stdout_elem = ET.SubElement(element, "stdout")
-        stdout_elem.text = escape_text_for_xml(self.stdout)
+        stdout_elem.text = escape_text_for_xml(self._stdout)
         
         # Add stderr element
         stderr_elem = ET.SubElement(element, "stderr")
-        stderr_elem.text = escape_text_for_xml(self.stderr)
+        stderr_elem.text = escape_text_for_xml(self._stderr)
         
         return element