px4-configuration 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

px4_configuration/api/__init__.py

@@ -1,5 +1,7 @@
 """PX4 Configuration REST API package."""
 
+from px4_configuration import __version__
+
 __all__ = [
     "config",
     "models",
@@ -7,5 +9,3 @@ __all__ = [
     "main",
 ]
 
-__version__ = "1.0.0"
-

px4_configuration/api/config.py

@@ -3,6 +3,16 @@
 import os
 
 
+def _get_package_version() -> str:
+    """Read version from package metadata (pyproject.toml). Single source of truth."""
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+
+        return version("px4-configuration")
+    except Exception:
+        return "0.0.0"
+
+
 class Settings:
     """Application settings with defaults."""
 
@@ -10,9 +20,9 @@ class Settings:
     default_port: str = os.getenv("PX4_DEFAULT_PORT", "/dev/pixhawk")
     default_baudrate: int = int(os.getenv("PX4_DEFAULT_BAUDRATE", "2000000"))
 
-    # API settings
+    # API settings (version from pyproject.toml via package metadata)
     api_title: str = "PX4 Configuration API"
-    api_version: str = "1.0.0"
+    api_version: str = _get_package_version()
     api_description: str = (
         "REST API for configuring PX4 flight controller from companion computer"
     )

px4_configuration/api/main.py

@@ -70,11 +70,11 @@ async def start_calibration(request: CalibrationRequest):
                 calibration_type=request.calibration_type,  # <-- enum here
             ):
                 # Convert dict -> SSE frame
-                yield f"data: {json.dumps(payload)}\n\n"
+                yield json.dumps(payload)
         except Exception as exc:
-            yield f"data: {json.dumps({'type': 'error', 'message': str(exc)})}\n\n"
+            yield json.dumps({'type': 'error', 'message': str(exc)})
         finally:
-            yield f"data: {json.dumps({'type': 'complete'})}\n\n"
+            yield json.dumps({'type': 'complete'})
 
     return EventSourceResponse(event_generator())
 

px4_configuration/api/models.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-from enum import StrEnum
-from typing import Literal, Optional, Dict, Any
+from enum import Enum
+from typing import Literal, Optional, Dict, Any, List
 
 from pydantic import BaseModel, Field, ConfigDict
 
 
-class CalibrationType(StrEnum):
+class CalibrationType(Enum):
     """Supported calibration types."""
     GYROSCOPE = "gyroscope"
     ACCELEROMETER = "accelerometer"
@@ -59,6 +59,61 @@ class CalibrationHealth(BaseModel):
         """Whether the calibration is required."""
         return not (self.gyroscope_ok and self.accelerometer_ok and self.magnetometer_ok)
 
+
+class HealthAndArmingCheckProblem(BaseModel):
+    """A single health/arming check problem from PX4 Events."""
+
+    message: str = Field(..., description="Short, single-line message.")
+    description: str = Field(default="", description="Detailed description (optional).")
+    health_component: str = Field(default="", description="Associated component, e.g. 'gps'.")
+
+
+class HealthAndArmingCheckMode(BaseModel):
+    """Arming checks for a specific flight mode (from PX4 Events)."""
+
+    mode_name: str = Field(..., description="Mode name, e.g. 'Position'.")
+    can_arm_or_run: bool = Field(
+        ...,
+        description="If disarmed: whether arming is possible. If armed: whether the mode can be selected.",
+    )
+    problems: List[HealthAndArmingCheckProblem] = Field(
+        default_factory=list,
+        description="List of reported problems for this mode.",
+    )
+
+
+class HealthComponentReport(BaseModel):
+    """Health component report (e.g. GPS, Accelerometer) from PX4 Events."""
+
+    name: str = Field(..., description="Unique component name, e.g. 'gps'.")
+    label: str = Field(..., description="Human-readable label, e.g. 'GPS'.")
+    is_present: bool = Field(..., description="Whether the component is present.")
+    has_error: bool = Field(..., description="Whether the component has errors.")
+    has_warning: bool = Field(..., description="Whether the component has warnings.")
+
+
+class HealthAndArmingCheckReport(BaseModel):
+    """
+    Health and arming checks report from MAVSDK Events plugin.
+
+    Provides detailed readiness-to-fly information: current mode arming status,
+    per-component health, and all reported problems.
+    """
+
+    current_mode_intention: Optional[HealthAndArmingCheckMode] = Field(
+        default=None,
+        description="Report for the currently intended flight mode (can_arm_or_run, problems).",
+    )
+    health_components: List[HealthComponentReport] = Field(
+        default_factory=list,
+        description="Health components (e.g. gps, accelerometer) with present/error/warning flags.",
+    )
+    all_problems: List[HealthAndArmingCheckProblem] = Field(
+        default_factory=list,
+        description="Complete list of all reported problems.",
+    )
+
+
 class Px4HealthResponse(BaseModel):
     """
     High-level PX4 health snapshot.
@@ -111,6 +166,14 @@ class Px4HealthResponse(BaseModel):
         description="True if PX4 considers the vehicle armable.",
     )
 
+    arming_checks_report: Optional[HealthAndArmingCheckReport] = Field(
+        default=None,
+        description=(
+            "Detailed health and arming checks from MAVSDK Events plugin "
+            "(mode intention, health components, all problems). None if Events plugin unavailable."
+        ),
+    )
+
     raw_health: Optional[Dict[str, Any]] = Field(
         default=None,
         description=(

px4_configuration/api/services/calibration_service.py

@@ -2,10 +2,17 @@
 
 from __future__ import annotations
 
-from typing import AsyncGenerator, Dict, Any
+import asyncio
+from typing import AsyncGenerator, Dict, Any, Optional
 
 from mavsdk import System
 
+try:
+    from grpc import RpcError
+except ImportError:
+    # Fallback if grpc is not directly available (shouldn't happen with mavsdk)
+    RpcError = Exception
+
 from ..models import CalibrationType
 from ..utils.calibration_parser import (
     parse_accelerometer_progress,
@@ -15,6 +22,40 @@ from ..utils.calibration_parser import (
 )
 
 
+def _format_grpc_error(exc: Exception) -> str:
+    """Format gRPC errors into user-friendly messages."""
+    error_msg = str(exc)
+    
+    if isinstance(exc, RpcError):
+        # Check for COMMAND_DENIED (PX4 rejected the command)
+        if "COMMAND_DENIED" in error_msg:
+            return (
+                "PX4 rejected the calibration command. "
+                "This may occur if: (1) a calibration is already in progress, "
+                "(2) the vehicle is armed or in flight, (3) the vehicle is not in the correct state. "
+                "Please ensure the vehicle is disarmed, on the ground, and no other calibration is running."
+            )
+        # Check for common gRPC error patterns
+        if "Connection reset by peer" in error_msg or "UNAVAILABLE" in error_msg:
+            return (
+                "Connection to PX4 device was lost. "
+                "This may occur if the device disconnected, rebooted, or the connection timed out. "
+                "Please check the device connection and try again."
+            )
+        elif "DEADLINE_EXCEEDED" in error_msg or "timeout" in error_msg.lower():
+            return (
+                "Connection timeout. The device may be unresponsive. "
+                "Please check the device connection and try again."
+            )
+        elif "PERMISSION_DENIED" in error_msg:
+            return "Permission denied. Please check device permissions."
+        else:
+            return f"gRPC error: {error_msg}"
+    
+    # For non-gRPC exceptions, return the error message as-is
+    return error_msg
+
+
 async def calibrate_sensors(
     port: str,
     baudrate: int,
@@ -26,111 +67,170 @@ async def calibrate_sensors(
     This function is transport-agnostic: it does NOT produce SSE-formatted strings.
     It yields plain Python dicts suitable for JSON serialization. The API layer
     (FastAPI endpoint) is responsible for converting these dicts into SSE frames.
+
+    The function properly handles connection cleanup and gRPC errors.
     """
 
     serial = f"serial://{port}:{baudrate}"
