def parse_metadata(metadata_element, gpxns=None):
gpxns = gpxns if gpxns is not None else determine_gpx_namespace(metadata_element)
get_text = lambda tag: optional_text(metadata_element, gpxns+tag)
name = get_text('name')
description = get_text('desc')
author_element = metadata_element.find(gpxns+'author')
author = nullable(parse_person)(author_element, gpxns)
copyright_element = metadata_element.find(gpxns+'copyright')
copyright = nullable(parse_copyright)(copyright_element, gpxns)
link_elements = metadata_element.findall(gpxns+'link')
links = [parse_link(link_element, gpxns) for link_element in link_elements]
time = get_text('time')
keywords = get_text('keywords')
bounds_element = metadata_element.find(gpxns+'bounds')
bounds = nullable(parse_bounds)(bounds_element)
extensions_element = metadata_element.find(gpxns+'extensions')
extensions = nullable(parse_metadata_extensions)(extensions_element, gpxns)
return Metadata(name, description, author, copyright, links, time,
keywords, bounds, extensions)
def __init__(self, name=None, description=None, author=None,
copyright=None, links=None, time=None, keywords=None,
bounds=None, extensions=None):
self._name = nullable(str)(name)
self._description = nullable(str)(description)
self._author = author
self._copyright = copyright
self._links = make_list(links)
self._time = nullable(make_time)(time)
self._keywords = nullable(str)(keywords)
self._bounds = bounds
self._extensions = make_list(extensions)
def parse_person(person_element, gpxns=None):
gpxns = gpxns if gpxns is not None else determine_gpx_namespace(person_element)
get_text = lambda tag: optional_text(person_element, gpxns+tag)
name = get_text('name')
email_element = person_element.find(gpxns+'email')
email = nullable(parse_email)(email_element, gpxns)
link_element = person_element.find(gpxns+'link')
link = nullable(parse_link)(link_element, gpxns)
return Person(name, email, link)
def parse_track(track_element, gpxns=None):
gpxns = gpxns if gpxns is not None else determine_gpx_namespace(track_element)
get_text = lambda tag: optional_text(track_element, gpxns+tag)
name = get_text('name')
comment = get_text('comment')
description = get_text('desc')
source = get_text('src')
link_elements = track_element.findall(gpxns+'link')
links = [parse_link(link_element, gpxns) for link_element in link_elements]
number = get_text('number')
classification = get_text('type')
segment_elements = track_element.findall(gpxns+'trkseg')
segments = [parse_segment(segment_element, gpxns) for segment_element in segment_elements]
extensions_element = track_element.find(gpxns+'extensions')
extensions = nullable(parse_track_extensions)(extensions_element, gpxns)
track = Track(name, comment, description, source, links, number,
classification, extensions, segments)
return track
def parse_route(route_element, gpxns=None):
gpxns = gpxns if gpxns is not None else determine_gpx_namespace(route_element)
get_text = lambda tag: optional_text(route_element, gpxns+tag)
name = get_text('name')
comment = get_text('cmt')
description = get_text('desc')
source = get_text('src')
link_elements = route_element.findall(gpxns+'link')
links = [parse_link(link_element, gpxns) for link_element in link_elements]
number = get_text('number')
classification = get_text('type')
extensions_element = route_element.find(gpxns+'extensions')
extensions = nullable(parse_route_extensions)(extensions_element, gpxns)
routepoint_elements = route_element.findall(gpxns+'rtept')
routepoints = [parse_waypoint(routepoint_element, gpxns) for routepoint_element in routepoint_elements]
route = Route(name, comment, description, source, links, number, classification, extensions, routepoints)
return route
def parse_segment(segment_element, gpxns=None):
gpxns = gpxns if gpxns is not None else determine_gpx_namespace(segment_element)
trackpoint_elements = segment_element.findall(gpxns+'trkpt')
trackpoints = [parse_waypoint(trackpoint_element, gpxns) for trackpoint_element in trackpoint_elements]
extensions_element = segment_element.find(gpxns+'extensions')
extensions = nullable(parse_segment_extensions)(extensions_element, gpxns)
segment = Segment(trackpoints, extensions)
return segment
def parse_copyright(copyright_element, gpxns=None):
gpxns = gpxns if gpxns is not None else determine_gpx_namespace(copyright_element)
get_text = lambda tag: optional_text(copyright_element, gpxns+tag)
author = copyright_element.attrib['author']
year_element = copyright_element.find(gpxns+'year')
year = nullable(parse_year)(year_element)
license = get_text('license')
return Copyright(author, year, license)
def parse_waypoint(waypoint_element, gpxns=None):
gpxns = gpxns if gpxns is not None else determine_gpx_namespace(waypoint_element)
get_text = lambda tag: optional_text(waypoint_element, gpxns+tag)
latitude = waypoint_element.attrib['lat']
longitude = waypoint_element.attrib['lon']
elevation = get_text('ele')
time = get_text('time')
magvar = get_text('magvar')
geoid_height = get_text('geoidheight')
name = get_text('name')
comment = get_text('cmt')
description = get_text('desc')
source = get_text('src')
link_elements = waypoint_element.findall(gpxns+'link')
links = [parse_link(link_element, gpxns) for link_element in link_elements]
symbol = get_text('sym')
classification = get_text('type')
fix = get_text('fix')
num_satellites = get_text('sat')
hdop = get_text('hdop')
vdop = get_text('vdop')
pdop = get_text('pdop')
seconds_since_dgps_update = get_text('ageofdgpsdata')
dgps_station_type = get_text('dgpsid')
extensions_element = waypoint_element.find(gpxns+'extensions')
extensions = nullable(parse_waypoint_extensions)(extensions_element, gpxns)
waypoint = Waypoint(latitude, longitude, elevation, time, magvar,
geoid_height, name, comment, description, source,
links, symbol, classification, fix, num_satellites,
hdop, vdop, pdop, seconds_since_dgps_update,
dgps_station_type, extensions)
return waypoint
def __init__(self, name=None, comment=None, description=None, source=None,
links=None, number=None, classification=None,
extensions=None, points=None):
self._name = nullable(str)(name)
self._comment = nullable(str)(comment)
self._description = nullable(str)(description)
self._source = nullable(str)(source)
self._links = make(list)(links)
self._number = nullable(int)(number)
if self._number is not None:
if self._number < 0:
raise ValueError("GPS track number {0} cannot be negative")
self._classification = nullable(str)(classification)
self._extensions = make_list(extensions)
self._points = make_list(points)
def __init__(self, href, text=None, mime=None):
self._href = str(href)
self._text = nullable(str)(text)
self._mime = nullable(str)(mime)
def parse_gpx(gpx_element, gpxns=None):
"""Parse a GPX file into a GpxModel.
Args:
xml: A file-like-object opened in binary mode - that is containing
bytes rather than characters. The root element of the XML should
be a <gpx> element containing a version attribute. GPX versions
1.0 is supported.
Returns:
A GpxModel representing the data from the supplies xml.
Raises:
ValueError: The supplied XML could not be parsed as GPX.
"""
gpxns = gpxns if gpxns is not None else determine_gpx_namespace(gpx_element)
if gpx_element.tag != gpxns+'gpx':
raise ValueError("No gpx root element")
get_text = lambda tag: optional_text(gpx_element, gpxns+tag)
version = gpx_element.attrib['version']
if not version.startswith('1.0'):
raise ValueError("Not a GPX 1.0 file")
creator = gpx_element.attrib['creator']
name = get_text('name')
description = get_text('desc')
author_name = get_text('author')
email = get_text('email')
author = Person(author_name, email)
url = get_text('url')
urlname = get_text('urlname')
links = make_links(url, urlname)
time = get_text('time')
keywords = get_text('keywords')
bounds_element = gpx_element.find(gpxns+'bounds')
bounds = nullable(parse_bounds)(bounds_element)
metadata = Metadata(name=name, description=description, author=author,
links=links, time=time, keywords=keywords, bounds=bounds)
waypoint_elements = gpx_element.findall(gpxns+'wpt')
waypoints = [parse_waypoint(waypoint_element, gpxns) for waypoint_element in waypoint_elements]
route_elements = gpx_element.findall(gpxns+'rte')
routes = [parse_route(route_element, gpxns) for route_element in route_elements]
track_elements = gpx_element.findall(gpxns+'trk')
tracks = [parse_track(track_element, gpxns) for track_element in track_elements]
# TODO : Private elements
gpx_model = GpxModel(creator, metadata, waypoints, routes, tracks)
return gpx_model
def __init__(self, author, year=None, license=None):
self._author = str(author)
self._year = nullable(Year)(year)
self._license = nullable(str)(license)
def parse_gpx(gpx_element, gpx_extensions_parser=None,
metadata_extensions_parser=None,
waypoint_extensions_parser=None,
route_extensions_parser=None,
track_extensions_parser=None,
segment_extensions_parser=None,
gpxns=None):
"""Parse a GPX file into a GpxModel.
Args:
gpx_element: gpx_element: The root <gpx> element of an XML document
containing a version attribute. GPX versions 1.1 is supported.
gpx_extensions_parser: An optional callable which accepts an Element
with the 'extensions' tag and returns a list of model objects
representing the extensions. If not specified, extensions are
ignored.
metadata_extensions_parser: An optional callable which accepts an
Element with the 'extensions' tag and returns a list of model
objects representing the extensions. If not specified, extensions
are ignored.
waypoint_extensions_parser: An optional callable which accepts an
Element with the 'extensions' tag and returns a list of model
objects representing the extensions. If not specified, extensions
are ignored.
route_extensions_parser: An optional callable which accepts an Element
with the 'extensions' tag and returns a list of model objects
representing the extensions. If not specified, extensions are
ignored.
track_extensions_parser: An optional callable which accepts an Element
with the 'extensions' tag and returns a list of model objects
representing the extensions. If not specified, extensions are
ignored.
segment_extensions_parser: An optional callable which accepts an
Element with the 'extensions' tag and returns a list of model
objects representing the extensions. If not specified, extensions
are ignored.
Returns:
A GpxModel representing the data from the supplies xml.
Raises:
ValueError: The supplied XML could not be parsed as GPX.
"""
gpxns = gpxns if gpxns is not None else determine_gpx_namespace(gpx_element)
if gpx_element.tag != gpxns+'gpx':
raise ValueError("No gpx root element")
creator = gpx_element.attrib['creator']
version = gpx_element.attrib['version']
if not version.startswith('1.1'):
raise ValueError("Not a GPX 1.1 file")
metadata_element = gpx_element.find(gpxns+'metadata')
metadata = nullable(parse_metadata)(metadata_element, gpxns)
waypoint_elements = gpx_element.findall(gpxns+'wpt')
waypoints = [parse_waypoint(waypoint_element, gpxns) for waypoint_element in waypoint_elements]
route_elements = gpx_element.findall(gpxns+'rte')
routes = [parse_route(route_element, gpxns) for route_element in route_elements]
track_elements = gpx_element.findall(gpxns+'trk')
tracks = [parse_track(track_element, gpxns) for track_element in track_elements]
extensions_element = gpx_element.find(gpxns+'extensions')
extensions = nullable(parse_gpx_extensions)(extensions_element, gpxns)
gpx_model = GpxModel(creator, metadata, waypoints, routes, tracks,
extensions)
return gpx_model
def __init__(
self,
latitude,
longitude,
elevation=None,
time=None,
magvar=None,
geoid_height=None,
name=None,
comment=None,
description=None,
source=None,
links=None,
symbol=None,
classification=None,
fix=None,
num_satellites=None,
hdop=None,
vdop=None,
pdop=None,
seconds_since_dgps_update=None,
dgps_station_type=None,
speed=None,
course=None,
extensions=None,
):
self._latitude = Decimal(latitude)
if not -90 <= self._latitude <= +90:
raise ValueError("Latitude {0} not in range -90 <= latitude <= +90")
self._longitude = Decimal(longitude)
if not -180 <= self._longitude < +180:
raise ValueError("Longitude {0} not in range -180 <= longitude < +180")
self._elevation = nullable(Decimal)(elevation)
self._time = nullable(make_time)(time)
self._magvar = nullable(Decimal)(magvar)
if self._magvar is not None:
if not 0 <= self._magvar < 360:
raise ValueError("Magnetic variation {0} not in range 0 <= magvar < 360")
self._geoid_height = nullable(Decimal)(geoid_height)
self._name = nullable(str)(name)
self._comment = nullable(str)(comment)
self._description = nullable(str)(description)
self._source = nullable(str)(source)
self._links = make_list(links)
self._symbol = nullable(str)(symbol)
self._classification = nullable(str)(classification)
self._fix = nullable(Fix)(fix)
self._num_satellites = nullable(int)(num_satellites)
if self._num_satellites is not None:
if self._num_satellites < 0:
raise ValueError("Number of satellites {0} cannot be negative")
self._hdop = nullable(Decimal)(hdop)
self._vdop = nullable(Decimal)(vdop)
self._pdop = nullable(Decimal)(pdop)
self._seconds_since_dgps_update = nullable(Decimal)(seconds_since_dgps_update)
self._dgps_station_type = nullable(int)(dgps_station_type)
if self._dgps_station_type is not None:
if not 0 <= self._dgps_station_type <= 1023:
raise ValueError("DGPS station type {0} not in range 0 <= dgps_station_type <= 1023")
self._speed = nullable(Decimal)(speed)
self._course = nullable(Decimal)(course)
if self._course is not None:
if not 0 <= self._course < 360:
raise ValueError("Course {0} not in range 0 <= course < 360")
self._extensions = make_list(extensions)
def __init__(self, name=None, email=None, link=None):
self._name = nullable(str)(name)
self._email = nullable(str)(email)
self._link = link
