py-acevo 0.0.1__tar.gz

py_acevo-0.0.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: py-acevo
+Version: 0.0.1
+Summary: Read Assetto Corsa EVO shared memory on Windows.
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# py-acevo
+
+The Python library to read shared memory of Assetto Corsa Evo.

py_acevo-0.0.1/README.MD

@@ -0,0 +1,3 @@
+# py-acevo
+
+The Python library to read shared memory of Assetto Corsa Evo.

py_acevo-0.0.1/VERSION

@@ -0,0 +1 @@
+0.0.1

py_acevo-0.0.1/acevo/__init__.py

@@ -0,0 +1,5 @@
+"""Read Assetto Corsa EVO shared-memory telemetry on Windows."""
+
+from .reader import Reader
+
+__all__ = ["Reader"]

py_acevo-0.0.1/acevo/models/enums.py

@@ -0,0 +1,49 @@
+from enum import IntEnum
+
+
+class ACEVO_STATUS(IntEnum):
+    AC_OFF = 0
+    AC_REPLAY = 1
+    AC_LIVE = 2
+    AC_PAUSE = 3
+
+
+class ACEVO_SESSION_TYPE(IntEnum):
+    AC_UNKNOWN = -1
+    AC_TIME_ATTACK = 0
+    AC_RACE = 1
+    AC_HOT_STINT = 2
+    AC_CRUISE = 3
+
+
+class ACEVO_FLAG_TYPE(IntEnum):
+    AC_NO_FLAG = 0
+    AC_WHITE_FLAG = 1
+    AC_GREEN_FLAG = 2
+    AC_RED_FLAG = 3
+    AC_BLUE_FLAG = 4
+    AC_YELLOW_FLAG = 5
+    AC_BLACK_FLAG = 6
+    AC_BLACK_WHITE_FLAG = 7
+    AC_CHECKERED_FLAG = 8
+    AC_ORANGE_CIRCLE_FLAG = 9
+    AC_RED_YELLOW_STRIPES_FLAG = 10
+
+
+class ACEVO_CAR_LOCATION(IntEnum):
+    ACEVO_UNASSIGNED = 0
+    ACEVO_PITLANE = 1
+    ACEVO_PITENTRY = 2
+    ACEVO_PITEXIT = 3
+    ACEVO_TRACK = 4
+
+
+class ACEVO_ENGINE_TYPE(IntEnum):
+    ACEVO_INTERNAL_COMBUSTION = 0
+    ACEVO_ELECTRIC_MOTOR = 1
+
+
+class ACEVO_STARTING_GRIP(IntEnum):
+    ACEVO_GREEN = 0
+    ACEVO_FAST = 1
+    ACEVO_OPTIMUM = 2

py_acevo-0.0.1/acevo/models/graphics.py