-    drone = System()
-
-    # Initial status messages
-    yield {
-        "type": "status",
-        "message": f"Connecting to {port}...",
-    }
-
-    # Connect to the PX4 system
-    await drone.connect(system_address=serial)
-
-    yield {
-        "type": "status",
-        "message": "Connected to device",
-    }
-
-    # Dispatch based on calibration type
-    if calibration_type is CalibrationType.GYROSCOPE:
-        # Gyroscope calibration
-        yield {
-            "type": "status",
-            "message": "Starting gyroscope calibration...",
-        }
-
-        async for progress_data in drone.calibration.calibrate_gyro():
-            structured_data = parse_gyroscope_progress(progress_data)
-            yield structured_data
-
-        yield {
-            "type": "gyroscope_complete",
-            "message": "Gyroscope calibration finished",
-            "is_complete": True,
-        }
-
-    elif calibration_type is CalibrationType.ACCELEROMETER:
-        # Accelerometer calibration
-        yield {
-            "type": "status",
-            "message": "Starting accelerometer calibration...",
-        }
-
-        async for progress_data in drone.calibration.calibrate_accelerometer():
-            structured_data = parse_accelerometer_progress(progress_data)
-            yield structured_data
-
-        yield {
-            "type": "accelerometer_complete",
-            "message": "Accelerometer calibration finished",
-            "is_complete": True,
-        }
+    drone: Optional[System] = None
 
-    elif calibration_type is CalibrationType.MAGNETOMETER:
-        # Magnetometer calibration
+    try:
+        # Initial status messages
         yield {
             "type": "status",
-            "message": "Starting magnetometer calibration...",
+            "message": f"Connecting to {port}...",
         }
 
-        async for progress_data in drone.calibration.calibrate_magnetometer():
-            structured_data = parse_magnetometer_progress(progress_data)
-            yield structured_data
+        # Create and connect to the PX4 system
+        drone = System()
+        await drone.connect(system_address=serial)
 
-        yield {
-            "type": "magnetometer_complete",
-            "message": "Magnetometer calibration finished",
-            "is_complete": True,
-        }
+        # Wait for connection to be established
+        async for state in drone.core.connection_state():
+            if state.is_connected:
+                break
 
-    elif calibration_type is CalibrationType.HORIZON:
-        # Level horizon calibration
         yield {
             "type": "status",
-            "message": "Starting board level horizon calibration...",
-        }
-
-        async for progress_data in drone.calibration.calibrate_level_horizon():
-            structured_data = parse_horizon_progress(progress_data)
-            yield structured_data
-
-        yield {
-            "type": "horizon_complete",
-            "message": "Level horizon calibration finished",
-            "is_complete": True,
+            "message": "Connected to device",
         }
 
