Calvin Ng
571 lines
27 KiB
Python
571 lines
27 KiB
Python
import argparse
|
|
from collections import namedtuple
|
|
import configparser
|
|
from dataclasses import dataclass
|
|
import os
|
|
import re
|
|
|
|
"""Endless ATC custom airport file build utility."""
|
|
|
|
|
|
@dataclass
|
|
class Fix:
|
|
"""Simple class to represent a fix."""
|
|
name: str
|
|
lat: str
|
|
lon: str
|
|
heading: str
|
|
pronunciation: str
|
|
|
|
def __init__(self, name, lat, lon, heading, pronunciation):
|
|
self.name = name.strip()
|
|
self.lat = lat.strip()
|
|
self.lon = lon.strip()
|
|
self.heading = heading.strip()
|
|
self.pronunciation = pronunciation.strip()
|
|
|
|
@property
|
|
def short_def(self):
|
|
"""Position definition as string."""
|
|
return f"{self.lat}, {self.lon}"
|
|
|
|
@property
|
|
def minor_def(self):
|
|
"""Definition without holding as string."""
|
|
return f"{self.name}, {self.lat}, {self.lon}, {self.pronunciation}"
|
|
|
|
@property
|
|
def full_def(self):
|
|
"""Full definition as string."""
|
|
return f"{self.name}, {self.lat}, {self.lon}, {self.heading.lstrip('!') or 0}, {self.pronunciation}"
|
|
|
|
|
|
@dataclass
|
|
class Airline:
|
|
"""Simple class to represent an airline declaration."""
|
|
callsign: str
|
|
frequency: int
|
|
types: str
|
|
pronunciation: str
|
|
directions: str
|
|
|
|
callsigns = None
|
|
use_callsigns = True
|
|
test_callsigns = False
|
|
|
|
def __init__(self, callsign, frequency, types, *data, gateways=None):
|
|
"""Create an airline from an entry in the airlines= list. `data` should be
|
|
`(pronunciation, directions)`.
|
|
|
|
If `Airline.callsigns` is defined, `pronunciation` should be omitted from `data`.
|
|
|
|
If `gateways` is provided, `directions` becomes `arrival_gateways`, `departure_gateways`."""
|
|
|
|
self.frequency = int(frequency.strip())
|
|
self.types = types.strip()
|
|
self.callsign = callsign.strip()
|
|
try:
|
|
if Airline.callsigns is not None and (Airline.use_callsigns or Airline.test_callsigns):
|
|
if '-' not in callsign:
|
|
self.pronunciation = Airline.callsigns[callsign]
|
|
else:
|
|
# if length of key is more than 3, assume it is not registration
|
|
key = callsign[:callsign.index('-')]
|
|
self.callsign = callsign.strip('_')
|
|
# if key length is longer than 3 and key doesn't have match,
|
|
# we strip '_' to allow for mil callsigns with length <= 3
|
|
self.pronunciation = Airline.callsigns.get(key, key.strip('_')) if len(key) > 3 \
|
|
else Airline.callsigns.get(key, '0')
|
|
if Airline.test_callsigns:
|
|
print(f'{self.callsign}: {self.pronunciation}')
|
|
if Airline.callsigns is None or not Airline.use_callsigns:
|
|
self.pronunciation = data[0].strip()
|
|
data = data[1:]
|
|
if gateways is not None:
|
|
arrival_gateways = {gateway.strip() for gateway in data[0].split("/")}
|
|
departure_gateways = {gateway.strip() for gateway in data[1].split("/")}
|
|
self.directions = "".join(sorted(
|
|
{gateways[gateway] for gateway in arrival_gateways | departure_gateways}))
|
|
else:
|
|
self.directions = data[0].strip()
|
|
except Exception as e:
|
|
raise ValueError(f"Could not create airline from ({callsign}, {frequency}, {types}, {str(data)})" +
|
|
f"\nCallsign pronunciation lookup = {Airline.use_callsigns}") from e
|
|
|
|
|
|
def process_fix_line(line, fixes):
|
|
"""Expands special commands for a fix definition in short format
|
|
and returns the expanded definition as the result.
|
|
|
|
Substitute "!<name>[, <extra_data>]" in `line` with
|
|
"lat, lon[, <extra_data>]" based on `fixes`.
|
|
|
|
Args:
|
|
`line` (list): A fix definition.
|
|
`fixes` (dict): A lookup of `Fix`es."""
|
|
if line.startswith('!'):
|
|
def_fix, def_sep, def_data = line.lstrip('!').partition(',')
|
|
return fixes[def_fix.strip()].short_def + def_sep + def_data
|
|
else:
|
|
return line
|
|
|
|
|
|
def process_fix_list(fix_list, fixes):
|
|
"""Expands special commands in a list of fixes in short format
|
|
and produces an iterable of definitions as the result.
|
|
|
|
Substitute any "!<name>[, <extra_data>]" in `fix_list` with
|
|
"lat, lon[, <extra_data>]" based on `fixes`.
|
|
|
|
Args:
|
|
`fix_list` (list): A list of fix definitions.
|
|
`fixes` (dict): A lookup of `Fix`es."""
|
|
for line in fix_list:
|
|
yield process_fix_line(line, fixes)
|
|
|
|
|
|
def _process_approach_fix_list(fix_list, fixes, tagged_routes, generated_approaches):
|
|
"""Inner worker function for `process_approach_fix_list()`.
|
|
|
|
Works the same as `process_fix_list`, but in addition, any fix definitions processed
|
|
will be added to any generated approaches in `generated_approaches`. Also, any fixes
|
|
processed will be checked for any approach generator parameters; if found, a new
|
|
generated approach is added to `generated_approaches`. The route of such generated
|
|
approach will also be added to `tagged_routes` if tagged in the fix definition.
|
|
|
|
Args:
|
|
`fix_list` (list): A list of fix definitions.
|
|
`fixes` (dict): A lookup of `Fix`es.
|
|
`tagged_routes` (dict): A lookup of approach routes that were tagged for lookup.
|
|
`generated_approaches`: A list of dicts of parameters to be used to generate
|
|
derived approaches in post-processing."""
|
|
for line in fix_list:
|
|
def_data, _, approach_generator_params = line.rpartition(',')
|
|
if def_data and '!' in approach_generator_params:
|
|
fix_name, _, _ = def_data.partition(',')
|
|
fix_name = fix_name.lstrip('!')
|
|
heading, _, tag = approach_generator_params.lstrip(' !').partition('@')
|
|
route = []
|
|
generated_approach = {"heading": heading, "beacon": fix_name, "route": route}
|
|
generated_approaches.append(generated_approach)
|
|
if tag:
|
|
tagged_routes[tag] = route
|
|
else:
|
|
def_data = line
|
|
result = process_fix_line(def_data, fixes)
|
|
for generated_approach in generated_approaches:
|
|
generated_approach['route'].append(result)
|
|
yield result
|
|
|
|
|
|
def process_approach_fix_list(fix_list, fixes, tagged_routes, generated_approaches, generate_approaches=True):
|
|
"""Processes special commands in a list of departure fixes
|
|
in short format and produces an iterable of definitions as the result.
|
|
|
|
Substitute any "!<name>[, <extra_data>]" in `fix_list` with
|
|
"lat, lon[, <extra_data>]" based on `fixes`.
|
|
|
|
If the last item in `fix_list` is "@<name>", substitute in
|
|
the contents of the approach route tagged <name>.
|
|
|
|
Args:
|
|
`fix_list` (list): A list of fix definitions.
|
|
`fixes` (dict): A lookup of `Fix`es.
|
|
`tagged_routes` (dict): A lookup of approach routes that were tagged for lookup.
|
|
`generated_approaches`: A list of dicts of parameters to be used to generate
|
|
derived approaches in post-processing.
|
|
`generate_approaches`: Whether or not to process any approach generator commands."""
|
|
current_tag = None
|
|
if fix_list:
|
|
if fix_list[0].startswith('@'):
|
|
tagged_route = fix_list[2:]
|
|
if fix_list[0].startswith('@!'):
|
|
tagged_route = tagged_route[1:]
|
|
current_tag = fix_list[0].lstrip('@!')
|
|
tagged_routes[current_tag] = tagged_route
|
|
fix_list = fix_list[1:]
|
|
if fix_list[-1].startswith('@'):
|
|
following_tag = fix_list[-1].lstrip('@')
|
|
if current_tag is not None and current_tag == following_tag:
|
|
raise RuntimeError(
|
|
'''Unable to build as approach tagged as @{tag} is trying to reference itself.
|
|
The following is the route= contents after the @tag: \n{lines}'''
|
|
.format(tag=current_tag, lines="\n".join(fix_list)))
|
|
yield from _process_approach_fix_list(fix_list[:-1], fixes, tagged_routes, generated_approaches)
|
|
yield from process_approach_fix_list(tagged_routes[following_tag], fixes, tagged_routes, generated_approaches, False)
|
|
else:
|
|
yield from _process_approach_fix_list(fix_list, fixes, tagged_routes, generated_approaches)
|
|
|
|
|
|
def process_departure_fix_list(fix_list, fixes, tagged_routes):
|
|
"""Processes special commands in a list of departure fixes
|
|
in short format and produces an iterable of definitions as the result,
|
|
or `None` if there is no result (fix_list was recorded in `tagged_routes`.
|
|
|
|
Substitute any "!<name>[, <extra_data>]" in `fix_list` with
|
|
"lat, lon[, <extra_data>]" based on `fixes`.
|
|
|
|
If and the first item of fix_list is "@<name>",
|
|
record the rest of the `fix_list` in `tagged_routes` under "name".
|
|
|
|
If the second (first if a tagged departure route) item in `fix_list`
|
|
is "@<name>", substitute in the contents of the departure route
|
|
tagged <name>.
|
|
|
|
Args:
|
|
`fix_list` (list): A list of fix definitions.
|
|
`fixes` (dict): A lookup of `Fix`es.
|
|
`tagged_routes` (dict): A lookup of departure routes."""
|
|
if fix_list:
|
|
if fix_list[0].startswith('@'):
|
|
tagged_routes[fix_list[0].lstrip('@')] = fix_list[1:]
|
|
return None
|
|
else:
|
|
return _process_departure_fix_list(fix_list, fixes, tagged_routes)
|
|
|
|
|
|
def _process_departure_fix_list(fix_list, fixes, tagged_routes, top_level=True):
|
|
if fix_list:
|
|
if top_level:
|
|
yield fix_list[0]
|
|
fix_list = fix_list[1:]
|
|
if fix_list[0].startswith('@'):
|
|
yield from _process_departure_fix_list(tagged_routes[fix_list[0].lstrip('@')], fixes, tagged_routes, top_level=False)
|
|
yield from process_fix_list(fix_list[1:], fixes)
|
|
else:
|
|
yield from process_fix_list(fix_list, fixes)
|
|
|
|
|
|
def process_sids_fix_list(fix_list, fixes):
|
|
"""Processes special commands in a list of fixes in minor format
|
|
and produces an iterable of definitions as the result.
|
|
|
|
Substitute any "!<name>[, <extra_data>]" in `fix_list` with
|
|
"lat, lon[, <extra_data>]" based on `fixes`.
|
|
|
|
Args:
|
|
`fix_list` (list): A list of fix definitions.
|
|
`fixes` (dict): A lookup of `Fix`es."""
|
|
for line in fix_list:
|
|
if line.startswith('!'):
|
|
def_fix, def_sep, def_data = line.lstrip('!').partition(',')
|
|
yield fixes[def_fix.strip()].minor_def + def_sep + def_data
|
|
else:
|
|
yield line
|
|
|
|
|
|
def process_repeatable_departure_fix_list(fix_list, fixes, departure_routes):
|
|
"""`Processes special commands in a list of departure fixes
|
|
in short format and produces an iterable of n iterables of
|
|
definitions as the result.
|
|
|
|
If the first item of `fix_list` is *n, n iterables are produced.
|
|
Otherwise, `n = 1`.
|
|
|
|
See `process_departure_fix_list` for further special commands."""
|
|
if not fix_list[0]:
|
|
fix_list = fix_list[1:]
|
|
if fix_list[0].startswith('*'):
|
|
result = list(process_departure_fix_list(fix_list[1:], fixes, departure_routes))
|
|
for i in range(int(fix_list[0].removeprefix('*'))):
|
|
yield result
|
|
else:
|
|
yield process_departure_fix_list(fix_list, fixes, departure_routes)
|
|
|
|
|
|
def process_beacons(fixes):
|
|
"""Returns a generator of [airspace] beacons= lines, while removing any
|
|
beacons with ! as the holding heading."""
|
|
for fix in fixes.values():
|
|
if not fix.heading.startswith("!"):
|
|
yield fix.full_def
|
|
|
|
|
|
def process_airlines_list(airline_list):
|
|
"""Returns generator of airline declaration strings based on the list of `Airline`s `airline_list`.
|
|
|
|
If frequency is greater than 10, write floor(frequency / 10) 10 frequency
|
|
declarations and 1x (frequency mod 10) declaration."""
|
|
for airline in airline_list:
|
|
n, r = divmod(airline.frequency, 10)
|
|
for i in range(n):
|
|
yield f"{airline.callsign}, 10, {airline.types}, {airline.pronunciation}, {airline.directions}"
|
|
if r:
|
|
yield f"{airline.callsign}, {r}, {airline.types}, {airline.pronunciation}, {airline.directions}"
|
|
|
|
|
|
def enumerate_routes(route_list, start=1):
|
|
"""built-in `enumerate()` but the enumeration is a string "route#"."""
|
|
for route in route_list:
|
|
yield f"route{start}", route
|
|
start += 1
|
|
|
|
|
|
def process(args, input_file=None):
|
|
"""Parses an Endless ATC custom airport "source" file and expands certain special commands,
|
|
then rewrites as a minimized output suitable for use by the game.
|
|
|
|
Refer to argparse help for detailed syntax of special commands.
|
|
|
|
Args:
|
|
`args`: An `argparse.Namespace`. The command line args from the invoking module.
|
|
`file`: The file to process. Defaults to `input_file` in `args`."""
|
|
|
|
# if input_file is None, we were invoked standalone and not from deploy.py
|
|
if input_file is None:
|
|
input_file = args.input_file
|
|
output_file = input_file if args.output_file is None else args.output_file
|
|
else:
|
|
output_file = os.path.join(os.path.dirname(input_file), args.output_path, os.path.basename(input_file))
|
|
print(f"Building {input_file} to {output_file}")
|
|
|
|
config = configparser.ConfigParser()
|
|
config.read("common.ini")
|
|
config.read(os.path.join(os.path.dirname(input_file), "common.ini"))
|
|
Airline.callsigns = config['expand.callsigns'] if 'expand.callsigns' in config else {}
|
|
default_gateways = config['expand.gateways'] if 'expand.gateways' in config else {}
|
|
|
|
if 'legacy' not in args or not args.legacy:
|
|
source = configparser.ConfigParser()
|
|
source.read(input_file)
|
|
|
|
# read optional header to be written in output
|
|
header = None
|
|
if 'meta' in source:
|
|
if 'header' in source['meta']:
|
|
header = ["# " + line for line in source['meta']['header'].splitlines()]
|
|
header.extend([
|
|
"",
|
|
f"# This file is generated from the source file {os.path.relpath(input_file, os.path.dirname(output_file))} using expand.py.",
|
|
"# All comments have been stripped, and edits are not made directly to this file.",
|
|
"# If you would like to contribute, or see the author's comments, please refer to the source file.",
|
|
"",
|
|
""])
|
|
header = "\n".join(header)
|
|
if 'callsigns' not in source['meta']:
|
|
Airline.use_callsigns = False
|
|
else:
|
|
Airline.use_callsigns = source['meta'].getboolean('callsigns')
|
|
if args.test_callsigns:
|
|
Airline.test_callsigns = True
|
|
# remove meta section so it won't be written in output
|
|
del source['meta']
|
|
|
|
# build a fix database from [airspace] beacons=
|
|
fixes = {fix.name: fix for fix in (
|
|
Fix(*definition.split(",")) for definition in
|
|
source['airspace']['beacons'].strip().splitlines()
|
|
)}
|
|
|
|
source['airspace']['beacons'] = "\n".join(process_beacons(fixes))
|
|
|
|
source['airspace']['boundary'] = "\n".join(
|
|
process_fix_list(source['airspace']['boundary'].splitlines(), fixes))
|
|
|
|
areas = {section: source[section] for section in source if section.startswith('area')}
|
|
|
|
for area_data in areas.values():
|
|
if 'points' in area_data:
|
|
area_data['points'] = "\n".join(
|
|
process_fix_list(area_data['points'].splitlines(), fixes))
|
|
|
|
# process airport sections
|
|
airports = {section: source[section] for section in source if section.startswith('airport')}
|
|
|
|
for airport_data in airports.values():
|
|
|
|
gateways = dict((tuple(map(str.strip, gateway.split(","))) for gateway in airport_data['gateways'].strip().splitlines()),
|
|
**default_gateways) if 'gateways' in airport_data else None
|
|
|
|
if 'airlines' in airport_data:
|
|
airlines = [Airline(*airline.split(","), gateways=gateways)
|
|
for airline in airport_data['airlines'].splitlines() if airline]
|
|
airport_data['airlines'] = "\n".join(process_airlines_list(airlines))
|
|
|
|
if 'sids' in airport_data:
|
|
airport_data['sids'] = "\n".join(
|
|
process_sids_fix_list(airport_data['sids'].splitlines(), fixes))
|
|
|
|
# process approach/transition sections
|
|
approaches = [source[section] for section in source
|
|
if section.startswith('approach') or section.startswith('transition')]
|
|
tagged_approaches_by_runway = {}
|
|
generated_approaches_by_runway = {}
|
|
highest_app_index = 0
|
|
|
|
for approach_data in approaches:
|
|
runway = approach_data['runway']
|
|
if runway not in tagged_approaches_by_runway:
|
|
tagged_approaches_by_runway[runway] = {}
|
|
tagged_approaches = tagged_approaches_by_runway[runway]
|
|
generated_approaches = []
|
|
if 'beacon' in approach_data and ',' not in approach_data['beacon']:
|
|
approach_data['beacon'] = approach_data['beacon'].removeprefix("!")
|
|
if approach_data['beacon'] in fixes and fixes[approach_data['beacon']].heading.startswith('!'):
|
|
approach_data['beacon'] = fixes[approach_data['beacon']].full_def
|
|
for option in approach_data:
|
|
if option.startswith('route'):
|
|
approach_data[option] = "\n".join(process_approach_fix_list(approach_data[option].splitlines(),
|
|
fixes, tagged_approaches, generated_approaches))
|
|
if runway not in generated_approaches_by_runway:
|
|
generated_approaches_by_runway[approach_data['runway']] = []
|
|
generated_approaches_by_runway[approach_data['runway']].extend(generated_approaches)
|
|
|
|
# find highest approach index as we need to add more approaches
|
|
for section in source:
|
|
if section.startswith('approach'):
|
|
highest_app_index = max(highest_app_index, int(section[8:]))
|
|
|
|
for runway, generated_approaches in generated_approaches_by_runway.items():
|
|
for generated_approach in generated_approaches:
|
|
section = f'approach{highest_app_index}'
|
|
highest_app_index += 1
|
|
beacon = generated_approach['beacon']
|
|
if fixes[beacon].heading.startswith('!'):
|
|
beacon = fixes[beacon].full_def
|
|
source[section] = {
|
|
"runway": runway,
|
|
"beacon": beacon,
|
|
"route1": generated_approach['heading'] + "\n" + "\n".join(
|
|
generated_approach['route'])
|
|
}
|
|
|
|
# process departure sections
|
|
departures = [source[section] for section in source if section.startswith('departure')]
|
|
tagged_departures = {}
|
|
|
|
for departure_data in departures:
|
|
routes = {int(option.removeprefix('route')): departure_data[option]
|
|
for option in departure_data if option.startswith('route')}
|
|
processed_routes = []
|
|
for route_index in sorted(routes):
|
|
processed_routes.extend("\n".join(route) for route in
|
|
process_repeatable_departure_fix_list(
|
|
routes[route_index].splitlines(), fixes, tagged_departures)
|
|
if route)
|
|
del departure_data[f'route{route_index}']
|
|
departure_data.update(enumerate_routes(processed_routes, start=1))
|
|
|
|
# write output file
|
|
if not args.parse_only:
|
|
with open(output_file, 'w', newline='') as airport_file:
|
|
airport_file.write(header)
|
|
source.write(airport_file)
|
|
|
|
# legacy processor in regex. Don't use for new projects.
|
|
else:
|
|
pattern = re.compile(r"^(?P<airport_section>\[airport(?P<airport_id>\d*)\])|(?P<airline_entry>#!\t(?P<airline_code>[-\w]*), (?P<airline_frequency>\d*), (?P<airline_parameters>[\w/d]*, [-\w ]*, [nswe]*))|(?P<result_marker>#!expansionoutput(?P<result_id>\d+))|(?P<result_end_marker>#!expansionoutputend)|(?P<sid_marker>#!sid(?P<sid_frequency>[\d]+)x)")
|
|
|
|
result = {'output': []}
|
|
airport = 0
|
|
ignore_lines = False
|
|
ignore_one_line = False
|
|
sid_frequency = 0
|
|
sid_lines = []
|
|
|
|
with open(input_file, 'r', newline='') as airport_file:
|
|
for line in airport_file:
|
|
match = pattern.match(line)
|
|
if match:
|
|
if match['airport_section']:
|
|
airport = match['airport_id']
|
|
if airport not in result:
|
|
result[airport] = []
|
|
|
|
elif match['airline_entry']:
|
|
total_frequency = int(match['airline_frequency'])
|
|
frequencies = []
|
|
while total_frequency > 10:
|
|
frequencies.append(10)
|
|
total_frequency -= 10
|
|
frequencies.append(total_frequency)
|
|
for frequency in frequencies:
|
|
result[airport].append(
|
|
f"\t{match['airline_code']}, {frequency}, {match['airline_parameters']}\n"
|
|
)
|
|
|
|
elif match['result_marker']:
|
|
result['output'].append(line)
|
|
for result_line in result[match['result_id']]:
|
|
result['output'].append(result_line)
|
|
ignore_lines = True
|
|
|
|
elif match['result_end_marker']:
|
|
ignore_lines = False
|
|
|
|
elif match['sid_marker']:
|
|
sid_frequency = int(match['sid_frequency']) - 1
|
|
ignore_one_line = True
|
|
|
|
if sid_frequency:
|
|
if line.isspace():
|
|
for _ in range(sid_frequency):
|
|
result['output'].extend(sid_lines)
|
|
sid_frequency = 0
|
|
sid_lines = []
|
|
elif not len(sid_lines):
|
|
sid_lines.append("\n")
|
|
else:
|
|
sid_lines.append(line)
|
|
|
|
if not ignore_lines and not ignore_one_line:
|
|
result['output'].append(line)
|
|
|
|
if ignore_one_line:
|
|
ignore_one_line = False
|
|
|
|
if not args.parse_only:
|
|
with open(output_file, 'w', newline='') as airport_file:
|
|
airport_file.writelines(result['output'])
|
|
return output_file if not args.parse_only else None
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(description='''Expands certain commands to allow for concise Endless ATC airport source files.
|
|
\n\n
|
|
Available functions:
|
|
\n\n
|
|
In [airspace] boundary=, [area] points=, or the route= of an [approach/departure/transition], specify "!<name>" instead of lat, lon
|
|
to substitute the lat, lon from the fix with the corresponding name in [airspace] beacons=. In [airport] sids=, "!<name>"
|
|
can also be specified, and will become name, lat, lon instead. In [approach/departure/transition], "!<name>" can also be specified
|
|
in beacon=, where it will become the full fix definition.
|
|
\n\n
|
|
In [airport] airlines=, definitions with frequency >10 with be broken down into multiple definitions of frequency 10 or less.
|
|
\n\n
|
|
In [airport], you can define gateways=, a list of <name>, direction. If gateways= is defined, the ", <directions>"" in
|
|
[airport] airlines= becomes ", <arrival_gateways>, <departure_gateways>", and the directions are used based on the defined
|
|
gateways. Default gateways can be specified in a common.ini in the same directory as the source file, or in the folder where
|
|
this tool is located; gateways= still needs to be defined in an [airport] to activate this feature for the [airport].
|
|
\n\n
|
|
In [airport] airlines=, the airline <pronunciation> can be omitted if [meta] callsigns= is true. A lookup will be loaded from
|
|
[expand.callsigns] defined in a common.ini in the same directory as the source file, or in the folder where this tool is
|
|
located. The former takes precedence. [expand.callsigns] is a list of <code>, <pronunciation>. The first item in each
|
|
line of airlines (stripped of a dash and anything after it, hereafter referred to as the "key") is used to lookup in
|
|
[expand.callsigns] to obtain the pronunciation. If nothing is found, pronunication defaults to the key if it is longer than
|
|
3 characters (assuming it is a military callsign), otherwise it defaults to "0".
|
|
\n\n
|
|
In a [approach/transition] route=, specify "@<name>" to "tag" the approach route. Any subsequent [approach] route= can then
|
|
specify "@<name>" as the last point to chain the approach route tagged as "name" to the end.
|
|
\n\n
|
|
In a [departure] route=, specify "@<name>" to "tag" the route. This will remove the departure route from the resulting file
|
|
(as it is an incomplete departure route). Any subsequent [departure] route= can then specify "@<name>" as the *first* point
|
|
(second line, after the route name) to chain the departure route tagged as "name" to the beginning.
|
|
\n\n
|
|
*n as the first line of a [departure] route= value will repeat that route n times. Obviously, a repeated route= cannot be
|
|
tagged as it wouldn't make any sense.''')
|
|
parser.add_argument('input_file')
|
|
parser.add_argument('output_file', nargs='?')
|
|
parser.add_argument('-l', '--legacy', action="store_true",
|
|
help='''Use legacy processing method. Don't use for new projects.
|
|
\n\n
|
|
#!expansionoutput<airport_id> can be inserted on its own line in a source file terminated by
|
|
#!expansionoutputend on a following line. This block, which should remain empty, will be used
|
|
to write the result of expanding any airline definitions in a #! comment. Any #! definitions
|
|
with frequency greater are split into entries with max 10 frequency each.
|
|
\n\n
|
|
#!sid<n>x can be inserted before any "routex =" declaration in a [departure] section to repeat the
|
|
route <n> times. This can be used to adjust the distribution of traffic on each SID. Note the
|
|
numbering of each "route" will not be adjusted. See renumber.py for such operation.''')
|
|
|
|
process(parser.parse_args())
|