@@ -0,0 +1,581 @@
+from ctypes import (
+    LittleEndianStructure,
+    sizeof,
+    c_bool,
+    c_char,
+    c_float,
+    c_int16,
+    c_int32,
+    c_int8,
+    c_uint16,
+    c_uint32,
+    c_uint64,
+    c_uint8,
+)
+from collections.abc import Sequence
+
+
+FloatArray = Sequence[float]
+FloatMatrix = Sequence[FloatArray]
+
+
+class SMEvoTyreState(LittleEndianStructure):
+    _layout_ = "ms"
+    _pack_ = 4
+    slip: float
+    lock: bool
+    tyre_pression: float
+    tyre_temperature_c: float
+    brake_temperature_c: float
+    brake_pressure: float
+    tyre_temperature_left: float
+    tyre_temperature_center: float
+    tyre_temperature_right: float
+    tyre_compound_front: bytes
+    tyre_compound_rear: bytes
+    tyre_normalized_pressure: float
+    tyre_normalized_temperature_left: float
+    tyre_normalized_temperature_center: float
+    tyre_normalized_temperature_right: float
+    brake_normalized_temperature: float
+    tyre_normalized_temperature_core: float
+    _fields_ = [
+        ("slip", c_float),
+        ("lock", c_bool),
+        ("tyre_pression", c_float),
+        ("tyre_temperature_c", c_float),
+        ("brake_temperature_c", c_float),
+        ("brake_pressure", c_float),
+        ("tyre_temperature_left", c_float),
+        ("tyre_temperature_center", c_float),
+        ("tyre_temperature_right", c_float),
+        ("tyre_compound_front", (c_char * 33)),
+        ("tyre_compound_rear", (c_char * 33)),
+        ("tyre_normalized_pressure", c_float),
+        ("tyre_normalized_temperature_left", c_float),
+        ("tyre_normalized_temperature_center", c_float),
+        ("tyre_normalized_temperature_right", c_float),
+        ("brake_normalized_temperature", c_float),
+        ("tyre_normalized_temperature_core", c_float),
+        ("place_holder", (c_char * 128)),
+    ]
+
+
+class SMEvoDamageState(LittleEndianStructure):
+    _layout_ = "ms"
+    _pack_ = 4
+    damage_front: float
+    damage_rear: float
+    damage_left: float
+    damage_right: float
+    damage_center: float
+    damage_suspension_lf: float
+    damage_suspension_rf: float
+    damage_suspension_lr: float
+    damage_suspension_rr: float
+    _fields_ = [
+        ("damage_front", c_float),
+        ("damage_rear", c_float),
+        ("damage_left", c_float),
+        ("damage_right", c_float),
+        ("damage_center", c_float),
+        ("damage_suspension_lf", c_float),
+        ("damage_suspension_rf", c_float),
+        ("damage_suspension_lr", c_float),
+        ("damage_suspension_rr", c_float),
+        ("place_holder", (c_char * 92)),
+    ]
+
+
+class SMEvoPitInfo(LittleEndianStructure):
+    _layout_ = "ms"
+    _pack_ = 4
+    damage: int
+    fuel: int
+    tyres_lf: int
+    tyres_rf: int
+    tyres_lr: int
+    tyres_rr: int
+    _fields_ = [
+        ("damage", c_int8),
+        ("fuel", c_int8),
+        ("tyres_lf", c_int8),
+        ("tyres_rf", c_int8),
+        ("tyres_lr", c_int8),
+        ("tyres_rr", c_int8),
+        ("place_holder", (c_char * 58)),
+    ]
+
+
+class SMEvoElectronics(LittleEndianStructure):
+    _layout_ = "ms"
+    _pack_ = 4
+    tc_level: int
+    tc_cut_level: int
+    abs_level: int
+    esc_level: int
+    ebb_level: int
+    brake_bias: float
+    engine_map_level: int
+    turbo_level: float
+    ers_deployment_map: int
+    ers_recharge_map: float
+    is_ers_heat_charging_on: bool
+    is_ers_overtake_mode_on: bool
+    is_drs_open: bool
+    diff_power_level: int
+    diff_coast_level: int
+    front_bump_damper_level: int
+    front_rebound_damper_level: int
+    rear_bump_damper_level: int
+    rear_rebound_damper_level: int
+    is_ignition_on: bool
+    is_pitlimiter_on: bool
+    active_performance_mode: int
+    _fields_ = [
+        ("tc_level", c_int8),
+        ("tc_cut_level", c_int8),
+        ("abs_level", c_int8),
+        ("esc_level", c_int8),
+        ("ebb_level", c_int8),
+        ("brake_bias", c_float),
+        ("engine_map_level", c_int8),
+        ("turbo_level", c_float),
+        ("ers_deployment_map", c_int8),
+        ("ers_recharge_map", c_float),
+        ("is_ers_heat_charging_on", c_bool),
+        ("is_ers_overtake_mode_on", c_bool),
+        ("is_drs_open", c_bool),
+        ("diff_power_level", c_int8),
+        ("diff_coast_level", c_int8),
+        ("front_bump_damper_level", c_int8),
+        ("front_rebound_damper_level", c_int8),
+        ("rear_bump_damper_level", c_int8),
+        ("rear_rebound_damper_level", c_int8),
+        ("is_ignition_on", c_bool),
+        ("is_pitlimiter_on", c_bool),
+        ("active_performance_mode", c_int8),
+        ("place_holder", (c_char * 88)),
+    ]
+
+
+class SMEvoInstrumentation(LittleEndianStructure):
+    _layout_ = "ms"
+    _pack_ = 4
+    main_light_stage: int
+    special_light_stage: int
+    cockpit_light_stage: int
+    wiper_level: int
+    rain_lights: bool
+    direction_light_left: bool
+    direction_light_right: bool
+    flashing_lights: bool
+    warning_lights: bool
+    selected_display_index: int
+    display_current_page_index: Sequence[int]
+    are_headlights_visible: bool
+    _fields_ = [
+        ("main_light_stage", c_int8),
+        ("special_light_stage", c_int8),
+        ("cockpit_light_stage", c_int8),
+        ("wiper_level", c_int8),
+        ("rain_lights", c_bool),
+        ("direction_light_left", c_bool),
+        ("direction_light_right", c_bool),
+        ("flashing_lights", c_bool),
+        ("warning_lights", c_bool),
+        ("selected_display_index", c_int8),
+        ("display_current_page_index", (c_int8 * 16)),
+        ("are_headlights_visible", c_bool),
+        ("place_holder", (c_char * 101)),
+    ]
+
+
+class SMEvoSessionState(LittleEndianStructure):
+    _layout_ = "ms"
+    _pack_ = 4
+    phase_name: bytes
+    time_left: bytes
+    time_left_ms: int
+    wait_time: bytes
+    total_lap: int
+    current_lap: int
+    lights_on: int
+    lights_mode: int
+    lap_length_km: float
+    end_session_flag: int
+    time_to_next_session: bytes
+    disconnected_from_server: bool
+    restart_season_enabled: bool
+    ui_enable_drive: bool
+    ui_enable_setup: bool
+    is_ready_to_next_blinking: bool
+    show_waiting_for_players: bool
+    _fields_ = [
+        ("phase_name", (c_char * 33)),
+        ("time_left", (c_char * 15)),
+        ("time_left_ms", c_int32),
+        ("wait_time", (c_char * 15)),
+        ("total_lap", c_int32),
+        ("current_lap", c_int32),
+        ("lights_on", c_int32),
+        ("lights_mode", c_int32),
+        ("lap_length_km", c_float),
+        ("end_session_flag", c_int32),
+        ("time_to_next_session", (c_char * 15)),
+        ("disconnected_from_server", c_bool),
+        ("restart_season_enabled", c_bool),
+        ("ui_enable_drive", c_bool),
+        ("ui_enable_setup", c_bool),
+        ("is_ready_to_next_blinking", c_bool),
+        ("show_waiting_for_players", c_bool),
+        ("place_holder", (c_char * 140)),
+    ]
+
+
+class SMEvoTimingState(LittleEndianStructure):
+    _layout_ = "ms"
+    _pack_ = 4
+    current_laptime: bytes
+    delta_current: bytes
+    delta_current_p: int
+    last_laptime: bytes
+    delta_last: bytes
+    delta_last_p: int
+    best_laptime: bytes
+    ideal_laptime: bytes
+    total_time: bytes
+    is_invalid: bool
+    _fields_ = [
+        ("current_laptime", (c_char * 15)),
+        ("delta_current", (c_char * 15)),
+        ("delta_current_p", c_int32),
+        ("last_laptime", (c_char * 15)),
+        ("delta_last", (c_char * 15)),
+        ("delta_last_p", c_int32),
+        ("best_laptime", (c_char * 15)),
+        ("ideal_laptime", (c_char * 15)),
+        ("total_time", (c_char * 15)),
+        ("is_invalid", c_bool),
+        ("place_holder", (c_char * 137)),
+    ]
+
+
+class SMEvoAssistsState(LittleEndianStructure):
+    _layout_ = "ms"
+    _pack_ = 4
+    auto_gear: int
+    auto_blip: int
+    auto_clutch: int
+    auto_clutch_on_start: int
+    manual_ignition_e_start: int
+    auto_pit_limiter: int
+    standing_start_assist: int
+    auto_steer: float
+    arcade_stability_control: float
+    _fields_ = [
+        ("auto_gear", c_uint8),
+        ("auto_blip", c_uint8),
+        ("auto_clutch", c_uint8),
+        ("auto_clutch_on_start", c_uint8),
+        ("manual_ignition_e_start", c_uint8),
+        ("auto_pit_limiter", c_uint8),
+        ("standing_start_assist", c_uint8),
+        ("auto_steer", c_float),
+        ("arcade_stability_control", c_float),
+        ("place_holder", (c_char * 48)),
+    ]
+
+
+class GraphicsPage(LittleEndianStructure):
+    _layout_ = "ms"
+    _pack_ = 4
+
+    packetId: int
+    status: int
+    focused_car_id_a: int
+    focused_car_id_b: int
+    player_car_id_a: int
+    player_car_id_b: int
+    rpm: int
+    is_rpm_limiter_on: bool
+    is_change_up_rpm: bool
+    is_change_down_rpm: bool
+    tc_active: bool
+    abs_active: bool
+    esc_active: bool
+    launch_active: bool
+    is_ignition_on: bool
+    is_engine_running: bool
+    kers_is_charging: bool
+    is_wrong_way: bool
+    is_drs_available: bool
+    battery_is_charging: bool
+    is_max_kj_per_lap_reached: bool
+    is_max_charge_kj_per_lap_reached: bool
+    display_speed_kmh: int
+    display_speed_mph: int
+    display_speed_ms: int
+    pitspeeding_delta: float
+    gear_int: int
+    rpm_percent: float
+    gas_percent: float
+    brake_percent: float
+    handbrake_percent: float
+    clutch_percent: float
+    steering_percent: float
+    ffb_strength: float
+    car_ffb_mupliplier: float
+    water_temperature_percent: float
+    water_pressure_bar: float
+    fuel_pressure_bar: float
+    water_temperature_c: int
+    air_temperature_c: int
+    oil_temperature_c: float
+    oil_pressure_bar: float
+    exhaust_temperature_c: float
+    g_forces_x: float
+    g_forces_y: float
+    g_forces_z: float
+    turbo_boost: float
+    turbo_boost_level: float
+    turbo_boost_perc: float
+    steer_degrees: int
+    current_km: float
+    total_km: int
+    total_driving_time_s: int
+    time_of_day_hours: int
+    time_of_day_minutes: int
+    time_of_day_seconds: int
+    delta_time_ms: int
+    current_lap_time_ms: int
+    predicted_lap_time_ms: int
+    fuel_liter_current_quantity: float
+    fuel_liter_current_quantity_percent: float
+    fuel_liter_per_km: float
+    km_per_fuel_liter: float
+    current_torque: float
+    current_bhp: int
+    tyre_lf: SMEvoTyreState
+    tyre_rf: SMEvoTyreState
+    tyre_lr: SMEvoTyreState
+    tyre_rr: SMEvoTyreState
+    npos: float
+    kers_charge_perc: float
+    kers_current_perc: float
+    control_lock_time: float
+    car_damage: SMEvoDamageState
+    car_location: int
+    pit_info: SMEvoPitInfo
+    fuel_liter_used: float
+    fuel_liter_per_lap: float
+    laps_possible_with_fuel: float
+    battery_temperature: float
+    battery_voltage: float
+    instantaneous_fuel_liter_per_km: float
+    instantaneous_km_per_fuel_liter: float
+    gear_rpm_window: float
+    instrumentation: SMEvoInstrumentation
+    instrumentation_min_limit: SMEvoInstrumentation
+    instrumentation_max_limit: SMEvoInstrumentation
+    electronics: SMEvoElectronics
+    electronics_min_limit: SMEvoElectronics
+    electronics_max_limit: SMEvoElectronics
+    electronics_is_modifiable: SMEvoElectronics
+    total_lap_count: int
+    current_pos: int
+    total_drivers: int
+    last_laptime_ms: int
+    best_laptime_ms: int
+    flag: int
+    global_flag: int
+    max_gears: int
+    engine_type: int
+    has_kers: bool
+    is_last_lap: bool
+    performance_mode_name: bytes
+    diff_coast_raw_value: float
+    diff_power_raw_value: float
+    race_cut_gained_time_ms: int
+    distance_to_deadline: int
+    race_cut_current_delta: float
+    session_state: SMEvoSessionState
+    timing_state: SMEvoTimingState
+    player_ping: int
+    player_latency: int
+    player_cpu_usage: int
+    player_cpu_usage_avg: int
+    player_qos: int
+    player_qos_avg: int
+    player_fps: int
+    player_fps_avg: int
+    driver_name: bytes
+    driver_surname: bytes
+    car_model: bytes
+    is_in_pit_box: bool
+    is_in_pit_lane: bool
+    is_valid_lap: bool
+    car_coordinates: FloatMatrix
+    gap_ahead: float
+    gap_behind: float
+    active_cars: int
+    fuel_per_lap: float
+    fuel_estimated_laps: float
+    assists_state: SMEvoAssistsState
+    max_fuel: float
+    max_turbo_boost: float
+    use_single_compound: bool
+    car_ids: Sequence[Sequence[int]]
+
+    _fields_ = [
+        ("packetId", c_int32),
+        ("status", c_int32),
+        ("focused_car_id_a", c_uint64),
+        ("focused_car_id_b", c_uint64),
+        ("player_car_id_a", c_uint64),
+        ("player_car_id_b", c_uint64),
+        ("rpm", c_uint16),
+        ("is_rpm_limiter_on", c_bool),
+        ("is_change_up_rpm", c_bool),
+        ("is_change_down_rpm", c_bool),
+        ("tc_active", c_bool),
+        ("abs_active", c_bool),
+        ("esc_active", c_bool),
+        ("launch_active", c_bool),
+        ("is_ignition_on", c_bool),
+        ("is_engine_running", c_bool),
+        ("kers_is_charging", c_bool),
+        ("is_wrong_way", c_bool),
+        ("is_drs_available", c_bool),
+        ("battery_is_charging", c_bool),
+        ("is_max_kj_per_lap_reached", c_bool),
+        ("is_max_charge_kj_per_lap_reached", c_bool),
+        ("display_speed_kmh", c_int16),
+        ("display_speed_mph", c_int16),
+        ("display_speed_ms", c_int16),
+        ("pitspeeding_delta", c_float),
+        ("gear_int", c_int16),
+        ("rpm_percent", c_float),
+        ("gas_percent", c_float),
+        ("brake_percent", c_float),
+        ("handbrake_percent", c_float),
+        ("clutch_percent", c_float),
+        ("steering_percent", c_float),
+        ("ffb_strength", c_float),
+        ("car_ffb_mupliplier", c_float),
+        ("water_temperature_percent", c_float),
+        ("water_pressure_bar", c_float),
+        ("fuel_pressure_bar", c_float),
+        ("water_temperature_c", c_int8),
+        ("air_temperature_c", c_int8),
+        ("oil_temperature_c", c_float),
+        ("oil_pressure_bar", c_float),
+        ("exhaust_temperature_c", c_float),
+        ("g_forces_x", c_float),
+        ("g_forces_y", c_float),
+        ("g_forces_z", c_float),
+        ("turbo_boost", c_float),
+        ("turbo_boost_level", c_float),
+        ("turbo_boost_perc", c_float),
+        ("steer_degrees", c_int32),
+        ("current_km", c_float),
+        ("total_km", c_uint32),
+        ("total_driving_time_s", c_uint32),
+        ("time_of_day_hours", c_int32),
+        ("time_of_day_minutes", c_int32),
+        ("time_of_day_seconds", c_int32),
+        ("delta_time_ms", c_int32),
+        ("current_lap_time_ms", c_int32),
+        ("predicted_lap_time_ms", c_int32),
+        ("fuel_liter_current_quantity", c_float),
+        ("fuel_liter_current_quantity_percent", c_float),
+        ("fuel_liter_per_km", c_float),
+        ("km_per_fuel_liter", c_float),
+        ("current_torque", c_float),
+        ("current_bhp", c_int32),
+        ("tyre_lf", SMEvoTyreState),
+        ("tyre_rf", SMEvoTyreState),
+        ("tyre_lr", SMEvoTyreState),
+        ("tyre_rr", SMEvoTyreState),
+        ("npos", c_float),
+        ("kers_charge_perc", c_float),
+        ("kers_current_perc", c_float),
+        ("control_lock_time", c_float),
+        ("car_damage", SMEvoDamageState),
+        ("car_location", c_int32),
+        ("pit_info", SMEvoPitInfo),
+        ("fuel_liter_used", c_float),
+        ("fuel_liter_per_lap", c_float),
+        ("laps_possible_with_fuel", c_float),
+        ("battery_temperature", c_float),
+        ("battery_voltage", c_float),
+        ("instantaneous_fuel_liter_per_km", c_float),
+        ("instantaneous_km_per_fuel_liter", c_float),
+        ("gear_rpm_window", c_float),
+        ("instrumentation", SMEvoInstrumentation),
+        ("instrumentation_min_limit", SMEvoInstrumentation),
+        ("instrumentation_max_limit", SMEvoInstrumentation),
+        ("electronics", SMEvoElectronics),
+        ("electronics_min_limit", SMEvoElectronics),
+        ("electronics_max_limit", SMEvoElectronics),
+        ("electronics_is_modifiable", SMEvoElectronics),
+        ("total_lap_count", c_int32),
+        ("current_pos", c_uint32),
+        ("total_drivers", c_uint32),
+        ("last_laptime_ms", c_int32),
+        ("best_laptime_ms", c_int32),
+        ("flag", c_int32),
+        ("global_flag", c_int32),
+        ("max_gears", c_uint32),
+        ("engine_type", c_int32),
+        ("has_kers", c_bool),
+        ("is_last_lap", c_bool),
+        ("performance_mode_name", (c_char * 33)),
+        ("diff_coast_raw_value", c_float),
+        ("diff_power_raw_value", c_float),
+        ("race_cut_gained_time_ms", c_int32),
+        ("distance_to_deadline", c_int32),
+        ("race_cut_current_delta", c_float),
+        ("session_state", SMEvoSessionState),
+        ("timing_state", SMEvoTimingState),
+        ("player_ping", c_int32),
+        ("player_latency", c_int32),
+        ("player_cpu_usage", c_int32),
+        ("player_cpu_usage_avg", c_int32),
+        ("player_qos", c_int32),
+        ("player_qos_avg", c_int32),
+        ("player_fps", c_int32),
+        ("player_fps_avg", c_int32),
+        ("driver_name", (c_char * 33)),
+        ("driver_surname", (c_char * 33)),
+        ("car_model", (c_char * 33)),
+        ("is_in_pit_box", c_bool),
+        ("is_in_pit_lane", c_bool),
+        ("is_valid_lap", c_bool),
+        ("car_coordinates", ((c_float * 3) * 60)),
+        ("gap_ahead", c_float),
+        ("gap_behind", c_float),
+        ("active_cars", c_uint8),
+        ("fuel_per_lap", c_float),
+        ("fuel_estimated_laps", c_float),
+        ("assists_state", SMEvoAssistsState),
+        ("max_fuel", c_float),
+        ("max_turbo_boost", c_float),
+        ("use_single_compound", c_bool),
+        ("car_ids", ((c_uint64 * 2) * 60)),
+    ]
+
+
+assert sizeof(SMEvoTyreState) == 256, "SMEvoTyreState differs from the EVO ABI"
+assert sizeof(SMEvoDamageState) == 128, "SMEvoDamageState differs from the EVO ABI"
+assert sizeof(SMEvoPitInfo) == 64, "SMEvoPitInfo differs from the EVO ABI"
+assert sizeof(SMEvoElectronics) == 128, "SMEvoElectronics differs from the EVO ABI"
+assert sizeof(SMEvoInstrumentation) == 128, (
+    "SMEvoInstrumentation differs from the EVO ABI"
+)
+assert sizeof(SMEvoSessionState) == 256, "SMEvoSessionState differs from the EVO ABI"
+assert sizeof(SMEvoTimingState) == 256, "SMEvoTimingState differs from the EVO ABI"
+assert sizeof(SMEvoAssistsState) == 64, "SMEvoAssistsState differs from the EVO ABI"
+assert sizeof(GraphicsPage) == 4900, (
+    "GraphicsPage differs from the EVO ABI"
+)

