""" Register your core engineering functions as DeepSeek Harness tools """ import sys import os sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from typing import Dict, Any, Optional import pandas as pd from core.engineering import ( run_compliance_checks, calculate_lift_value, calculate_slue_value, calculate_cant_value, calculate_twist, check_radius_for_speed, TrackData, NR_LIMITS, compute_track_displacements, ) from core.xml_parser import parse_station_base, parse_geometry_report, alignment_names from core.standards_loader import get_limit, load_standards calculate_lift = calculate_lift_value calculate_slue = calculate_slue_value calculate_cant = calculate_cant_value def run_qa_checks(track_data, limits, track_category="C", design_speed=75.0, track_name=""): track = TrackData( track_no=1, chainages=list(track_data.get("lift", {}).keys()), lifts=track_data.get("lift", {}), slues=track_data.get("slue", {}), ex_cants=track_data.get("ex_cant", {}), pr_cants=track_data.get("pr_cant", {}), ex_levels=track_data.get("ex_low", {}), pr_levels=track_data.get("pr_low", {}), radii=track_data.get("pr_radius", {}), ) return run_compliance_checks(track, limits, track_category, design_speed, track_name) def get_standard_limit(parameter, default=None): return get_limit(parameter, default) def get_alignment_names(df): return alignment_names(df) def compute_displacements(track_data, track_no, chainages): return compute_track_displacements(track_data, track_no, chainages).to_dict() def get_nr_limits(): return NR_LIMITS def register_engineering_tools(harness): """Register all engineering functions as Harness tools""" @harness.tool(name="run_qa_checks", description="Run Network Rail QA compliance checks") def tool_run_qa_checks(track_data: Dict, limits: Dict, track_category: str = "C", design_speed: float = 75.0, track_name: str = "") -> Dict: track = TrackData( track_no=1, chainages=list(track_data.get("lift", {}).keys()), lifts=track_data.get("lift", {}), slues=track_data.get("slue", {}), ex_cants=track_data.get("ex_cant", {}), pr_cants=track_data.get("pr_cant", {}), ex_levels=track_data.get("ex_low", {}), pr_levels=track_data.get("pr_low", {}), radii=track_data.get("pr_radius", {}) ) return run_compliance_checks(track, limits, track_category, design_speed, track_name) @harness.tool(name="calculate_lift", description="Calculate lift/lower in mm") def tool_calculate_lift(existing_level: float, proposed_level: float) -> Optional[float]: return calculate_lift_value(existing_level, proposed_level) @harness.tool(name="calculate_slue", description="Calculate slue/slew in mm") def tool_calculate_slue(existing_offset: float, proposed_offset: float) -> Optional[float]: return calculate_slue_value(existing_offset, proposed_offset) @harness.tool(name="calculate_cant", description="Calculate cant in mm") def tool_calculate_cant(left_level: float, right_level: float) -> Optional[float]: return calculate_cant_value(left_level, right_level) @harness.tool(name="calculate_twist", description="Calculate twist in mm/m") def tool_calculate_twist(level1: float, level2: float, distance_m: float) -> Optional[float]: return calculate_twist(level1, level2, distance_m) @harness.tool(name="check_radius_for_speed", description="Check radius for speed") def tool_check_radius_for_speed(radius_m: float, speed_mph: float, max_cant_def_mm: float = 110.0, applied_cant_mm: float = 0.0) -> tuple: return check_radius_for_speed(radius_m, speed_mph, max_cant_def_mm, applied_cant_mm) @harness.tool(name="get_standard_limit", description="Get limit from NR standards") def tool_get_standard_limit(parameter: str, default: Optional[float] = None) -> Optional[float]: return get_limit(parameter, default) @harness.tool(name="load_standards", description="Load all NR standards") def tool_load_standards() -> Dict: return load_standards() @harness.tool(name="parse_station_base", description="Parse Station Base XML") def tool_parse_station_base(xml_bytes: bytes) -> pd.DataFrame: return parse_station_base(xml_bytes) @harness.tool(name="parse_geometry_report", description="Parse Geometry Report XML") def tool_parse_geometry_report(xml_bytes: bytes) -> tuple: return parse_geometry_report(xml_bytes) @harness.tool(name="get_alignment_names", description="Get alignment names") def tool_get_alignment_names(df: pd.DataFrame) -> list: return alignment_names(df) @harness.tool(name="compute_displacements", description="Compute track displacements") def tool_compute_displacements(track_data: Dict, track_no: int, chainages: list) -> Dict: result = compute_track_displacements(track_data, track_no, chainages) return result.to_dict() @harness.tool(name="get_nr_limits", description="Get default NR limits") def tool_get_nr_limits() -> Dict: return NR_LIMITS print("Engineering tools registered")