-    elif calibration_type is CalibrationType.ESC:
-        # ESC calibration not implemented yet
-        yield {
-            "type": "status",
-            "message": "Starting ESC calibration...",
-        }
+        # Small delay to ensure connection is stable before starting calibration
+        # This helps avoid COMMAND_DENIED errors from rapid-fire requests
+        await asyncio.sleep(0.1)
+
+        # Dispatch based on calibration type
+        if calibration_type is CalibrationType.GYROSCOPE:
+            # Gyroscope calibration
+            yield {
+                "type": "status",
+                "message": "Starting gyroscope calibration...",
+            }
+
+            prev: Dict[str, Any] | None = None
+            try:
+                async for progress_data in drone.calibration.calibrate_gyro():
+                    structured_data = parse_gyroscope_progress(progress_data, prev=prev)
+                    prev = structured_data
+                    yield structured_data
+            except (RpcError, Exception) as exc:
+                yield {
+                    "type": "error",
+                    "message": f"Gyroscope calibration failed: {_format_grpc_error(exc)}",
+                }
+                raise
+
+            yield {
+                "type": "gyroscope_complete",
+                "message": "Gyroscope calibration finished",
+                "is_complete": True,
+            }
+
+        elif calibration_type is CalibrationType.ACCELEROMETER:
+            # Accelerometer calibration
+            yield {
+                "type": "status",
+                "message": "Starting accelerometer calibration...",
+            }
+
+            prev = None
+            try:
+                async for progress_data in drone.calibration.calibrate_accelerometer():
+                    structured_data = parse_accelerometer_progress(progress_data, prev=prev)
+                    prev = structured_data
+                    yield structured_data
+            except (RpcError, Exception) as exc:
+                yield {
+                    "type": "error",
+                    "message": f"Accelerometer calibration failed: {_format_grpc_error(exc)}",
+                }
+                raise
+
+            yield {
+                "type": "accelerometer_complete",
+                "message": "Accelerometer calibration finished",
+                "is_complete": True,
+            }
+
+        elif calibration_type is CalibrationType.MAGNETOMETER:
+            # Magnetometer calibration
+            yield {
+                "type": "status",
+                "message": "Starting magnetometer calibration...",
+            }
+
+            prev = None
+            try:
+                async for progress_data in drone.calibration.calibrate_magnetometer():
+                    structured_data = parse_magnetometer_progress(progress_data, prev=prev)
+                    prev = structured_data
+                    yield structured_data
+            except (RpcError, Exception) as exc:
+                yield {
+                    "type": "error",
+                    "message": f"Magnetometer calibration failed: {_format_grpc_error(exc)}",
+                }
+                raise
+
+            yield {
+                "type": "magnetometer_complete",
+                "message": "Magnetometer calibration finished",
+                "is_complete": True,
+            }
+
+        elif calibration_type is CalibrationType.HORIZON:
+            # Level horizon calibration
+            yield {
+                "type": "status",
+                "message": "Starting board level horizon calibration...",
+            }
+
+            prev = None
+            try:
+                async for progress_data in drone.calibration.calibrate_level_horizon():
+                    structured_data = parse_horizon_progress(progress_data, prev=prev)
+                    prev = structured_data
+                    yield structured_data
+            except (RpcError, Exception) as exc:
+                yield {
+                    "type": "error",
+                    "message": f"Horizon calibration failed: {_format_grpc_error(exc)}",
+                }
+                raise
+
+            yield {
+                "type": "horizon_complete",
+                "message": "Level horizon calibration finished",
+                "is_complete": True,
+            }
+
+        elif calibration_type is CalibrationType.ESC:
+            # ESC calibration not implemented yet
+            yield {
+                "type": "status",
+                "message": "Starting ESC calibration...",
+            }
+            yield {
+                "type": "warning",
+                "message": "ESC calibration not yet implemented",
+            }
+            yield {
+                "type": "status",
+                "message": "ESC calibration finished",
+            }
+
+    except (RpcError, Exception) as exc:
+        # Handle connection and gRPC errors
+        error_message = _format_grpc_error(exc)
         yield {
-            "type": "warning",
-            "message": "ESC calibration not yet implemented",
+            "type": "error",
+            "message": f"Calibration failed: {error_message}",
         }
-        yield {
-            "type": "status",
-            "message": "ESC calibration finished",
-        }
-
-    # Final success message for the whole calibration run
-    yield {
-        "type": "success",
-        "message": "Calibration sequence completed",
-    }
+        raise
+
+    finally:
+        # Cleanup: Ensure the System object is properly released
+        # MAVSDK System objects are cleaned up when they go out of scope,
+        # but explicitly setting to None helps with resource management
+        if drone is not None:
+            drone = None

px4_configuration/api/services/health_service.py

@@ -3,38 +3,105 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Optional, Dict, Any
+from typing import Any, Dict, Optional
 
 from mavsdk import System
 
+try:
+    from grpc import RpcError
+except ImportError:
+    # Fallback if grpc is not directly available (shouldn't happen with mavsdk)
+    RpcError = Exception
+
 from ..config import settings
-from ..models import Px4HealthResponse, CalibrationHealth
+from ..models import (
+    Px4HealthResponse,
+    CalibrationHealth,
+    HealthAndArmingCheckReport,
+    HealthAndArmingCheckMode,
+    HealthAndArmingCheckProblem,
+    HealthComponentReport,
+)
 
 
-async def _get_health_once(drone: System, timeout_s: float = 5.0):
+async def _get_stable_health(drone: System, duration_s: float = 2.0) -> Optional[Any]:
     """
-    Wait for the first telemetry.health() message.
-
-    Raises asyncio.TimeoutError if nothing is received within timeout_s.
+    Stream health messages for the specified duration and return the latest.
+    This skips initial stale messages (all False) and gets accurate values.
     """
-    async def _first():
+    latest_health = None
+    start_time = asyncio.get_event_loop().time()
+    
+    try:
         async for health in drone.telemetry.health():