py_acevo-0.0.1/acevo/models/physics.py

@@ -0,0 +1,193 @@
+from ctypes import (
+    LittleEndianStructure,
+    sizeof,
+    c_float,
+    c_int32,
+)
+from collections.abc import Sequence
+
+
+FloatArray = Sequence[float]
+FloatMatrix = Sequence[FloatArray]
+
+
+class PhysicsPage(LittleEndianStructure):
+    _layout_ = "ms"
+    _pack_ = 4
+
+    packetId: int
+    gas: float
+    brake: float
+    fuel: float
+    gear: int
+    rpms: int
+    steerAngle: float
+    speedKmh: float
+    velocity: FloatArray
+    accG: FloatArray
+    wheelSlip: FloatArray
+    wheelLoad: FloatArray
+    wheelsPressure: FloatArray
+    wheelAngularSpeed: FloatArray
+    tyreWear: FloatArray
+    tyreDirtyLevel: FloatArray
+    tyreCoreTemperature: FloatArray
+    camberRAD: FloatArray
+    suspensionTravel: FloatArray
+    drs: float
+    tc: float
+    heading: float
+    pitch: float
+    roll: float
+    cgHeight: float
+    carDamage: FloatArray
+    numberOfTyresOut: int
+    pitLimiterOn: int
+    abs: float
+    kersCharge: float
+    kersInput: float
+    autoShifterOn: int
+    rideHeight: FloatArray
+    turboBoost: float
+    ballast: float
+    airDensity: float
+    airTemp: float
+    roadTemp: float
+    localAngularVel: FloatArray
+    finalFF: float
+    performanceMeter: float
+    engineBrake: int
+    ersRecoveryLevel: int
+    ersPowerLevel: int
+    ersHeatCharging: int
+    ersIsCharging: int
+    kersCurrentKJ: float
+    drsAvailable: int
+    drsEnabled: int
+    brakeTemp: FloatArray
+    clutch: float
+    tyreTempI: FloatArray
+    tyreTempM: FloatArray
+    tyreTempO: FloatArray
+    isAIControlled: int
+    tyreContactPoint: FloatMatrix
+    tyreContactNormal: FloatMatrix
+    tyreContactHeading: FloatMatrix
+    brakeBias: float
+    localVelocity: FloatArray
+    P2PActivations: int
+    P2PStatus: int
+    currentMaxRpm: int
+    mz: FloatArray
+    fx: FloatArray
+    fy: FloatArray
+    slipRatio: FloatArray
+    slipAngle: FloatArray
+    tcinAction: int
+    absInAction: int
+    suspensionDamage: FloatArray
+    tyreTemp: FloatArray
+    waterTemp: float
+    brakeTorque: FloatArray
+    frontBrakeCompound: int
+    rearBrakeCompound: int
+    padLife: FloatArray
+    discLife: FloatArray
+    ignitionOn: int
+    starterEngineOn: int
+    isEngineRunning: int
+    kerbVibration: float
+    slipVibrations: float
+    roadVibrations: float
+    absVibrations: float
+
+    _fields_ = [
+        ("packetId", c_int32),
+        ("gas", c_float),
+        ("brake", c_float),
+        ("fuel", c_float),
+        ("gear", c_int32),
+        ("rpms", c_int32),
+        ("steerAngle", c_float),
+        ("speedKmh", c_float),
+        ("velocity", (c_float * 3)),
+        ("accG", (c_float * 3)),
+        ("wheelSlip", (c_float * 4)),
+        ("wheelLoad", (c_float * 4)),
+        ("wheelsPressure", (c_float * 4)),
+        ("wheelAngularSpeed", (c_float * 4)),
+        ("tyreWear", (c_float * 4)),
+        ("tyreDirtyLevel", (c_float * 4)),
+        ("tyreCoreTemperature", (c_float * 4)),
+        ("camberRAD", (c_float * 4)),
+        ("suspensionTravel", (c_float * 4)),
+        ("drs", c_float),
+        ("tc", c_float),
+        ("heading", c_float),
+        ("pitch", c_float),
+        ("roll", c_float),
+        ("cgHeight", c_float),
+        ("carDamage", (c_float * 5)),
+        ("numberOfTyresOut", c_int32),
+        ("pitLimiterOn", c_int32),
+        ("abs", c_float),
+        ("kersCharge", c_float),
+        ("kersInput", c_float),
+        ("autoShifterOn", c_int32),
+        ("rideHeight", (c_float * 2)),
+        ("turboBoost", c_float),
+        ("ballast", c_float),
+        ("airDensity", c_float),
+        ("airTemp", c_float),
+        ("roadTemp", c_float),
+        ("localAngularVel", (c_float * 3)),
+        ("finalFF", c_float),
+        ("performanceMeter", c_float),
+        ("engineBrake", c_int32),
+        ("ersRecoveryLevel", c_int32),
+        ("ersPowerLevel", c_int32),
+        ("ersHeatCharging", c_int32),
+        ("ersIsCharging", c_int32),
+        ("kersCurrentKJ", c_float),
+        ("drsAvailable", c_int32),
+        ("drsEnabled", c_int32),
+        ("brakeTemp", (c_float * 4)),
+        ("clutch", c_float),
+        ("tyreTempI", (c_float * 4)),
+        ("tyreTempM", (c_float * 4)),
+        ("tyreTempO", (c_float * 4)),
+        ("isAIControlled", c_int32),
+        ("tyreContactPoint", ((c_float * 3) * 4)),
+        ("tyreContactNormal", ((c_float * 3) * 4)),
+        ("tyreContactHeading", ((c_float * 3) * 4)),
+        ("brakeBias", c_float),
+        ("localVelocity", (c_float * 3)),
+        ("P2PActivations", c_int32),
+        ("P2PStatus", c_int32),
+        ("currentMaxRpm", c_int32),
+        ("mz", (c_float * 4)),
+        ("fx", (c_float * 4)),
+        ("fy", (c_float * 4)),
+        ("slipRatio", (c_float * 4)),
+        ("slipAngle", (c_float * 4)),
+        ("tcinAction", c_int32),
+        ("absInAction", c_int32),
+        ("suspensionDamage", (c_float * 4)),
+        ("tyreTemp", (c_float * 4)),
+        ("waterTemp", c_float),
+        ("brakeTorque", (c_float * 4)),
+        ("frontBrakeCompound", c_int32),
+        ("rearBrakeCompound", c_int32),
+        ("padLife", (c_float * 4)),
+        ("discLife", (c_float * 4)),
+        ("ignitionOn", c_int32),
+        ("starterEngineOn", c_int32),
+        ("isEngineRunning", c_int32),
+        ("kerbVibration", c_float),
+        ("slipVibrations", c_float),
+        ("roadVibrations", c_float),
+        ("absVibrations", c_float),
+    ]
+
+
+assert sizeof(PhysicsPage) == 800, "PhysicsPage differs from the EVO ABI"

