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