compiler: durcissement express des flux stdout/stderr et test de garde

- Evite les crashs quand stdout/stderr sont indisponibles sur le processus de compilation.

- Ajoute un warning explicite et stop proprement la lecture temps reel.

- Ajoute un test de non-regression pour ce cas edge.

Author: raidos23

Core/Compiler/compiler.py

@@ -29,12 +29,10 @@
 from __future__ import annotations
 
 import os
-import sys
 import subprocess
 import select
 import time
-from pathlib import Path
-from typing import Optional, Dict, Any, List, Callable
+from typing import Optional, Dict, List
 from datetime import datetime
 from enum import Enum
 
@@ -156,20 +154,30 @@ def _read_output(self) -> None:
             if self.process is None or self.process.poll() is not None:
                 break
 
+            stdout_stream = self.process.stdout
+            stderr_stream = self.process.stderr
+            if stdout_stream is None and stderr_stream is None:
+                self.error_ready.emit(
+                    "Warning: process streams are unavailable; stopping realtime read."
+                )
+                break
+
+            watched_streams = [s for s in (stdout_stream, stderr_stream) if s is not None]
+            if not watched_streams:
+                break
+
             # Utiliser select pour attendre des données
             try:
-                ready, _, _ = select.select(
-                    [self.process.stdout, self.process.stderr], [], [], 0.1
-                )
+                ready, _, _ = select.select(watched_streams, [], [], 0.1)
 
                 for stream in ready:
-                    if stream == self.process.stdout:
-                        line = self.process.stdout.readline()
+                    if stdout_stream is not None and stream == stdout_stream:
+                        line = stdout_stream.readline()
                         if line:
                             self.output_ready.emit(line.rstrip())
                             self._update_progress(line)
-                    elif stream == self.process.stderr:
-                        line = self.process.stderr.readline()
+                    elif stderr_stream is not None and stream == stderr_stream:
+                        line = stderr_stream.readline()
                         if line:
                             self.error_ready.emit(line.rstrip())
                             self._update_progress(line)
@@ -186,7 +194,7 @@ def _read_remaining(self) -> None:
 
         # Lire stdout restant
         try:
-            remaining_stdout = self.process.stdout.read()
+            remaining_stdout = self.process.stdout.read() if self.process.stdout else ""
             if remaining_stdout:
                 for line in remaining_stdout.strip().split("\n"):
                     if line:
@@ -196,7 +204,7 @@ def _read_remaining(self) -> None:
 
         # Lire stderr restant
         try:
-            remaining_stderr = self.process.stderr.read()
+            remaining_stderr = self.process.stderr.read() if self.process.stderr else ""
             if remaining_stderr:
                 for line in remaining_stderr.strip().split("\n"):
                     if line:

tests/test_compiler_stream_guards.py

@@ -0,0 +1,29 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Ague Samuel Amen
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("PySide6")
+
+from Core.Compiler.compiler import CompilationThread
+
+
+class _FakeProcessNoStreams:
+    stdout = None
+    stderr = None
+
+    def poll(self):
+        return None
+
+
+def test_read_output_handles_missing_streams_without_crash() -> None:
+    t = CompilationThread(program="python", args=[])
+    t.process = _FakeProcessNoStreams()
+    captured_errors: list[str] = []
+    t.error_ready.connect(lambda msg: captured_errors.append(msg))
+
+    t._read_output()
+
+    assert any("streams are unavailable" in m for m in captured_errors)