py_acevo-0.0.1/acevo/models/static.py

@@ -0,0 +1,59 @@
+from ctypes import (
+    LittleEndianStructure,
+    sizeof,
+    c_bool,
+    c_char,
+    c_float,
+    c_int32,
+    c_uint8,
+)
+
+
+class StaticPage(LittleEndianStructure):
+    _layout_ = "ms"
+    _pack_ = 4
+
+    sm_version: bytes
+    ac_evo_version: bytes
+    session: int
+    session_name: bytes
+    event_id: int
+    session_id: int
+    starting_grip: int
+    starting_ambient_temperature_c: float
+    starting_ground_temperature_c: float
+    is_static_weather: bool
+    is_timed_race: bool
+    is_online: bool
+    number_of_sessions: int
+    nation: bytes
+    longitude: float
+    latitude: float
+    track: bytes
+    track_configuration: bytes
+    track_length_m: float
+
+    _fields_ = [
+        ("sm_version", (c_char * 15)),
+        ("ac_evo_version", (c_char * 15)),
+        ("session", c_int32),
+        ("session_name", (c_char * 33)),
+        ("event_id", c_uint8),
+        ("session_id", c_uint8),
+        ("starting_grip", c_int32),
+        ("starting_ambient_temperature_c", c_float),
+        ("starting_ground_temperature_c", c_float),
+        ("is_static_weather", c_bool),
+        ("is_timed_race", c_bool),
+        ("is_online", c_bool),
+        ("number_of_sessions", c_int32),
+        ("nation", (c_char * 33)),
+        ("longitude", c_float),
+        ("latitude", c_float),
+        ("track", (c_char * 33)),
+        ("track_configuration", (c_char * 33)),
+        ("track_length_m", c_float),
+    ]
+
+
+assert sizeof(StaticPage) == 208, "StaticPage differs from the EVO ABI"

