CLR Helper: Using the NSP Python SDK with .NET Apps - NSP

When NSP attaches to a .NET application, you access it through the same Session interface you use for any other runtime — get_str, get_int, get_bool, and execute() all work identically. For cases where you need to read a specific .NET field or invoke a managed method directly, session.clr provides a CLRSessionProxy with runtime-specific helpers.

Detecting CLR apps

Before calling CLR-specific methods, confirm that the attached app is a CLR process. Check the runtime field on any AppSummary from list_apps().

apps = await client.list_apps()
clr_apps = [a for a in apps if a.runtime == "clr"]

for app in clr_apps:
    print(f"{app.app_name}  pid={app.pid}  conf={app.confidence:.2f}")

Attaching to a CLR app

Attaching to a .NET app works exactly like attaching to any other app. Use the display name.

session = await client.attach("Mission Planner")
print(f"Runtime: {session.state.runtime}")   # clr
print(f"Confidence: {session.confidence:.2f}")

Reading state with standard accessors

The standard dot-notation accessors work the same way for CLR apps as they do for V8 or JVM apps. NSP normalizes .NET field values into the same flat SSF key-value map.

alt        = session.get_float("flight.altitude_m", 0.0)
mode       = session.get_str("flight.mode")
is_armed   = session.get_bool("flight.is_armed")
waypoints  = session.get_int("mission.waypoint_count", 0)

print(f"Alt={alt:.1f}m  Mode={mode}  Armed={is_armed}  WPs={waypoints}")

Use keys_with_prefix to see everything available under a namespace:

flight_data = session.state.keys_with_prefix("flight.")
for key, value in flight_data.items():
    print(f"  {key}: {value}")

Reading fields directly with `session.clr`

session.clr exposes read_field() and read_fields() for reading .NET field values by fully-qualified type name. Use these when you need a value that the standard probe doesn’t surface, or when you want lower-latency access to a specific field.

# Single field
armed = await session.clr.read_field("MAVLink.MAVLinkInterface", "IsArmed")
alt   = await session.clr.read_field("MissionPlanner.FlightData", "alt")
mode  = await session.clr.read_field("MissionPlanner.FlightData", "mode")

print(type(armed))   # <class 'bool'>
print(type(alt))     # <class 'float'>
print(type(mode))    # <class 'str'>

# Multiple fields in one round-trip
telemetry = await session.clr.read_fields(
    "MissionPlanner.FlightData",
    "alt", "groundspeed", "airspeed", "heading",
    "battery_voltage", "battery_remaining",
)
print(f"Altitude: {telemetry['alt']:.1f}m")
print(f"Battery:  {telemetry['battery_voltage']:.1f}V ({telemetry['battery_remaining']}%)")

Invoking managed methods

Use session.clr.invoke() to call a .NET method on the target process. Python values are automatically coerced to the correct .NET types based on the method’s parameter signature.

# Parameterless method
status = await session.clr.invoke("MissionPlanner.MainV2", "GetStatusText")
print(status)   # "OK: 3D GPS Fix. Satellites: 14"

# String argument — set flight mode
await session.clr.invoke("MissionPlanner.GCS", "setMode", ["GUIDED"])

# Multiple typed arguments — add a waypoint
await session.clr.invoke(
    "MissionPlanner.NavController",
    "SetWaypoint",
    [34.0522, -118.2437, 50.0],   # double, double, double
)

# Boolean argument — arm the vehicle
await session.clr.invoke("MissionPlanner.MainV2", "doArm", [True])

The raw_return field of an ActionResponse carries the method’s return value when you go through session.execute() for an action that maps to a managed method invocation. Check it to confirm what the CLR bridge returned.

result = await session.execute(
    "get_waypoint_count",
    parameters={},
)
print(f"Waypoints: {result.raw_return}")   # e.g. 7

Type coercion reference

Python type	.NET target
`True` / `False`	`bool`
`int`	`int`, `long`, `short`, `byte`, `uint`, …
`float`	`double`, `float`, `decimal`
`str`	`string`
`str` (ISO 8601)	`DateTime`
`str` (GUID format)	`Guid`
`list`	`T[]`, `List<T>`
`dict`	`Dictionary<string, object>`
`None`	`null`
`str` (enum name)	Any `enum` type

Cold probe timing

The first time NSP attaches to a CLR process, the initial probe can take 10 to 90 seconds. During this time, probe_status is "attaching" or "cold_probe" and the confidence score is low.

session = await client.attach("Mission Planner")

# Wait for probe_status to become "active" before executing actions
apps = await client.list_apps()
mp = next((a for a in apps if a.app_name == "Mission Planner"), None)

if mp and mp.probe_status != "active":
    print(f"Probe status: {mp.probe_status} — waiting...")

Call await session.refresh(fresh_probe=True) after attaching to a CLR app to confirm the first state snapshot is ready before reading fields. Once the probe is active, CLR apps operate at the same confidence range as JVM apps: 0.93–0.97.

Complete example: Mission Planner telemetry monitor

mission_planner.py

import asyncio
import nelieo_nsp as nsp

async def mission_planner_monitor():
    async with nsp.NSPClient() as client:
        session = await client.attach("Mission Planner")
        print(f"Connected to Mission Planner (runtime={session.state.runtime})")

        # Confirm probe is ready
        await session.refresh(fresh_probe=True)
        print(f"Confidence: {session.confidence:.2f}")

        while True:
            try:
                telemetry = await session.clr.read_fields(
                    "MissionPlanner.FlightData",
                    "alt", "groundspeed", "heading",
                    "battery_voltage", "battery_remaining",
                )
                armed = await session.clr.read_field(
                    "MAVLink.MAVLinkInterface", "IsArmed"
                )

                print(
                    f"Alt={telemetry['alt']:.1f}m  "
                    f"GS={telemetry['groundspeed']:.1f}m/s  "
                    f"Hdg={telemetry['heading']:.0f}°  "
                    f"Batt={telemetry['battery_remaining']}%  "
                    f"Armed={'✓' if armed else '✗'}"
                )
            except nsp.NSPActionError as e:
                print(f"Telemetry error: {e.code}")

            await asyncio.sleep(1.0)

asyncio.run(mission_planner_monitor())

​Detecting CLR apps

​Attaching to a CLR app

​Reading state with standard accessors

​Reading fields directly with session.clr

​Invoking managed methods

​Type coercion reference

​Cold probe timing

​Complete example: Mission Planner telemetry monitor

Detecting CLR apps

Attaching to a CLR app

Reading state with standard accessors

Reading fields directly with `session.clr`

Invoking managed methods

Type coercion reference

Cold probe timing

Complete example: Mission Planner telemetry monitor