llm_coding.py

# import requests
# import urllib3
# import json
# from utils import geoutil
# import regex_spatial
# from shapely.geometry import Polygon, MultiPoint, LineString, Point, mapping
# import re
# import geopandas as gpd
# from geocoder import geo_level1
# from openai import OpenAI
# import numpy as np
#
# client = OpenAI(
#     api_key='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'
# )
#
#
# model = "gpt-4o"
#
# north = ["north", "N'", "North", "NORTH"]
# south = ["south", "S'", "South", "SOUTH"]
# east = ["east", "E'", "East", "EAST"]
# west = ["west", "W'", "West", "WEST"]
# northeast = ["north-east", "NE'", "north east", "NORTH-EAST", "North East", "NORTH EAST"]
# southeast = ["south-east", "SE'", "south east", "SOUTH-EAST", "South East", "SOUTH EAST"]
# northwest = ["north-west", "NW'", "north west", "NORTH-WEST", "North West", "NORTH WEST"]
# southwest = ["south-west", "SW'", "south west", "SOUTH-WEST", "South West", "SOUTH WEST"]
# center = ["center","central", "downtown","midtown"]
# #
# #
# # def get_directional_coordinates(coordinates, direction, centroid, minimum, maximum, is_midmid):
# #     direction_coordinates = get_directional_coordinates_by_angle(coordinates, direction, minimum, maximum)
# #     midmid1, midmid2 = geoutil.get_midmid_point(centroid, direction_coordinates[0], direction_coordinates[-1],
# #                                                 is_midmid)
# #     if direction in west:
# #         maxi = max(p[2] for p in direction_coordinates)
# #         mini = min(p[2] for p in direction_coordinates)
# #         index_mini = 0
# #         index_maxi = 0
# #         for idx, p in enumerate(direction_coordinates):
# #             if p[2] == mini:
# #                 index_mini = idx
# #             if p[2] == maxi:
# #                 index_maxi = idx
# #
# #         direction_coordinates.insert(index_maxi + 1, midmid2)
# #         direction_coordinates.insert(index_mini + 1, midmid1)
# #     else:
# #         direction_coordinates.append(midmid2)
# #         direction_coordinates.append(midmid1)
# #
# #     return direction_coordinates, midmid1, midmid2
# #
# #
# # def get_directional_coordinates_by_angle(coordinates, direction, minimum, maximum):
# #     direction_coordinates = []
# #     for p in coordinates:
# #         if direction in east:
# #             if p[2] >= minimum or p[2] <= maximum:
# #                 direction_coordinates.append(p)
# #
# #         else:
# #             if p[2] >= minimum and p[2] <= maximum:
# #                 direction_coordinates.append(p)
# #     return direction_coordinates
# #
# #
# # def get_directional_coordinates_by_angle(coordinates, direction, minimum, maximum):
# #     direction_coordinates = []
# #     for p in coordinates:
# #         if direction in east:
# #             if p[2] >= minimum or p[2] <= maximum:
# #                 direction_coordinates.append(p)
# #
# #         else:
# #             if p[2] >= minimum and p[2] <= maximum:
# #                 direction_coordinates.append(p)
# #     return direction_coordinates
# #
# #
# # def get_central(coordinates, centroid, direction, is_midmid):
# #     n_min_max = get_min_max("north")
# #     n_coordinates = get_directional_coordinates_by_angle(coordinates, "north", n_min_max[0], n_min_max[1])
# #     n_mid1, n_mid2 = geoutil.get_midmid_point(centroid, n_coordinates[0], n_coordinates[-1], is_midmid)
# #
# #     ne_min_max = get_min_max("north east")
# #     ne_coordinates = get_directional_coordinates_by_angle(coordinates, "north east", ne_min_max[0], ne_min_max[1])
# #     ne_mid1, ne_mid2 = geoutil.get_midmid_point(centroid, ne_coordinates[0], ne_coordinates[-1], is_midmid)
# #
# #     e_min_max = get_min_max("east")
# #     e_coordinates = get_directional_coordinates_by_angle(coordinates, "east", e_min_max[0], e_min_max[1])
# #     e_mid1, e_mid2 = geoutil.get_midmid_point(centroid, e_coordinates[0], e_coordinates[-1], is_midmid)
# #
# #     se_min_max = get_min_max("south east")
# #     se_coordinates = get_directional_coordinates_by_angle(coordinates, "south east", se_min_max[0], se_min_max[1])
# #     se_mid1, se_mid2 = geoutil.get_midmid_point(centroid, se_coordinates[0], se_coordinates[-1], is_midmid)
# #
# #     s_min_max = get_min_max("south")
# #     s_coordinates = get_directional_coordinates_by_angle(coordinates, "south", s_min_max[0], s_min_max[1])
# #     s_mid1, s_mid2 = geoutil.get_midmid_point(centroid, s_coordinates[0], s_coordinates[-1], is_midmid)
# #
# #     sw_min_max = get_min_max("south west")
# #     sw_coordinates = get_directional_coordinates_by_angle(coordinates, "south west", sw_min_max[0], sw_min_max[1])
# #     sw_mid1, sw_mid2 = geoutil.get_midmid_point(centroid, sw_coordinates[0], sw_coordinates[-1], is_midmid)
# #
# #     w_min_max = get_min_max("west")
# #     w_coordinates = get_directional_coordinates_by_angle(coordinates, "west", w_min_max[0], w_min_max[1])
# #     w_mid1, w_mid2 = geoutil.get_midmid_point(centroid, w_coordinates[0], w_coordinates[-1], is_midmid)
# #
# #     nw_min_max = get_min_max("north west")
# #     nw_coordinates = get_directional_coordinates_by_angle(coordinates, "north west", nw_min_max[0], nw_min_max[1])
# #     nw_mid1, nw_mid2 = geoutil.get_midmid_point(centroid, nw_coordinates[0], nw_coordinates[-1], is_midmid)
# #
# #     central_coordindates = [e_mid1, e_mid2, ne_mid1, ne_mid2, n_mid1, n_mid2,
# #                             nw_mid1, nw_mid2, w_mid1, w_mid2, sw_mid1, sw_mid2,
# #                             s_mid1, s_mid2, se_mid1, se_mid2]
# #     return central_coordindates
# #
# #
# # def get_min_max(direction):
# #     regex = regex_spatial.get_directional_regex()
# #     direction_list = regex.split("|")
# #     if direction in direction_list:
# #         if direction in east:
# #             return (337, 22)
# #         if direction in northeast:
# #             return (22, 67)
# #         if direction in north:
# #             return (67, 112)
# #         if direction in northwest:
# #             return (112, 157)
# #         if direction in west:
# #             return (157, 202)
# #         if direction in southwest:
# #             return (202, 247)
# #         if direction in south:
# #             return (247, 292)
# #         if direction in southeast:
# #             return (292, 337)
# #
# #     return None
# # def get_level1_coordinates(coordinates, centroid, direction, is_midmid):
# #     min_max = get_min_max(direction)
# #     if min_max is not None:
# #         coordinates, mid1, mid2 = get_directional_coordinates(coordinates, direction, centroid, min_max[0], min_max[1], is_midmid)
# #         return coordinates, centroid, mid1, mid2
# #     elif direction.lower() in center:
# #         return get_central(coordinates, centroid, direction, is_midmid), centroid, None, None
# #     else:
# #         return coordinates, centroid, None, None
# def to_standard_2d_list(data):
#     arr = np.array(data)
#
#     # 强制变成一维后 reshape，前提是元素总数是2的倍数
#     flat = arr.flatten()
#     if flat.size % 2 != 0:
#         raise ValueError("元素个数不是2的倍数，不能 reshape 成 [N, 2] 格式")
#
#     return flat.reshape(-1, 2).tolist()
#
#
# def get_geojson(ent, arr, centroid):
#     poly_json = {}
#     poly_json['type'] = 'FeatureCollection'
#     poly_json['features'] = []
#     coordinates= []
#     coordinates.append(arr)
#     poly_json['features'].append({
#     'type':'Feature',
#     'id': ent,
#     'properties': {
#         'centroid': centroid
#         },
#     'geometry': {
#         'type':'Polygon',
#         'coordinates': coordinates
#         }
#     })
#     return poly_json
#
#
# def get_coordinates(ent):
#     request_url = 'https://nominatim.openstreetmap.org/search.php?q= ' +ent +'&polygon_geojson=1&accept-language=en&format=jsonv2'
#     headers = {
#         "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15"
#     }
#     page = requests.get(request_url, headers=headers, verify=False)
#     json_content = json.loads(page.content)
#     all_coordinates = json_content[0]['geojson']['coordinates'][0]
#     centroid = (float(json_content[0]['lon']), float(json_content[0]['lat']))
#     for p in all_coordinates:
#         p2 = (p[0], p[1])
#         angle = geoutil.calculate_bearing(centroid, p2)
#         p.append(angle)
#
#     geojson = get_geojson(ent, all_coordinates, centroid)
#
#     return geojson['features'][0]['geometry']['coordinates'][0], geojson['features'][0]['properties']['centroid']
#
# # def geojson(ent):
# #     request_url = 'https://nominatim.openstreetmap.org/search.php?q= ' +ent +'&polygon_geojson=1&accept-language=en&format=jsonv2'
# #     headers = {
# #         "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15"
# #     }
# #     page = requests.get(request_url, headers=headers, verify=False)
# #     json_content = json.loads(page.content)
# #     all_coordinates = json_content[0]['geojson']['coordinates'][0]
# #     centroid = (float(json_content[0]['lon']), float(json_content[0]['lat']))
# #     for p in all_coordinates:
# #         p2 = (p[0], p[1])
# #         angle = geoutil.calculate_bearing(centroid, p2)
# #         p.append(angle)
# #
# #     geojson = get_geojson(ent, all_coordinates, centroid)
# #
# #     return geojson
#
#
# def get_coordinates(location):
#     request_url = f'https://nominatim.openstreetmap.org/search.php?q={location}&polygon_geojson=1&accept-language=en&format=jsonv2'
#
#     print(request_url)
#     headers = {"User-Agent": "Mozilla/5.0"}
#     response = requests.get(request_url, headers=headers, verify=False)
#     json_content = json.loads(response.content)
#     # print(json_content)
#     if json_content[0]['geojson']['type'] == 'Polygon':
#         coordinates = json_content[0]['geojson']['coordinates'][0]
#     elif json_content[0]['geojson']['type'] == 'Point':
#         coordinates = json_content[0]['geojson']['coordinates']
#     else:
#         print(json_content[0]['geojson']['type'])
#     centroid = (float(json_content[0]['lon']), float(json_content[0]['lat']))
#     return (coordinates, centroid)
#
#
# # level3
# def get_directional_coordinates_by_angle(coordinates, centroid, direction, minimum, maximum):
#     # minimum = 157
#     # maximum = 202
#
#     direction_coordinates = []
#     for p in coordinates:
#         angle = geoutil.calculate_bearing(centroid, p)
#         p2 = (p[0], p[1], angle)
#         if direction in geo_level1.east:
#             if angle >= minimum or angle <= maximum:
#                 direction_coordinates.append(p2)
#
#         else:
#             if angle >= minimum and angle <= maximum:
#                 direction_coordinates.append(p2)
#     # print(type(direction_coordinates[0]))
#     # if(direction in geo_level1.west):
#     #    direction_coordinates.sort(key=lambda k: k[2], reverse=True)
#
#     return direction_coordinates
# def get_level3(level3):
#     digits = re.findall('[0-9]+', level3)[0]
#     unit = re.findall('[A-Za-z]+', level3)[0]
#     return digits, unit
#
# def get_direction_coordinates(coordinates, centroid, level1):
#     min_max = geo_level1.get_min_max(level1)
#     if min_max is not None:
#         coord = get_directional_coordinates_by_angle(coordinates, centroid, level1, min_max[0], min_max[1])
#         return coord
#     return coordinates
# def sort_west(poly1, poly2, centroid):
#     coords1 = mapping(poly1)["features"][0]["geometry"]["coordinates"]
#     coords2 = mapping(poly2)["features"][0]["geometry"]["coordinates"]
#     coord1 = []
#     coord2 = []
#     coord = []
#     for c in coords1:
#         pol = list(c[::-1])
#         coord1.extend(pol)
#     for c in coords2:
#         pol = list(c[::-1])
#         coord2.extend(pol)
#     coo1 = []
#     coo2 = []
#     for p in coord1:
#         angle = geoutil.calculate_bearing(centroid, p)
#         if angle >= 157 and angle <= 202:
#             coo1.append((p[0], p[1], angle))
#     for p in coord2:
#         angle = geoutil.calculate_bearing(centroid, p)
#         if angle >= 157 and angle <= 202:
#             coo2.append((p[0], p[1], angle))
#     coo1.extend(coo2)
#     return coo1
#
#
# def get_level3_coordinates(coordinates, level_3, level1):
#     distance, unit = get_level3(level_3)
#     kms = geoutil.get_kilometers(distance, unit)
#     coord = []
#
#     coords0, center = coordinates
#
#     if not isinstance(coords0, list) or len(coords0) < 3:
#
#         # 从原始点出发，根据方向移动距离 kms 得到新圆心
#         lat_km = 111.32
#         lon_km = 111.32 * np.cos(np.radians(center[1]))
#
#         dx = dy = 0
#
#         if level1 is not None:
#             if level1 in geo_level1.east:
#                 dx = kms / lon_km
#             elif level1 in geo_level1.west:
#                 dx = -kms / lon_km
#             elif level1 in geo_level1.north:
#                 dy = kms / lat_km
#             elif level1 in geo_level1.south:
#                 dy = -kms / lat_km
#             # 你也可以支持 northeast、southwest 等复合方向
#
#         new_center = (center[0] + dx, center[1] + dy)
#
#         # 用固定半径画个圆（例如半径2km）
#         r_km = 1  # 半径设为1km，你也可以设为其他值
#
#         circle_points = []
#         for theta in np.linspace(0, 360, num=100):
#             theta_rad = np.radians(theta)
#             d_lat = (np.sin(theta_rad) * r_km) / lat_km
#             d_lon = (np.cos(theta_rad) * r_km) / lon_km
#             circle_points.append((new_center[0] + d_lon, new_center[1] + d_lat))
#
#         # 输出中心（使用新圆心）
#         if circle_points:
#             center_point = MultiPoint(circle_points).centroid
#             center = (center_point.x, center_point.y)
#         else:
#             center = new_center
#
#         return circle_points, center
#
#     # 正常 polygon 流程
#     poly1 = Polygon(coords0)
#     polygon1 = gpd.GeoSeries(poly1)
#
#     # 生成环形区域
#     poly2 = polygon1.buffer(0.0095 * kms, join_style=2)
#     poly3 = polygon1.buffer(0.013 * kms, join_style=2)
#     poly = poly3.difference(poly2)
#
#     # 获取坐标
#     coords = mapping(poly)["features"][0]["geometry"]["coordinates"]
#     for c in coords:
#         pol = list(c[::-1])
#         coord.extend(pol)
#
#     # 方向裁剪
#     if level1 is not None:
#         coord = get_direction_coordinates(coord, coordinates[1], level1)
#         if level1 in geo_level1.west:
#             coord = sort_west(poly3, poly2, coordinates[1])
#
#     # 计算质心
#     if coord:
#         center_point = MultiPoint(coord).centroid
#         center = (center_point.x, center_point.y)
#     else:
#         center = coordinates[1]
#
#     return coord, center
# # level 3 end
#
# # between
# def get_between_coordinates(coordinates1, coordinates2):
#     """
#     计算两个区域之间的中间点，并生成一个等面积的圆形区域。
#     如果某个输入仅为点（坐标长度 < 3），则其面积设为 0；
#     如果两个输入都是点，则默认半径为 2km。
#     :param coordinates1: 第一个区域的边界坐标和中心点
#     :param coordinates2: 第二个区域的边界坐标和中心点
#     :return: 圆形区域的坐标集和圆心
#     """
#
#     def is_valid_polygon(coords):
#         return isinstance(coords, list) and len(coords) >= 3
#
#     coords1, center1 = coordinates1
#     coords2, center2 = coordinates2
#
#     # 判断输入是否为合法多边形（>=3个点）
#     if is_valid_polygon(coords1):
#         poly1 = Polygon(coords1)
#         area1 = poly1.area
#     else:
#         area1 = 0
#
#     if is_valid_polygon(coords2):
#         poly2 = Polygon(coords2)
#         area2 = poly2.area
#     else:
#         area2 = 0
#
#     # 计算中心点（两个中心的中点）
#     midpoint = (
#         (center1[0] + center2[0]) / 2,
#         (center1[1] + center2[1]) / 2
#     )
#
#     # 如果两个区域都是点，则使用默认半径 2km
#     if area1 == 0 and area2 == 0:
#         r_km = 2
#     else:
#         avg_area = (area1 + area2) / 2
#         r_km = np.sqrt(avg_area / np.pi) * 111.32  # 近似 km 半径
#
#     # 经纬度距离换算因子
#     lat_km = 111.32
#     lon_km = 111.32 * np.cos(np.radians(midpoint[1]))
#
#     # 生成圆形区域坐标（100个点）
#     circle_points = []
#     for theta in np.linspace(0, 360, num=100):
#         theta_rad = np.radians(theta)
#         d_lat = (np.sin(theta_rad) * r_km) / lat_km
#         d_lon = (np.cos(theta_rad) * r_km) / lon_km
#         circle_points.append((midpoint[0] + d_lon, midpoint[1] + d_lat))
#
#     return circle_points, midpoint
# # between end
#
#
# def llmapi(text):
#     system_prompt = (
#         "你是一个资深的地理学家，你的任务是通过给定的一段自然语言，来选择正确的定位函数顺序以及他们的输入。\n"
#         "你能选择的定位函数有：\n"
#         "1. 相对定位（Relative Positioning）：输入为地点坐标，方位，距离。输出为距离‘距离’输入的地点坐标的‘方位’的坐标。\n"
#         "2. 中间定位（Between Positioning）：输入为两个地点的坐标，输出为两个地点坐标的中点。\n"
#         "请先进行思维链（CoT）推理，并最终用 JSON 格式输出你的答案，用 `<<<JSON>>>` 和 `<<<END>>>` 包裹起来。\n"
#         "请确保所有输入仅包含：地点名称（字符串）、索引（整数）、方位（字符串，必须是英文）或距离（字符串，带单位），不允许返回诸如 'Chatswood 南4 km的坐标' 这样的内容。\n"
#         "每个步骤编号都有 id 记录，然后如果某个输入是之前步骤的输出，那么输入对应步骤的 id。\n"
#         "所有方向必须使用英文（如 south, west, northeast, etc.）。\n"
#         "示例输出：\n"
#         "<<<JSON>>>\n"
#         "[{\"id\": 1, \"function\": \"Relative\", \"inputs\": [\"Chatswood\", \"south\", \"4 km\"]},"
#         "{\"id\": 2, \"function\": \"Relative\", \"inputs\": [\"North Sydney\", \"west\", \"2 km\"]},"
#         "{\"id\": 3, \"function\": \"Between\", \"inputs\": [1, 2]},"
#         "{\"id\": 4, \"function\": \"Relative\", \"inputs\": [3, \"southwest\", \"5 km\"]}]\n"
#         "<<<END>>>")
#
#     messages = [
#         {"role": "system", "content": system_prompt},
#         {"role": "user", "content": text},
#     ]
#
#     chat_completion = client.chat.completions.create(
#         messages=messages,
#         model=model,
#     )
#
#     result = chat_completion.choices[0].message.content
#     json_match = re.search(r'<<<JSON>>>\n(.*?)\n<<<END>>>', result, re.DOTALL)
#
#     if json_match:
#         # print(json.loads(json_match.group(1)))
#         return json.loads(json_match.group(1))
#     else:
#         raise ValueError("LLM 输出未包含预期的 JSON 格式数据。")
# def llmapi(text):
#     system_prompt = (
#         "You are an experienced geographer. Your task is to determine the correct sequence of positioning functions and their inputs based on a given piece of natural language.\n"
#         "The positioning functions you can choose from are:\n"
#         "1. Relative Positioning: Inputs is (location coordinate or location name, direction, and distance). Outputs the coordinates that are in the given 'direction' and 'distance' from the input location.\n"
#         "2. Between Positioning: Inputs is (location 1 coordinates or location 1 name, location 2 coordinates or location 2 name). Outputs the midpoint coordinate between the two locations.\n"
#         "You can only use the given functions, and the inputs to the functions must obey the above properties. The given functions can be combined to solve complex situations."
#         "First, perform chain-of-thought (CoT) reasoning, and finally output your answer in JSON format, wrapped between `<<<JSON>>>` and `<<<END>>>`.\n"
#         "Make sure all inputs only include: location names (strings), step indices (integers), directions (strings, must be in English), or distances (strings with units). Do not return expressions like 'the coordinate 4 km south of Chatswood'.\n"
#         "Each step must have an 'id'. If the input of a step is the output of a previous step, use that step’s 'id' as the input.\n"
#         "All directions must be in English (e.g., south, west, northeast, etc.).\n"
#         "Example output:\n"
#         "<<<JSON>>>\n"
#         "[{\"id\": 1, \"function\": \"Relative\", \"inputs\": [\"Chatswood\", \"south\", \"4 km\"]},"
#         "{\"id\": 2, \"function\": \"Relative\", \"inputs\": [\"North Sydney\", \"west\", \"2 km\"]},"
#         "{\"id\": 3, \"function\": \"Between\", \"inputs\": [1, 2]},"
#         "{\"id\": 4, \"function\": \"Relative\", \"inputs\": [3, \"southwest\", \"5 km\"]}]\n"
#         "<<<END>>>")
#
#     messages = [
#         {"role": "system", "content": system_prompt},
#         {"role": "user", "content": text},
#     ]
#
#     chat_completion = client.chat.completions.create(
#         messages=messages,
#         model=model,
#     )
#
#     result = chat_completion.choices[0].message.content
#     print(result)
#     json_match = re.search(r'<<<JSON>>>\n(.*?)\n<<<END>>>', result, re.DOTALL)
#
#     if json_match:
#         return json.loads(json_match.group(1))
#     else:
#         raise ValueError("LLM 输出未包含预期的 JSON 格式数据。")
#
#
#
#
#
# def execute_steps(steps):
#     data = {}
#
#     for step in steps:
#         step_id = step['id']
#         function = step['function']
#         inputs = step['inputs']
#         # print('-' * 50)
#         # print(function)
#         # print(inputs)
#
#
#         resolved_inputs = []
#         for inp in inputs:
#             if isinstance(inp, int):
#                 resolved_inputs.append(data[inp])
#             else:
#                 resolved_inputs.append(inp)
#         if function == "Relative":
#             location, direction, distance = resolved_inputs
#             if isinstance(location, str):
#                 location = get_coordinates(location)
#
#             location = [to_standard_2d_list(location[0])] + list(location[1:])
#             location = [[[151.214901,-33.859175]], (151.214901,-33.859175)]
#             result = get_level3_coordinates(location, distance, direction)
#             data[step_id] = result
#
#         elif function == "Between":
#
#
#             location1, location2 = resolved_inputs
#             # print(location1)
#             # print(111)
#             # print(location2)
#             if isinstance(location1, str):
#                 location1 = get_coordinates(location1)
#
#                 location1 = [to_standard_2d_list(location1[0])] + list(location1[1:])
#             if isinstance(location2, str):
#
#                 location2 = get_coordinates(location2)
#                 location2 = [to_standard_2d_list(location2[0])] + list(location2[1:])
#             result = get_between_coordinates(location1, location2)
#
#             data[step_id] = result
#
#     return data
#
#
#
# if __name__ == '__main__':
#     # a = get_coordinates('Burwood')
#     # a2 = get_coordinates('Glebe')
#     # b = get_level3_coordinates(a, '5 km', 'east')
#     # c = get_between_coordinates(a, a2)
#
#     # 完整通道
#     # 默认输入
#     # default_input_text = "在Chatswood南边4公里与North Sydney 东边2公里的中间的西南5公里。"
#     # default_input_text = "你是一位规划师，正在为华盛顿州的一项新森林监测站选址。两个潜在的参考位置分别是雷尼尔山国家公园（Mount Rainier National Park）和北喀斯喀特国家公园（North Cascades National Park）。首先，你想在这两个国家公园之间找到一个中间点。接着，你希望在这个中间点与北喀斯喀特国家公园之间，再取一个中间位置，以便确定最终的建设候选地。"
#     # default_input_text = "在Chatswood和North Sydney的中间靠近North Sydney的四分之一位置"
#     # default_input_text = "Plan a trip that involves determining the midpoint between Paris and London, and then finding another midpoint between this location and Paris to identify potential stopovers during travel."
#     # default_input_text = "5km southwest of Chatswood, 4km south of Chatswood and 2km north of North Sydney."
#
#
#
#     # 解析 LLM 结果
#     # parsed_steps = llmapi(default_input_text)
#     # parsed_steps = [{'id': 1, 'function': 'Relative', 'inputs': ['Chatswood', 'south', '4 km']}, {'id': 2, 'function': 'Relative', 'inputs': ['North Sydney', 'east', '2 km']}, {'id': 3, 'function': 'Between', 'inputs': [1, 2]}, {'id': 4, 'function': 'Relative', 'inputs': [3, 'south west', '5 km']}]
#     # parsed_steps = [{"id": 1, "function": "Between", "inputs": ["Chatswood", "North Sydney"]},{"id": 2, "function": "Between", "inputs": [1, "North Sydney"]}]
#     # parsed_steps = [{"id": 1, "function": "Relative", "inputs": ["Katoomba", "southeast", "3 km"]}, {"id": 2, "function": "Between", "inputs": [1, "Echo Point"]}]
#     # parsed_steps = [{'id': 1, 'function': 'Relative', 'inputs': ['Scafell Pike', 'east', '9 km']}]
#     # parsed_steps = [{'id': 1, 'function': 'Relative', 'inputs': ['Colosseum', 'northeast', '8 km']}, {'id': 2, 'function': 'Relative', 'inputs': [1, 'northeast', '2 km']}]
#     parsed_steps = [
#       {"id": 1, "function": "Between", "inputs": ["Statue of Liberty", "Eiffel Tower"]},
#       {"id": 2, "function": "Relative", "inputs": [1, "west", "8 km"]}
#     ]
#
#     # 执行步骤
#     result = execute_steps(parsed_steps)
#     # 输出最终计算结果
#     print(result)
#     print('-' * 100)
#     print(result[(max(result.keys()))][0])
#     # 通道结束
#
#     # location = get_coordinates('Chatswood')
#     # result = get_level3_coordinates(location, '4 km', 'north west')
#     # print(result)
#
#