py_acevo-0.0.1/acevo/reader.py

@@ -0,0 +1,76 @@
+import ctypes
+from ctypes import wintypes
+from typing import TypeVar
+
+from .models.graphics import GraphicsPage
+from .models.physics import PhysicsPage
+from .models.static import StaticPage
+
+
+Page = TypeVar("Page", bound=ctypes.Structure)
+
+
+class Reader:
+    """Read Assetto Corsa EVO shared-memory telemetry on Windows."""
+
+    def __init__(self) -> None:
+        self.kernel32 = kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+        kernel32.OpenFileMappingW.argtypes = (
+            wintypes.DWORD,
+            wintypes.BOOL,
+            wintypes.LPCWSTR,
+        )
+        kernel32.OpenFileMappingW.restype = wintypes.HANDLE
+        kernel32.MapViewOfFile.argtypes = (
+            wintypes.HANDLE,
+            wintypes.DWORD,
+            wintypes.DWORD,
+            wintypes.DWORD,
+            ctypes.c_size_t,
+        )
+        kernel32.MapViewOfFile.restype = ctypes.c_void_p
+        kernel32.UnmapViewOfFile.argtypes = (ctypes.c_void_p,)
+        kernel32.UnmapViewOfFile.restype = wintypes.BOOL
+        kernel32.CloseHandle.argtypes = (wintypes.HANDLE,)
+        kernel32.CloseHandle.restype = wintypes.BOOL
+
+    def read_static(self) -> StaticPage:
+        """Return validated session metadata; refresh when a new session loads."""
+        metadata = self._read_page("Local\\acevo_pmf_static", StaticPage)
+        if metadata.sm_version != b"1.0":
+            raise ValueError(
+                f"Unsupported EVO shared-memory API {metadata.sm_version!r}; expected b'1.0'."
+            )
+
+        return metadata
+
+    def read_physics(self) -> PhysicsPage:
+        """Return a copied physics page; call read_static first to validate the API."""
+        return self._read_page("Local\\acevo_pmf_physics", PhysicsPage)
+
+    def read_graphics(self) -> GraphicsPage:
+        """Return a copied graphics page; call read_static first to validate the API."""
+        return self._read_page("Local\\acevo_pmf_graphics", GraphicsPage)
+
+    def _read_page(self, name: str, page_type: type[Page]) -> Page:
+        kernel32 = self.kernel32
+        handle = kernel32.OpenFileMappingW(4, False, name)
+        if not handle:
+            error = ctypes.get_last_error()
+            if error == 2:
+                message = "The Assetto Corsa Evo shared memory is unavailable. Start a driving session."
+                raise FileNotFoundError(message)
+            raise ctypes.WinError(ctypes.get_last_error())
+
+        try:
+            # Use the read-only handle directly; mmap reopens the named mapping.
+            size = ctypes.sizeof(page_type)
+            address = kernel32.MapViewOfFile(handle, 4, 0, 0, size)
+            if not address:
+                raise ctypes.WinError(ctypes.get_last_error())
+            try:
+                return page_type.from_buffer_copy(ctypes.string_at(address, size))
+            finally:
+                kernel32.UnmapViewOfFile(address)
+        finally:
+            kernel32.CloseHandle(handle)

