Download agent/tools.py from Surajnitp/flowmarg: direct link, hf CLI and curl.
- Browser
- Download file 5.4 kB
-
https://huggingface.co/spaces/Surajnitp/flowmarg/resolve/main/agent/tools.py
- Command line
-
hf download hf://spaces/Surajnitp/flowmarg/agent/tools.py
-
curl -L -o tools.py https://huggingface.co/spaces/Surajnitp/flowmarg/resolve/main/agent/tools.py
5.4 kB
| """ | |
| 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""" | |
| 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) | |
| def tool_calculate_lift(existing_level: float, proposed_level: float) -> Optional[float]: | |
| return calculate_lift_value(existing_level, proposed_level) | |
| def tool_calculate_slue(existing_offset: float, proposed_offset: float) -> Optional[float]: | |
| return calculate_slue_value(existing_offset, proposed_offset) | |
| def tool_calculate_cant(left_level: float, right_level: float) -> Optional[float]: | |
| return calculate_cant_value(left_level, right_level) | |
| def tool_calculate_twist(level1: float, level2: float, distance_m: float) -> Optional[float]: | |
| return calculate_twist(level1, level2, distance_m) | |
| 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) | |
| def tool_get_standard_limit(parameter: str, default: Optional[float] = None) -> Optional[float]: | |
| return get_limit(parameter, default) | |
| def tool_load_standards() -> Dict: | |
| return load_standards() | |
| def tool_parse_station_base(xml_bytes: bytes) -> pd.DataFrame: | |
| return parse_station_base(xml_bytes) | |
| def tool_parse_geometry_report(xml_bytes: bytes) -> tuple: | |
| return parse_geometry_report(xml_bytes) | |
| def tool_get_alignment_names(df: pd.DataFrame) -> list: | |
| return alignment_names(df) | |
| 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() | |
| def tool_get_nr_limits() -> Dict: | |
| return NR_LIMITS | |
| print("Engineering tools registered") | |