-            return health
+            latest_health = health
+            elapsed = asyncio.get_event_loop().time() - start_time
+            if elapsed >= duration_s:
+                break
+    except Exception:
+        pass
+    
+    return latest_health
+
+
+def _convert_arming_checks_report(report: Any) -> HealthAndArmingCheckReport:
+    """Convert MAVSDK HealthAndArmingCheckReport to our Pydantic model."""
+    current = getattr(report, "current_mode_intention", None)
+    current_mode = None
+    if current is not None:
+        problems = [
+            HealthAndArmingCheckProblem(
+                message=getattr(p, "message", ""),
+                description=getattr(p, "description", ""),
+                health_component=getattr(p, "health_component", ""),
+            )
+            for p in (getattr(current, "problems", None) or [])
+        ]
+        current_mode = HealthAndArmingCheckMode(
+            mode_name=getattr(current, "mode_name", ""),
+            can_arm_or_run=getattr(current, "can_arm_or_run", False),
+            problems=problems,
+        )
+
+    health_components = [
+        HealthComponentReport(
+            name=getattr(c, "name", ""),
+            label=getattr(c, "label", ""),
+            is_present=getattr(c, "is_present", False),
+            has_error=getattr(c, "has_error", False),
+            has_warning=getattr(c, "has_warning", False),
+        )
+        for c in (getattr(report, "health_components", None) or [])
+    ]
+
+    all_problems = [
+        HealthAndArmingCheckProblem(
+            message=getattr(p, "message", ""),
+            description=getattr(p, "description", ""),
+            health_component=getattr(p, "health_component", ""),
+        )
+        for p in (getattr(report, "all_problems", None) or [])
+    ]
 
-    return await asyncio.wait_for(_first(), timeout_s)
+    return HealthAndArmingCheckReport(
+        current_mode_intention=current_mode,
+        health_components=health_components,
+        all_problems=all_problems,
+    )
 
 
-async def _get_gps_info_once(drone: System, timeout_s: float = 5.0):
+async def _get_arming_checks_report(drone: System) -> Optional[HealthAndArmingCheckReport]:
     """
-    Wait for the first telemetry.gps_info() message.
-
-    Raises asyncio.TimeoutError if nothing is received within timeout_s.
+    Fetch health and arming checks report from MAVSDK Events plugin.
+    Returns None if Events plugin is not available (e.g. older PX4).
     """