py_acevo-0.0.1/py_acevo.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: py-acevo
+Version: 0.0.1
+Summary: Read Assetto Corsa EVO shared memory on Windows.
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# py-acevo
+
+The Python library to read shared memory of Assetto Corsa Evo.

py_acevo-0.0.1/py_acevo.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.MD
+VERSION
+pyproject.toml
+acevo/__init__.py
+acevo/reader.py
+acevo/models/__init__.py
+acevo/models/enums.py
+acevo/models/graphics.py
+acevo/models/physics.py
+acevo/models/static.py
+py_acevo.egg-info/PKG-INFO
+py_acevo.egg-info/SOURCES.txt
+py_acevo.egg-info/dependency_links.txt
+py_acevo.egg-info/top_level.txt

py_acevo-0.0.1/py_acevo.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py_acevo-0.0.1/py_acevo.egg-info/top_level.txt

@@ -0,0 +1 @@
+acevo

py_acevo-0.0.1/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "py-acevo"
+dynamic = ["version"]
+description = "Read Assetto Corsa EVO shared memory on Windows."
+readme = "README.MD"
+requires-python = ">= 3.9"
+classifiers = ["Operating System :: Microsoft :: Windows"]
+
+[tool.setuptools.packages.find]
+include = ["acevo*"]
+
+[tool.setuptools.dynamic]
+version = { file = ["VERSION"] }

py_acevo-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+