-    async def _first():
-        async for gps_info in drone.telemetry.gps_info():
-            return gps_info
-
-    return await asyncio.wait_for(_first(), timeout_s)
+    try:
+        report = await drone.events.get_health_and_arming_checks_report()
+        if report is None:
+            return None
+        return _convert_arming_checks_report(report)
+    except Exception:
+        return None
 
 
 async def read_px4_health(
@@ -42,83 +109,95 @@ async def read_px4_health(
     baudrate: Optional[int] = None,
     timeout_s: float = 10.0,
 ) -> Px4HealthResponse:
-    """
-    Connect to PX4 via MAVSDK and return a one-shot health snapshot.
-
-    - Uses telemetry.health() for calibration + armable flags.
-    - Uses telemetry.gps_info() for fix type + satellites.
-    - Returns Px4HealthResponse; never raises to the API layer.
-    """
+    """Connect to PX4 via MAVSDK and return a health snapshot using telemetry health flags."""
 
-    # Fallback to global settings if not provided explicitly
     port = port or settings.default_port
     baudrate = baudrate or settings.default_baudrate
     serial = f"serial://{port}:{baudrate}"
 
-    drone = System()
+    drone: Optional[System] = None
 
     try:
-        # Connect to PX4
+        drone = System()
         await drone.connect(system_address=serial)
 
-        # Get health & GPS within the global timeout
-        health = await _get_health_once(drone, timeout_s=timeout_s / 2)
+        # Wait for connection with timeout
+        connection_established = False
         try:
-            gps_info = await _get_gps_info_once(drone, timeout_s=timeout_s / 2)
-        except asyncio.TimeoutError:
-            gps_info = None
-
-        # Build calibration health
+            async for state in drone.core.connection_state():
+                if state.is_connected:
+                    connection_established = True
+                    break
+                # Timeout if not connected within reasonable time
+                await asyncio.sleep(0.1)
+        except (RpcError, Exception):
+            connection_established = False
+
+        if not connection_established:
+            return Px4HealthResponse(
+                status="disconnected",
+                connection_port=port,
+                connection_baudrate=baudrate,
+                calibration=None,
+                gps_fix_type=None,
+                satellites_used=None,
+                armable=False,
+                arming_checks_report=None,
+                raw_health=None,
+            )
+
+        # Stream health for 2 seconds to get accurate values (skip initial stale messages)
+        health = await asyncio.wait_for(_get_stable_health(drone, duration_s=2.0), timeout_s)
+
+        if health is None:
+            return Px4HealthResponse(
+                status="disconnected",
+                connection_port=port,
+                connection_baudrate=baudrate,
+                calibration=None,
+                gps_fix_type=None,
+                satellites_used=None,
+                armable=False,
+                arming_checks_report=None,
+                raw_health=None,
+            )
+
+        # Use telemetry health flags directly
         calibration = CalibrationHealth(
             gyroscope_ok=health.is_gyrometer_calibration_ok,
             accelerometer_ok=health.is_accelerometer_calibration_ok,
             magnetometer_ok=health.is_magnetometer_calibration_ok,
         )
 
-        # GPS fields
-        gps_fix_type: Optional[str] = None
-        satellites_used: Optional[int] = None
-
-        if gps_info is not None:
-            # gps_info.fix_type is an enum; prefer its name
-            if hasattr(gps_info.fix_type, "name"):
-                gps_fix_type = gps_info.fix_type.name.lower()
-            else:
-                gps_fix_type = str(gps_info.fix_type).lower()
+        # Determine status
+        status = "ok" if (health.is_armable and not calibration.requires_calibration) else "degraded"
 
-            # MAVSDK docs: num_satellites = number of visible satellites in use
-            satellites_used = int(getattr(gps_info, "num_satellites", 0))
-
-        # High-level status heuristic
-        if calibration.requires_calibration:
-            status = "degraded"
-        else:
-            status = "ok"
-
-        # Raw health flags (optional, but handy for debugging / advanced UI)
+        # Minimal raw health for debugging
         raw_health: Dict[str, Any] = {
+            "raw_health_message": str(health),
             "is_gyrometer_calibration_ok": health.is_gyrometer_calibration_ok,
             "is_accelerometer_calibration_ok": health.is_accelerometer_calibration_ok,
             "is_magnetometer_calibration_ok": health.is_magnetometer_calibration_ok,
-            "is_local_position_ok": getattr(health, "is_local_position_ok", None),
-            "is_global_position_ok": getattr(health, "is_global_position_ok", None),
-            "is_home_position_ok": getattr(health, "is_home_position_ok", None),
             "is_armable": health.is_armable,
         }
 
+        # Fetch detailed health and arming checks from Events plugin (optional)
+        arming_checks_report = await _get_arming_checks_report(drone)
+
         return Px4HealthResponse(
             status=status,
             connection_port=port,
             connection_baudrate=baudrate,
             calibration=calibration,
-            gps_fix_type=gps_fix_type,
-            satellites_used=satellites_used,
+            gps_fix_type=None,
+            satellites_used=None,
             armable=health.is_armable,
+            arming_checks_report=arming_checks_report,
             raw_health=raw_health,
         )
 
-    except (asyncio.TimeoutError, Exception):
-        # On any connection / telemetry failure, report "disconnected"
+    except (RpcError, Exception):
+        # Return disconnected status on any error
         return Px4HealthResponse(
             status="disconnected",
             connection_port=port,
@@ -127,5 +206,10 @@ async def read_px4_health(
             gps_fix_type=None,
             satellites_used=None,
             armable=False,
+            arming_checks_report=None,
             raw_health=None,
         )
+    finally:
+        # Cleanup: Ensure the System object is properly released
+        if drone is not None:
+            drone = None

px4_configuration/api/services/param_service.py

@@ -1,10 +1,16 @@
 """Service for PX4 parameter upload operations."""
 
 import json
-from typing import AsyncGenerator
+from typing import AsyncGenerator, Optional
 
 from mavsdk import System
 
+try:
+    from grpc import RpcError
+except ImportError:
+    # Fallback if grpc is not directly available (shouldn't happen with mavsdk)
+    RpcError = Exception
+
 
 async def upload_parameters(
     param_file_path: str,
@@ -13,7 +19,7 @@ async def upload_parameters(
 ) -> AsyncGenerator[str, None]:
     """Upload PX4 parameters from a .params file, streaming progress via SSE."""
 
-    drone = None
+    drone: Optional[System] = None
     try:
         drone = System()
         serial = f"serial://{port}:{baudrate}"
@@ -22,6 +28,12 @@ async def upload_parameters(
             json.dumps({"type": "status", "message": f"Connecting to {port}..."})
         )
         await drone.connect(system_address=serial)
+
+        # Wait for connection to be established
+        async for state in drone.core.connection_state():
+            if state.is_connected:
+                break
+
         yield "data: {}\n\n".format(
             json.dumps({"type": "status", "message": "Connected to device"})
         )
@@ -133,18 +145,25 @@ async def upload_parameters(
             )
         )
 
-    except Exception as exc:  # pragma: no cover - streaming generator
+    except (RpcError, Exception) as exc:  # pragma: no cover - streaming generator
+        error_msg = str(exc)
+        if isinstance(exc, RpcError):
+            if "Connection reset by peer" in error_msg or "UNAVAILABLE" in error_msg:
+                error_msg = (
+                    "Connection to PX4 device was lost. "
+                    "This may occur if the device disconnected, rebooted, or the connection timed out."
+                )
         yield "data: {}\n\n".format(
             json.dumps(
                 {
                     "type": "error",
-                    "message": f"Parameter upload failed: {exc}",
+                    "message": f"Parameter upload failed: {error_msg}",
                 }
             )
         )
         raise
     finally:
-        if drone:
-            # No explicit teardown required
-            pass
+        # Cleanup: Ensure the System object is properly released
+        if drone is not None:
+            drone = None
 

px4_configuration/api/services/sdcard_service.py

@@ -1,10 +1,16 @@
 """Service for uploading files to PX4 SD card via FTP."""
 
 import json
-from typing import AsyncGenerator
+from typing import AsyncGenerator, Optional
 
 from mavsdk import System
 
+try:
+    from grpc import RpcError
+except ImportError:
+    # Fallback if grpc is not directly available (shouldn't happen with mavsdk)
+    RpcError = Exception
+
 
 async def upload_to_sdcard(
     file_path: str,
@@ -14,7 +20,7 @@ async def upload_to_sdcard(
 ) -> AsyncGenerator[str, None]:
     """Upload a file to the PX4 SD card via MAVSDK FTP and stream progress."""
 
-    drone = None
+    drone: Optional[System] = None
     try:
         drone = System()
         serial = f"serial://{port}:{baudrate}"
@@ -23,6 +29,12 @@ async def upload_to_sdcard(
             json.dumps({"type": "status", "message": f"Connecting to {port}..."})
         )
         await drone.connect(system_address=serial)
+
+        # Wait for connection to be established
+        async for state in drone.core.connection_state():
+            if state.is_connected:
+                break
+
         yield "data: {}\n\n".format(
             json.dumps({"type": "status", "message": "Connected to device"})
         )
@@ -72,18 +84,25 @@ async def upload_to_sdcard(
             json.dumps({"type": "success", "message": "File uploaded successfully"})
         )
 
-    except Exception as exc:  # pragma: no cover - streaming generator
+    except (RpcError, Exception) as exc:  # pragma: no cover - streaming generator
+        error_msg = str(exc)
+        if isinstance(exc, RpcError):
+            if "Connection reset by peer" in error_msg or "UNAVAILABLE" in error_msg:
+                error_msg = (
+                    "Connection to PX4 device was lost. "
+                    "This may occur if the device disconnected, rebooted, or the connection timed out."
+                )
         yield "data: {}\n\n".format(
             json.dumps(
                 {
                     "type": "error",
-                    "message": f"SD card upload failed: {exc}",
+                    "message": f"SD card upload failed: {error_msg}",
                 }
             )
         )
         raise
     finally:
-        if drone:
-            # No explicit teardown required
-            pass
+        # Cleanup: Ensure the System object is properly released
+        if drone is not None:
+            drone = None
 

px4_configuration/api/services/shell_service.py

@@ -5,6 +5,12 @@ from typing import Optional
 
 from mavsdk import System
 
+try:
+    from grpc import RpcError
+except ImportError:
+    # Fallback if grpc is not directly available (shouldn't happen with mavsdk)
+    RpcError = Exception
+
 
 class ShellConnection:
     """Manage a persistent MAVSDK shell connection with queued output."""
@@ -19,16 +25,23 @@ class ShellConnection:
     async def connect(self) -> None:
         """Establish connection to PX4 and start shell monitoring."""
 
-        self.drone = System()
-        serial = f"serial://{self.port}:{self.baudrate}"
-        await self.drone.connect(system_address=serial)
-
-        async for state in self.drone.core.connection_state():
-            if state.is_connected:
-                self.connected = True
-                break
-
-        asyncio.create_task(self._observe_shell())
+        try:
+            self.drone = System()
+            serial = f"serial://{self.port}:{self.baudrate}"
+            await self.drone.connect(system_address=serial)
+
+            # Wait for connection to be established
+            async for state in self.drone.core.connection_state():
+                if state.is_connected:
+                    self.connected = True
+                    break
+
+            asyncio.create_task(self._observe_shell())
+        except (RpcError, Exception) as exc:
+            self.connected = False
+            if self.drone is not None:
+                self.drone = None
+            raise RuntimeError(f"Failed to connect to PX4 shell: {exc}") from exc
 
     async def _observe_shell(self) -> None:
         """Monitor shell output and place data into the queue."""
@@ -38,16 +51,27 @@ class ShellConnection:
 
         try:
             async for output in self.drone.shell.receive():
+                if not self.connected:
+                    break
                 await self.output_queue.put(output)
-        except Exception as exc:  # pragma: no cover - streaming loop
-            await self.output_queue.put(f"Error receiving shell output: {exc}")
+        except (RpcError, Exception) as exc:  # pragma: no cover - streaming loop
+            error_msg = str(exc)
+            if isinstance(exc, RpcError):
+                if "Connection reset by peer" in error_msg or "UNAVAILABLE" in error_msg:
+                    error_msg = "Connection to PX4 device was lost"
+            await self.output_queue.put(f"Error receiving shell output: {error_msg}")
+            self.connected = False
 
     async def send_command(self, command: str) -> None:
         """Send a command to the PX4 shell."""
 
         if not self.connected or not self.drone:
             raise RuntimeError("Not connected to PX4")
-        await self.drone.shell.send(command)
+        try:
+            await self.drone.shell.send(command)
+        except (RpcError, Exception) as exc:
+            self.connected = False
+            raise RuntimeError(f"Failed to send command: {exc}") from exc
 
     async def receive_output(self) -> Optional[str]:
         """Receive shell output (non-blocking)."""
@@ -58,8 +82,10 @@ class ShellConnection:
             return None
 
     async def disconnect(self) -> None:
-        """Close the connection if required."""
+        """Close the connection and cleanup resources."""
 
         self.connected = False
-        # MAVSDK handles cleanup on garbage collection; nothing else required here.
+        # Cleanup: Ensure the System object is properly released
+        if self.drone is not None:
+            self.drone = None
 

px4_configuration/api/utils/calibration_parser.py

@@ -5,7 +5,10 @@ from typing import Optional, Dict, Any, List
 import math
 
 
-def parse_accelerometer_progress(progress_data) -> Dict[str, Any]:
+def parse_accelerometer_progress(
+    progress_data,
+    prev: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
     """
     Parse accelerometer calibration progress data into structured format.
     
@@ -33,10 +36,11 @@ def parse_accelerometer_progress(progress_data) -> Dict[str, Any]:
             result["progress"] = float(progress_value)
     
     # Extract status text if available
+    pending_match = None
     if hasattr(progress_data, 'has_status_text') and progress_data.has_status_text:
         status_text = progress_data.status_text
         result["status_text"] = status_text
-        
+
         # Parse pending orientations (e.g., "pending: back front left right up down")
         pending_match = re.search(r'pending:\s*([a-z\s]+)', status_text, re.IGNORECASE)
         if pending_match:
@@ -65,31 +69,44 @@ def parse_accelerometer_progress(progress_data) -> Dict[str, Any]:
             except ValueError:
                 pass
         
-        # Determine current message/instruction
-        if "progress" in status_text.lower() and "<" in status_text and ">" in status_text:
+        # Determine current message/instruction (normalize to simple labels)
+        low = status_text.lower()
+        if "progress" in low and "<" in status_text and ">" in status_text:
             # This seems to be a completion indicator (e.g., "progress <102>")
             result["is_complete"] = True
             result["current_message"] = "complete"
-        elif "hold vehicle still" in status_text.lower():
+        elif pending_match:
+            result["current_message"] = "pending"
+        elif "hold vehicle still" in low:
             result["current_message"] = "hold_still"
-        elif "detected rest position" in status_text.lower():
+        elif "detected rest position" in low:
             result["current_message"] = "rest_detected"
-        elif "measuring" in status_text.lower():
+        elif "measuring" in low:
             result["current_message"] = "measuring"
-        elif "done, rotate" in status_text.lower():
+        elif "done, rotate" in low:
             result["current_message"] = "rotate"
-        elif "already completed" in status_text.lower():
+        elif "already completed" in low:
             result["current_message"] = "already_completed"
-        elif "orientation detected" in status_text.lower():
+        elif "orientation detected" in low:
             result["current_message"] = "orientation_detected"
         else:
             # Default: use the status text as message
             result["current_message"] = status_text
+
+    # Carry forward state from previous snapshot where appropriate
+    if prev:
+        if not result["pending_orientations"]:
+            result["pending_orientations"] = prev.get("pending_orientations", [])
+        if result["current_orientation"] is None:
+            result["current_orientation"] = prev.get("current_orientation")
     
     return result
 
 
-def parse_gyroscope_progress(progress_data) -> Dict[str, Any]:
+def parse_gyroscope_progress(
+    progress_data,
+    prev: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
     """
     Parse gyroscope calibration progress data into structured format.
     
@@ -126,11 +143,19 @@ def parse_gyroscope_progress(progress_data) -> Dict[str, Any]:
         result["status_text"] = status_text
         if status_text and not result["current_message"]:
             result["current_message"] = status_text
+
+    # Carry forward simple state where helpful
+    if prev:
+        if result["progress"] is None:
+            result["progress"] = prev.get("progress")
     
     return result
 
 
-def parse_magnetometer_progress(progress_data) -> Dict[str, Any]:
+def parse_magnetometer_progress(
+    progress_data,
+    prev: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
     """
     Parse magnetometer calibration progress data into structured format.
     
@@ -185,29 +210,40 @@ def parse_magnetometer_progress(progress_data) -> Dict[str, Any]:
                 result["current_orientation"] = match.group(1).lower()
                 break
         
-        # Determine current message/instruction
-        if "Rotate vehicle" in status_text:
+        # Determine current message/instruction (normalize)
+        low = status_text.lower()
+        if "rotate vehicle" in status_text:
             result["current_message"] = "rotate"
-        elif "hold vehicle still" in status_text.lower():
+        elif "hold vehicle still" in low:
             result["current_message"] = "hold_still"
-        elif "detected rest position" in status_text.lower():
+        elif "detected rest position" in low:
             result["current_message"] = "rest_detected"
-        elif "detected motion" in status_text.lower():
+        elif "detected motion" in low:
             result["current_message"] = "motion_detected"
-        elif "done, rotate" in status_text.lower():
+        elif "done, rotate" in low:
             result["current_message"] = "rotate"
-        elif "already completed" in status_text.lower():
+        elif "already completed" in low:
             result["current_message"] = "already_completed"
-        elif "orientation detected" in status_text.lower():
+        elif "orientation detected" in low:
             result["current_message"] = "orientation_detected"
         else:
             # Default: use the status text as message
             result["current_message"] = status_text
+
+    # Carry forward orientation / pending where appropriate
+    if prev:
+        if not result["pending_orientations"]:
+            result["pending_orientations"] = prev.get("pending_orientations", [])
+        if result["current_orientation"] is None:
+            result["current_orientation"] = prev.get("current_orientation")
     
     return result
 
 
-def parse_horizon_progress(progress_data) -> Dict[str, Any]:
+def parse_horizon_progress(
+    progress_data,
+    prev: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
     """
     Parse level horizon calibration progress data into structured format.
     
@@ -243,6 +279,11 @@ def parse_horizon_progress(progress_data) -> Dict[str, Any]:
         result["status_text"] = status_text
         if status_text and not result["current_message"]:
             result["current_message"] = status_text
+
+    # Carry forward simple state where helpful
+    if prev:
+        if result["progress"] is None:
+            result["progress"] = prev.get("progress")
     
     return result
 

{px4_configuration-0.2.0.dist-info → px4_configuration-0.2.2.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: px4-configuration
-Version: 0.2.0
+Version: 0.2.2
 Summary: Tools and REST API for configuring PX4 from a companion computer
 Author-email: Alex <bonnefond@fly4future.com>
 License: BSD-3-Clause
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Requires-Dist: fastapi>=0.104.0
-Requires-Dist: mavsdk==3.0.1
+Requires-Dist: mavsdk==3.10.2
 Requires-Dist: python-multipart>=0.0.6
 Requires-Dist: sse-starlette>=1.6.5
 Requires-Dist: tqdm==4.67.1
@@ -60,7 +60,7 @@ pip install dist/px4_configuration-0.1.0-py3-none-any.whl
 
 ## Requirements
 
-- Python 3.8+
+- Python 3.10+
 - PX4 flight controller connected over serial (e.g. `/dev/pixhawk`)
 - User added to the `dialout` group for serial access (`sudo usermod -aG dialout $USER`)
 

px4_configuration-0.2.2.dist-info/RECORD

@@ -0,0 +1,17 @@
+px4_configuration/__init__.py,sha256=U0jqmbB8mDtIQ_ZPVjfHzoF7b9EM1TFJQRWEJ49Vk1I,334
+px4_configuration/api/__init__.py,sha256=vQzGhWTEdxVccRcgICUNqCWF-1Ts7t_dGryDTnsGKCs,157
+px4_configuration/api/config.py,sha256=onlTwFoMEcbNDRWK77xb_hMZqft_gAEgC8ZR1pPaYLE,920
+px4_configuration/api/main.py,sha256=aeGpssDFcg9xwps3sdRM0tH2p2yYeqkGn9y7QLHw3I4,8278
+px4_configuration/api/models.py,sha256=ltb6N-8g6prR-vNqj_OCh7U0AqqxNDGHZm6ksgWo3DA,6081
+px4_configuration/api/services/__init__.py,sha256=U91RCGMiGcIQqtbnzscfNbWpFw65ZNz0DKabCPtTGMw,163
+px4_configuration/api/services/calibration_service.py,sha256=W5ZpkokPMOjfK3Sf64JAFKiRdrc0QivCYIGfBedLNBc,8451
+px4_configuration/api/services/health_service.py,sha256=WcZR3aioEFVQ1PwrHZYlR3bCKX3-2HdCBA6uPBUbavM,7299
+px4_configuration/api/services/param_service.py,sha256=AUDNckhF05hCK7zOF8l9yI4erD76VWqpFZuglN-ejnQ,5977
+px4_configuration/api/services/sdcard_service.py,sha256=UKZNR6n5c0Xrlpv2TKM2HmG6Rujwr3svZqJ6m050kMQ,3419
+px4_configuration/api/services/shell_service.py,sha256=Df9Zprdu4s1tq2i0-uS83kR76We2f601ULZcLhmmQ9I,3167
+px4_configuration/api/utils/__init__.py,sha256=KR-_U6nAXr8V1uxsB1hCFXPxKYYEwbf096kvhhUJfFk,54
+px4_configuration/api/utils/calibration_parser.py,sha256=rlW4D-ogc0z8o80jBkazZ3oqucAvSMGp_vKfpp5bLp0,10990
+px4_configuration-0.2.2.dist-info/METADATA,sha256=JPSgYEMPqn1HBaK2ts3U6PUbpaslJlbAxTTY9ZavqFM,7109
+px4_configuration-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+px4_configuration-0.2.2.dist-info/entry_points.txt,sha256=mBRa68p2qL9HPLE9nCruYZDtTmuDOhFIbkY_nwX-WTc,67
+px4_configuration-0.2.2.dist-info/RECORD,,

{px4_configuration-0.2.0.dist-info → px4_configuration-0.2.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

px4_configuration-0.2.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-px4_configuration/__init__.py,sha256=U0jqmbB8mDtIQ_ZPVjfHzoF7b9EM1TFJQRWEJ49Vk1I,334
-px4_configuration/api/__init__.py,sha256=o0txTrY6RjO1ehOJGtMerrVMm0QR1E4PiutPhoKtmZo,137
-px4_configuration/api/config.py,sha256=imb6qv75ye_DE4t7kbf7xbxWPvy3Yota95keVjg1c5A,562
-px4_configuration/api/main.py,sha256=xiOOVfWQB6pRhzA2rDJzFDrfGTnqAyQeIcQ3Hlzplyk,8323
-px4_configuration/api/models.py,sha256=Wi0eWsfqd4noxSPgIN4yUnKGdoncBwkmlSvCs6HAsbE,3552
-px4_configuration/api/services/__init__.py,sha256=U91RCGMiGcIQqtbnzscfNbWpFw65ZNz0DKabCPtTGMw,163
-px4_configuration/api/services/calibration_service.py,sha256=yLlSd3ePe4zOrb4hdXdiwVRiZ5u1f-ACO1-eiyocFSU,4076
-px4_configuration/api/services/health_service.py,sha256=3rNGRfy0GvwnQ_OMD4jU5qm-O2_YDOnfVg_AGS3Fcl4,4457
-px4_configuration/api/services/param_service.py,sha256=95Ee5v3rEGjXiW2LJURTUHXqtxBl2JomV_tMcLwGjac,5201
-px4_configuration/api/services/sdcard_service.py,sha256=6bnMTcaHddo8ZOsrKtl39V518MBO_Z-2fXFT4PTLT5M,2643
-px4_configuration/api/services/shell_service.py,sha256=A_28vCxWyc6e-Usf3QLHqCy5Auf7tyGwqySQ5E5LO1s,2096
-px4_configuration/api/utils/__init__.py,sha256=KR-_U6nAXr8V1uxsB1hCFXPxKYYEwbf096kvhhUJfFk,54
-px4_configuration/api/utils/calibration_parser.py,sha256=ARn702mhz16gJV3gw0-HvFQmUSNCMbohwxTAtcs06GQ,9821
-px4_configuration-0.2.0.dist-info/METADATA,sha256=MaxU3zpqE8nUdJgb892fbuMvrnqL1irMfyAs43fyYus,7106
-px4_configuration-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-px4_configuration-0.2.0.dist-info/entry_points.txt,sha256=mBRa68p2qL9HPLE9nCruYZDtTmuDOhFIbkY_nwX-WTc,67
-px4_configuration-0.2.0.dist-info/RECORD,,