gpxtractor 0.1.0__py3-none-any.whl

gpxtractor/__init__.py

@@ -0,0 +1,12 @@
+"""
+GPX, TCX and FIT data extraction for Python
+======================================
+
+gpxtractor is a python package to extract data from
+gpx, tcx and fit files and present it in a dataframe.
+"""
+
+__version__ = "0.1.0"
+
+
+from gpxtractor._core import Activity, extract_data

gpxtractor/_core.py

@@ -0,0 +1,265 @@
+import gzip
+import pathlib
+from typing import Optional
+from dataclasses import dataclass, field
+import pyarrow as pa
+import pandas as pd
+
+import gpxtractor._xml_extraction as xml_ext
+import gpxtractor._fit_extraction as fit_ext
+import gpxtractor._transformation as tr
+import gpxtractor._utils as ut
+
+
+@dataclass
+class Activity:
+    """Stores and manages records and metadata parsed from a gpx, tcx or
+    fit file.
+
+    This class is designed to hold structured data and associated metadata
+    extracted from a gpx, tcx or fit file, providing methods for accessing
+    and transforming the records.
+
+    Parameters
+    ----------
+    file_type : str
+        Can be any of the following: 'GPX', 'TCX' or 'FIT'.
+        Corresponds to the type of the file for which the instance of the
+        class holds data.
+
+    sport : str
+        Is the type of sport as extracted from the file in lower case.
+
+    records : pandas.DataFrame
+        DataFrame holding the records extracted from the gpx, tcx or fit file.
+
+    Attributes
+    ----------
+    is_transformed : bool
+        initially False, becomes True once either the method
+        `transform_records` or `full_transform` is used.
+
+    file_type : str
+        Can be any of the following: 'GPX', 'TCX' or 'FIT'.
+        Corresponds to the type of the file for which the instance of the
+        class holds data.
+
+    sport : None or str
+        Is the type of sport as extracted from the file in lower case.
+
+    start_time : None or pandas.Timestamp
+        Is None before a transformation method has been called.
+        A pandas Timestamp with timezone information indicating the start
+        time of the activity.
+
+    elapsed_time : None or int
+        Is None before a transformation method has been called.
+        An integer indicating the total elapsed time of the activity in
+        seconds.
+
+    distance : None or float
+        Is None before a transformation method has been called.
+        A float indicating the total distance covered during the activity
+        in kilometres.
+
+    avg_speed : None or float
+        Is None before a transformation method has been called.
+        A float indicating the average speed over the activity in kph.
+
+    avg_pace : None or str
+        Is None before a transformation method has been called.
+        A string indicating the average pace over the activity in min per km.
+
+    elevation_gain : None or int
+        Is None before a transformation method has been called.
+        An integer indicating the total elevation gained during the activity
+        in meters.
+
+    elevation_loss : None or int
+        Is None before a transformation method has been called.
+        An integer indicating the total elevation lossed during the activity
+        in meters.
+
+    avg_heart_rate : None or int
+        Is None before a transformation method has been called.
+        An integer indicating the average heart rate of the activity in bpm.
+
+    max_heart_rate : None or int
+        Is None before a transformation method has been called.
+        An integer indicating the maximum heart rate of the activity in bpm.
+
+    avg_cadence : None or int
+        Is None before a transformation method has been called.
+        An integer indicating the average cadence of the activity in either
+        rpm or, in the case of a running activity spm.
+
+    max_cadence : None or int
+        Is None before a transformation method has been called.
+        An integer indicating the maximum cadence of the activity in either
+        rpm or, in the case of a running activity spm.
+
+    records : pandas.DataFrame
+        DataFrame holding the records extracted from the gpx, tcx or fit file.
+        Records can be transformed with the methods `transform_records` or
+        `full_transform`.
+
+    km_splits : None or pandas.DataFrame
+        Initially None. DataFrame holding the transformed and aggregated data
+        grouped by kilometre splits once the `compute_km_splits` or
+        `full_transform` method has been used.
+
+    lap_splits : None or pandas.DataFrame
+        Initially None. DataFrame holding the transformed and aggregated data
+        grouped by lap splits once the `compute_lap_splits` or
+        `full_transform` method has been used. Can only hold data if the file
+        has lap data which is not the case for gpx files.
+    """
+
+    file_type: str
+    sport: str
+    records: pd.DataFrame
+    is_transformed: bool = field(default=False, init=False)
+    start_time: Optional[pd.Timestamp] = field(default=None, init=False)
+    elapsed_time: Optional[int] = field(default=None, init=False)
+    distance: Optional[float] = field(default=None, init=False)
+    avg_speed: Optional[float] = field(default=None, init=False)
+    max_speed: Optional[float] = field(default=None, init=False)
+    avg_pace: Optional[str] = field(default=None, init=False)
+    elevation_gain: Optional[int] = field(default=None, init=False)
+    elevation_loss: Optional[int] = field(default=None, init=False)
+    avg_heart_rate: Optional[int] = field(default=None, init=False)
+    max_heart_rate: Optional[int] = field(default=None, init=False)
+    avg_cadence: Optional[int] = field(default=None, init=False)
+    max_cadence: Optional[int] = field(default=None, init=False)
+    km_splits: Optional[pd.DataFrame] = field(default=None, init=False)
+    lap_splits: Optional[pd.DataFrame] = field(default=None, init=False)
+
+    def __str__(self):
+        records_str = str(self.records.head())
+        km_splits_str = (
+            str(self.km_splits.head()) if self.km_splits is not None else None
+        )
+        lap_splits_str = (
+            str(self.lap_splits.head()) if self.lap_splits is not None else None
+        )
+        return (
+            "Activity(\n"
+            f"  is_transformed: {self.is_transformed}\n"
+            f"  file_type: {self.file_type}\n"
+            f"  sport: {self.sport}\n"
+            f"  start_time: {self.start_time}\n"
+            f"  elapsed_time: {self.elapsed_time}\n"
+            f"  distance: {self.distance}\n"
+            f"  avg_speed: {self.avg_speed}\n"
+            f"  max_speed: {self.max_speed}\n"
+            f"  avg_pace: {self.avg_pace}\n"
+            f"  elevation_gain: {self.elevation_gain}\n"
+            f"  elevation_loss: {self.elevation_loss}\n"
+            f"  avg_heart_rate: {self.avg_heart_rate}\n"
+            f"  max_heart_rate: {self.max_heart_rate}\n"
+            f"  avg_cadence: {self.avg_cadence}\n"
+            f"  max_cadence: {self.max_cadence}\n"
+            f"  records:\n{records_str}\n"
+            f"  km_splits:\n{km_splits_str}\n"
+            f"  lap_splits:\n{lap_splits_str}\n"
+            ")"
+        )
+
+    def _transform_records_to_pyarrow(self):
+        if not self.is_transformed:
+            self.records = pa.Table.from_pandas(self.records)
+            self.records = tr.transform_data(self.records, self.sport)
+            stats = tr.compute_overall_stats(self.records)
+            self.start_time = stats["start_time"].at[0]
+            self.elapsed_time = int(stats["elapsed_time"].at[0])
+            self.distance = float(stats["distance"].at[0])
+            self.avg_speed = float(stats["avg_speed"].at[0])
+            self.max_speed = float(stats["max_speed"].at[0])
+            self.avg_pace = stats["avg_pace"].at[0]
+            self.elevation_gain = int(stats["elevation_gain"].at[0])
+            self.elevation_loss = int(stats["elevation_loss"].at[0])
+            self.avg_heart_rate = int(stats["avg_heart_rate"].at[0])
+            self.max_heart_rate = int(stats["max_heart_rate"].at[0])
+            self.avg_cadence = int(stats["avg_cadence"].at[0])
+            self.max_cadence = int(stats["max_cadence"].at[0])
+
+    def transform_records(self):
+        """Transforms the data in the records attributes to calculate distance,
+        speed if absent and elevation difference, gradient and, in the case of
+        running activities, pace.
+        """
+        if not self.is_transformed:
+            self._transform_records_to_pyarrow()
+            self.records = self.records.to_pandas(types_mapper=pd.ArrowDtype)
+            self.is_transformed = True
+
+    def compute_lap_splits(self):
+        """If there is lap data in the records, updates the lap_splits to a
+        DataFrame holding the transformed and aggregated data grouped by lap
+        splits. Note: there is no lap data in gpx files.
+        """
+        if self.file_type != "GPX" and self.is_transformed:
+            self.records = pa.Table.from_pandas(self.records)
+            self.lap_splits = tr.compute_lap_data(self.records)
+            self.records = self.records.to_pandas(types_mapper=pd.ArrowDtype)
+
+    def compute_km_splits(self):
+        """Updates km_splits attribute to a DataFrame holding the transformed
+        and aggregated data grouped by kilometre splits.
+        """
+        if self.is_transformed:
+            self.records = pa.Table.from_pandas(self.records)
+            self.km_splits = tr.compute_km_data(self.records)
+            self.records = self.records.to_pandas(types_mapper=pd.ArrowDtype)
+
+    def full_transform(self):
+        """Transforms data in records, computes km and lap splits"""
+        if not self.is_transformed:
+            self._transform_records_to_pyarrow()
+            self.km_splits = tr.compute_km_data(self.records)
+            if self.file_type != "GPX":
+                self.lap_splits = tr.compute_lap_data(self.records)
+            self.records = self.records.to_pandas(types_mapper=pd.ArrowDtype)
+            self.is_transformed = True
+
+
+def extract_data(file_path: pathlib.Path) -> Activity:
+    """Extract records from a gpx, tcx or fit file.
+    Create and return a new Activity instance where records are
+    stored as a pandas.DataFrame in the records attribute and the
+    sport is stored as a string in the sport attribute.
+
+    Parameters
+    ----------
+    file_path : pathlib.Path
+        Path to a file of type .gpx, .tcx or .fit. Can be gzipped.
+
+    Returns
+    -------
+    gpxtractor.Activity
+
+    Raises
+    ------
+    ValueError
+        if the file type is not gpx, tcx or fit or their gzipped
+        equivalent.
+    """
+    extensions = ut._get_file_extensions(file_path)
+    match extensions:
+        case ".gpx" | ".gpx.gz":
+            sport, records = ut._handle_gzipped_xml_files(
+                file_path, extensions, xml_ext.get_sport_from_gpx, xml_ext.extract_gpx
+            )
+        case ".tcx" | ".tcx.gz":
+            sport, records = ut._handle_gzipped_xml_files(
+                file_path, extensions, xml_ext.get_sport_from_tcx, xml_ext.extract_tcx
+            )
+        case ".fit":
+            sport, records = fit_ext.extract_fit(file_path)
+        case ".fit.gz":
+            with gzip.open(file_path, "rb") as gz:
+                sport, records = fit_ext.extract_fit(gz)
+        case _:
+            raise ValueError("Not a valid file type: Try a GPX, TCX or FIT file")
+    file_type = ut._get_file_type_from_extensions(extensions)
+    return Activity(file_type=file_type, sport=sport, records=records)

gpxtractor/_fit_extraction.py

@@ -0,0 +1,90 @@
+import pathlib
+import numpy as np
+import pandas as pd
+import fitdecode
+
+
+def _convert_fit_coords_to_deg(coord):
+    """Convert semicircle 32-bit integer coordinate to degrees"""
+    return coord * (180 / 2**31)
+
+
+def _generate_frame_from_fit(fit_file: pathlib.Path, selected_frames: list):
+    with fitdecode.FitReader(fit_file, check_crc=False) as fit:
+        for frame in fit:
+            if (
+                frame.frame_type == fitdecode.FIT_FRAME_DATA
+                and frame.name in selected_frames
+            ):
+                yield frame
+
+
+def _extract_str(frame, field_name: str):
+    if frame.has_field(field_name) and frame.get_value(field_name) is not None:
+        return frame.get_value(field_name)
+    return None
+
+
+def _extract_value(frame, field_name: str, datatype):
+    if frame.has_field(field_name) and frame.get_value(field_name) is not None:
+
+        return datatype(frame.get_value(field_name))
+    return 0 if datatype is int else np.nan
+
+
+def get_sport_from_fit(fit_content) -> str:
+    for frame in _generate_frame_from_fit(fit_content, ["session"]):
+        return _extract_str(frame, "sport")
+    return None
+
+
+def extract_fit(file_path: pathlib.Path) -> pd.DataFrame:
+    lap_number = 1
+    laps = []
+    times = []
+    lats = []
+    lons = []
+    eles = []
+    dists = []
+    speeds = []
+    hrs = []
+    cads = []
+
+    for frame in _generate_frame_from_fit(file_path, ["lap", "record", "session"]):
+        if frame.name == "record":
+            laps.append(lap_number)
+            times.append(_extract_str(frame, "timestamp"))
+            lats.append(_extract_value(frame, "position_lat", float))
+            lons.append(_extract_value(frame, "position_long", float))
+            eles.append(_extract_value(frame, "altitude", float))
+            dists.append(_extract_value(frame, "distance", float))
+            speeds.append(_extract_value(frame, "speed", float))
+            hrs.append(_extract_value(frame, "heart_rate", int))
+            cads.append(_extract_value(frame, "cadence", int))
+        elif frame.name == "lap":
+            lap_number += 1
+        elif frame.name == "session":
+            sport = _extract_str(frame, "sport")
+
+    laps = np.array(laps, dtype=np.uint16)
+    lats = _convert_fit_coords_to_deg(np.array(lats, dtype=np.float32))
+    lons = _convert_fit_coords_to_deg(np.array(lons, dtype=np.float32))
+    eles = np.array(eles, dtype=np.float32)
+    dists = np.array(dists, dtype=np.float32)
+    speeds = np.array(speeds, dtype=np.float32)
+    hrs = np.array(hrs, dtype=np.uint8)
+    cads = np.array(cads, dtype=np.uint8)
+
+    return sport, pd.DataFrame(
+        {
+            "lap": laps,
+            "timestamp": pd.to_datetime(times),
+            "latitude": lats,
+            "longitude": lons,
+            "distance": dists,
+            "speed": speeds,
+            "altitude": eles,
+            "heart_rate": hrs,
+            "cadence": cads,
+        }
+    )

gpxtractor/_transformation.py

@@ -0,0 +1,99 @@
+import inspect
+from importlib_resources import files
+import pandas as pd
+import pyarrow as pa
+import duckdb
+
+
+def get_var_name(var):
+    callers_local_vars = inspect.currentframe().f_back.f_locals.items()
+    return [name for name, val in callers_local_vars if val is var][0]
+
+
+def is_col_all_null(table: pa.Table, col: str) -> bool:
+    null_mask = pa.compute.is_null(table.column(col))
+    return pa.compute.all(null_mask).as_py()
+
+
+def add_empty_col_if_absent(arrow_table: pa.Table, col: str, datatype) -> pa.Table:
+    if col not in arrow_table.schema.names:
+        empty_values = pa.nulls(len(arrow_table), type=datatype)
+        return arrow_table.append_column(col, empty_values)
+    else:
+        return arrow_table
+
+
+def query_table(arrow_table: pa.Table, sql_file: str) -> pa.Table:
+    sql_path = files("gpxtractor.sql").joinpath(sql_file)
+    safe_table_name = get_var_name(arrow_table)
+    sql_query = sql_path.read_text().format(table_name=safe_table_name)
+    return duckdb.sql(sql_query).arrow().read_all()
+
+
+def compute_distance_and_speed(arrow_table: pa.Table) -> pa.Table:
+    sql_haversine_file = files("gpxtractor.sql").joinpath("haversine_formula.sql")
+    haversine_formula = sql_haversine_file.read_text()
+    duckdb.sql(haversine_formula)
+    sql_file = "compute_distance_and_speed.sql"
+    return query_table(arrow_table, sql_file)
+
+
+def compute_speed(arrow_table: pa.Table) -> pa.Table:
+    sql_file = "compute_speed.sql"
+    return query_table(arrow_table, sql_file)
+
+
+def preprocess_data(arrow_table: pa.Table) -> pa.Table:
+    sql_file = "preprocess_data.sql"
+    return query_table(arrow_table, sql_file)
+
+
+def preprocess_running_data(arrow_table: pa.Table) -> pa.Table:
+    sql_file = "preprocess_running_data.sql"
+    return query_table(arrow_table, sql_file)
+
+
+def transform_data(arrow_table: pa.Table, sport: str) -> pa.Table:
+    REQUIRED_COLUMNS = {
+        "timestamp": pa.timestamp("us"),
+        "latitude": pa.float32(),
+        "longitude": pa.float32(),
+        "altitude": pa.float32(),
+        "heart_rate": pa.uint8(),
+        "cadence": pa.uint8(),
+        "lap": pa.uint16(),
+    }
+    for col, datatype in REQUIRED_COLUMNS.items():
+        arrow_table = add_empty_col_if_absent(arrow_table, col, datatype)
+    if "distance" not in arrow_table.schema.names or is_col_all_null(
+        arrow_table, "distance"
+    ):
+        arrow_table = compute_distance_and_speed(arrow_table)
+    elif "speed" not in arrow_table.schema.names or is_col_all_null(
+        arrow_table, "speed"
+    ):
+        arrow_table = compute_speed(arrow_table)
+    if sport == "running":
+        arrow_table = preprocess_running_data(arrow_table)
+    else:
+        arrow_table = preprocess_data(arrow_table)
+
+    return arrow_table
+
+
+def compute_km_data(arrow_table: pa.Table) -> pd.DataFrame:
+    sql_file = "km_data_query.sql"
+    arrow_table = query_table(arrow_table, sql_file)
+    return arrow_table.to_pandas(types_mapper=pd.ArrowDtype)
+
+
+def compute_lap_data(arrow_table: pa.Table) -> pd.DataFrame:
+    sql_file = "lap_data_query.sql"
+    arrow_table = query_table(arrow_table, sql_file)
+    return arrow_table.to_pandas(types_mapper=pd.ArrowDtype)
+
+
+def compute_overall_stats(arrow_table: pa.Table):
+    sql_file = "overall_stats.sql"
+    arrow_table = query_table(arrow_table, sql_file)
+    return arrow_table.to_pandas(types_mapper=pd.ArrowDtype)

gpxtractor/_utils.py

@@ -0,0 +1,32 @@
+import pathlib
+import gzip
+
+
+def _get_file_extensions(file_path: pathlib.Path) -> str:
+    path = pathlib.Path(file_path)
+    return "".join(path.suffixes)
+
+
+def _get_file_type_from_extensions(extensions) -> str:
+    match extensions:
+        case ".gpx" | ".gpx.gz":
+            return "GPX"
+        case ".tcx" | ".tcx.gz":
+            return "TCX"
+        case ".fit" | ".fit.gz":
+            return "FIT"
+
+
+def _handle_gzipped_xml_files(
+    file_path: pathlib.Path, extensions, sport_func, extraction_func
+):
+    is_gzipped = ".gz" in extensions
+    if is_gzipped:
+        with gzip.open(file_path, "rt") as gz:
+            sport = sport_func(gz)
+        with gzip.GzipFile(file_path, "r") as gz:
+            return sport, extraction_func(gz)
+    else:
+        with open(file_path, "r") as file:
+            sport = sport_func(file)
+        return sport, extraction_func(file_path)

gpxtractor/_xml_extraction.py

@@ -0,0 +1,165 @@
+import numpy as np
+import pandas as pd
+from lxml import etree
+from typing import Union, Type
+
+
+def _extract_value(
+    etree_element: etree.Element, datatype: Union[Type[int], Type[float]]
+) -> Union[int, float]:
+    if etree_element is None:
+        return 0 if datatype is int else np.nan
+    return datatype(etree_element.text)
+
+
+def _get_tcx_cadence(trkpt_ext: etree.Element, ns: dict) -> int:
+    run_cadence = trkpt_ext.find("tcxtpx:RunCadence", ns)
+    if run_cadence is not None:
+        return int(run_cadence.text)
+    cadence = trkpt_ext.find("tcxtpx:Cadence", ns)
+    if cadence is not None:
+        return int(cadence.text)
+    return 0
+
+
+def get_sport_from_gpx(open_file):
+    for line in open_file:
+        if "<type>" in line:
+            start = line.find("<type>") + len("<type>")
+            end = line.find("</type>")
+            return line[start:end].strip().lower()
+    return None
+
+
+def get_sport_from_tcx(open_file):
+    for line in open_file:
+        if "<Activity" in line:
+            start = line.find('Sport="') + len('Sport="')
+            end = line.find('"', start)
+            return line[start:end].strip().lower()
+    return None
+
+
+def extract_gpx(gpx_file: str) -> pd.DataFrame:
+    ns = {
+        "gpx": "http://www.topografix.com/GPX/1/1",
+        "gpxtpx": "http://www.garmin.com/xmlschemas/TrackPointExtension/v1",
+    }
+
+    times = []
+    lats = []
+    lons = []
+    eles = []
+    hrs = []
+    cads = []
+
+    for event, trkpt in etree.iterparse(
+        gpx_file, events=("end",), tag="{http://www.topografix.com/GPX/1/1}trkpt"
+    ):
+
+        times.append(trkpt.find("gpx:time", ns).text)
+        lats.append(float(trkpt.attrib["lat"]))
+        lons.append(float(trkpt.attrib["lon"]))
+        eles.append(_extract_value(trkpt.find("gpx:ele", ns), float))
+        extensions = trkpt.find("gpx:extensions", ns)
+        if extensions is not None:
+            hrs.append(
+                _extract_value(
+                    extensions.find("gpxtpx:TrackPointExtension/gpxtpx:hr", ns), int
+                )
+            )
+            cads.append(
+                _extract_value(
+                    extensions.find("gpxtpx:TrackPointExtension/gpxtpx:cad", ns), int
+                )
+            )
+
+    lats = np.array(lats, dtype=np.float32)
+    lons = np.array(lons, dtype=np.float32)
+    eles = np.array(eles, dtype=np.float32)
+    hrs = np.array(hrs, dtype=np.uint8)
+    cads = np.array(cads, dtype=np.uint8)
+
+    return pd.DataFrame(
+        {
+            "timestamp": pd.to_datetime(times),
+            "latitude": lats,
+            "longitude": lons,
+            "altitude": eles,
+            "heart_rate": hrs,
+            "cadence": cads,
+        }
+    )
+
+
+def extract_tcx(tcx_file: str) -> pd.DataFrame:
+    ns = {
+        "tcx": "http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2",
+        "tcxtpx": "http://www.garmin.com/xmlschemas/ActivityExtension/v2",
+    }
+
+    lap_number = 0
+    laps = []
+    times = []
+    lats = []
+    lons = []
+    eles = []
+    dists = []
+    speeds = []
+    hrs = []
+    cads = []
+
+    for event, lap in etree.iterparse(
+        tcx_file,
+        events=("end",),
+        tag="{http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2}Lap",
+    ):
+        lap_number += 1
+        for trkpt in lap.findall(".//tcx:Trackpoint", ns):
+            laps.append(lap_number)
+            times.append(trkpt.find("tcx:Time", ns).text)
+            lats.append(
+                _extract_value(
+                    trkpt.find("tcx:Position/tcx:LatitudeDegrees", ns), float
+                )
+            )
+            lons.append(
+                _extract_value(
+                    trkpt.find("tcx:Position/tcx:LongitudeDegrees", ns), float
+                )
+            )
+            eles.append(_extract_value(trkpt.find("tcx:AltitudeMeters", ns), float))
+            dists.append(_extract_value(trkpt.find("tcx:DistanceMeters", ns), float))
+            hrs.append(
+                _extract_value(trkpt.find("tcx:HeartRateBpm/tcx:Value", ns), int)
+            )
+
+            extensions = trkpt.find("tcx:Extensions", ns)
+            if extensions is not None:
+                tpx = extensions.find("tcxtpx:TPX", ns)
+                if tpx is not None:
+                    speeds.append(_extract_value(tpx.find("tcxtpx:Speed", ns), float))
+                    cads.append(_get_tcx_cadence(tpx, ns))
+
+    laps = np.array(laps, dtype=np.uint16)
+    lats = np.array(lats, dtype=np.float32)
+    lons = np.array(lons, dtype=np.float32)
+    eles = np.array(eles, dtype=np.float32)
+    dists = np.array(dists, dtype=np.float32)
+    speeds = np.array(speeds, dtype=np.float32)
+    hrs = np.array(hrs, dtype=np.uint8)
+    cads = np.array(cads, dtype=np.uint8)
+
+    return pd.DataFrame(
+        {
+            "lap": laps,
+            "timestamp": pd.to_datetime(times),
+            "latitude": lats,
+            "longitude": lons,
+            "distance": dists,
+            "speed": speeds,
+            "altitude": eles,
+            "heart_rate": hrs,
+            "cadence": cads,
+        }
+    )

gpxtractor/cli.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+
+import argparse
+import visidata
+
+import gpxtractor
+from gpxtractor import extract_data
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Display a GPX or TCX file as a dataframe in visidata."
+    )
+    parser.add_argument("file", type=str, nargs="?", help="")
+    parser.add_argument(
+        "--raw",
+        action="store_true",
+        help="Display the data from the file with no transformation in a table.",
+    )
+    parser.add_argument(
+        "--sport",
+        action="store_true",
+        help="Print the sport or activity type of the file.",
+    )
+    parser.add_argument(
+        "--kms",
+        action="store_true",
+        help="Display aggregated stats grouped by kilometer.",
+    )
+    parser.add_argument(
+        "--laps",
+        action="store_true",
+        help="Display aggregated stats grouped by lap.",
+    )
+    parser.add_argument(
+        "--version",
+        action="store_true",
+        help="Display version and exit.",
+    )
+
+    return parser, parser.parse_args()
+
+
+def main():
+    parser, args = parse_args()
+
+    if args.version:
+        print(f"gpxtractor v{gpxtractor.__version__}")
+        return
+
+    if not args.file and not args.version:
+        parser.error("the following arguments are required: file")
+
+    activity = extract_data(file_path=args.file)
+    if args.raw:
+        visidata.vd.view_pandas(df=activity.records)
+        return
+
+    activity.full_transform()
+
+    if args.sport:
+        print(activity.sport)
+    elif args.kms:
+        visidata.vd.view_pandas(df=activity.km_splits)
+    elif args.laps:
+        if activity.lap_splits is not None:
+            visidata.vd.view_pandas(df=activity.lap_splits)
+        else:
+            print("No laps in file")
+    else:
+        visidata.vd.view_pandas(df=activity.records)
+
+
+if __name__ == "__main__":
+    main()

gpxtractor/sql/compute_distance_and_speed.sql

@@ -0,0 +1,49 @@
+WITH stage_1 AS (
+    SELECT
+        ROW_NUMBER() OVER (ORDER BY timestamp) AS index,
+        timestamp,
+        latitude,
+        longitude,
+        LAG(timestamp, 1) OVER (ORDER BY timestamp) AS prev_time,
+        LAG(latitude, 1) OVER (ORDER BY timestamp) AS prev_lat,
+        LAG(longitude, 1) OVER (ORDER BY timestamp) AS prev_long,
+        altitude,
+        heart_rate,
+        cadence,
+        lap,
+    FROM {table_name}
+    ORDER BY timestamp
+), stage_2 AS (
+    SELECT
+        timestamp,
+        latitude,
+        longitude,
+        CASE
+            WHEN index == 1
+            THEN 0.0::FLOAT
+            ELSE haversine(prev_lat, prev_long, latitude, longitude)::FLOAT END AS marginal_distance,
+        CASE
+            WHEN index == 1
+            THEN 0::SMALLINT
+            ELSE date_diff('second', prev_time, timestamp)::SMALLINT END AS marginal_time,
+        altitude,
+        heart_rate,
+        cadence,
+        lap,
+    FROM stage_1
+    ORDER BY timestamp
+)
+
+SELECT
+    timestamp,
+    latitude,
+    longitude,
+    ROUND(SUM(marginal_distance) OVER (ORDER BY timestamp), 2)::FLOAT AS distance, -- in meters
+    -- SUM(marginal_time) OVER (ORDER BY timestamp) AS elapsed_time,
+    (marginal_distance / marginal_time)::FLOAT AS speed, -- in meters per second
+    altitude, -- in meters
+    heart_rate,
+    cadence, -- strides (2 steps) per minute
+    lap,
+FROM stage_2
+ORDER BY timestamp;

gpxtractor/sql/compute_speed.sql

@@ -0,0 +1,49 @@
+WITH stage_1 AS (
+    SELECT
+        ROW_NUMBER() OVER (ORDER BY timestamp) AS index,
+        timestamp,
+        latitude,
+        longitude,
+        LAG(timestamp, 1) OVER (ORDER BY timestamp) AS prev_time,
+        distance,
+        LAG(distance, 1) OVER (ORDER BY timestamp) AS prev_dist,
+        altitude,
+        heart_rate,
+        cadence,
+        lap,
+    FROM {table_name}
+    ORDER BY timestamp
+), stage_2 AS (
+    SELECT
+        timestamp,
+        latitude,
+        longitude,
+        CASE
+            WHEN index == 1
+            THEN 0.0::FLOAT
+            ELSE (distance - prev_dist)::FLOAT END AS marginal_distance,
+        CASE
+            WHEN index == 1
+            THEN 0::SMALLINT
+            ELSE date_diff('second', prev_time, timestamp)::SMALLINT END AS marginal_time,
+        altitude,
+        heart_rate,
+        cadence,
+        lap,
+    FROM stage_1
+    ORDER BY timestamp
+)
+
+SELECT
+    timestamp,
+    latitude,
+    longitude,
+    ROUND(SUM(marginal_distance) OVER (ORDER BY timestamp), 2)::FLOAT AS distance, -- in meters
+    -- SUM(marginal_time) OVER (ORDER BY timestamp) AS elapsed_time,
+    (marginal_distance / marginal_time)::FLOAT AS speed, -- in meters per second
+    altitude, -- in meters
+    heart_rate,
+    cadence, -- strides (2 steps) per minute
+    lap,
+FROM stage_2
+ORDER BY timestamp;

gpxtractor/sql/haversine_formula.sql

@@ -0,0 +1,8 @@
+CREATE OR REPLACE FUNCTION haversine(lat1 DOUBLE, lon1 DOUBLE, lat2 DOUBLE, lon2 DOUBLE) AS
+    2 * 6371000 * ASIN(
+        SQRT(
+            POW(SIN(RADIANS(lat2 - lat1) / 2), 2) +
+            COS(RADIANS(lat1)) * COS(RADIANS(lat2)) *
+            POW(SIN(RADIANS(lon2 - lon1) / 2), 2)
+        )
+    );

gpxtractor/sql/km_data_query.sql

@@ -0,0 +1,92 @@
+WITH data_with_km_col AS (
+    SELECT 
+        *,
+        TRUNC(distance) + 1 AS km
+    FROM {table_name}
+    ORDER BY timestamp
+), km_data AS (
+    SELECT
+        km::SMALLINT AS km,
+        MIN(timestamp) AS start_time,
+        MAX(timestamp) AS end_time,
+        MAX(distance) AS max_distance,
+        ROUND(SUM(CASE
+            WHEN diff_alt > 0
+            THEN diff_alt
+            ELSE 0 END))::USMALLINT AS elevation_gain,
+        ABS(ROUND(SUM(CASE
+            WHEN diff_alt < 0
+            THEN diff_alt
+            ELSE 0 END)))::USMALLINT AS elevation_loss,
+        ROUND(AVG(heart_rate))::UTINYINT AS avg_hr,
+        MAX(heart_rate)::UTINYINT AS max_hr,
+        ROUND(AVG(cadence))::UTINYINT AS avg_cadence,
+        MAX(cadence)::UTINYINT AS max_cadence
+    FROM data_with_km_col
+    GROUP BY km
+    ORDER BY km
+), km_data_stage_2 AS (
+    SELECT
+        km,
+        start_time,
+        end_time,
+        LAG(end_time, 1) OVER (ORDER BY km) AS km_start_time,
+        LAG(max_distance, 1) OVER (ORDER BY km) AS km_start_distance,
+        max_distance,
+        elevation_gain,
+        elevation_loss,
+        avg_hr,
+        max_hr,
+        avg_cadence,
+        max_cadence
+    FROM km_data
+    ORDER BY km
+), km_data_stage_3 AS (
+    SELECT
+        km,
+        CASE
+            WHEN km > 1
+            THEN date_diff('second', km_start_time , end_time)
+            ELSE date_diff('second', start_time, end_time) END AS elapsed_time,
+        CASE
+            WHEN km > 1
+            THEN max_distance - km_start_distance 
+            ELSE max_distance END AS distance_km,
+        CASE
+            WHEN km > 1
+            THEN (km_start_distance + distance_km / 2)
+            ELSE (distance_km / 2) END AS midpoint,
+        elevation_gain,
+        elevation_loss,
+        avg_hr,
+        max_hr,
+        avg_cadence,
+        max_cadence
+    FROM km_data_stage_2
+    ORDER BY km
+)
+
+SELECT
+    km,
+    distance_km AS distance,
+    CASE
+        WHEN elapsed_time == 0
+        THEN 0
+        ELSE (distance_km / elapsed_time * 3600) END AS avg_speed_kph,
+    CASE 
+        WHEN avg_speed_kph == 0
+        THEN NULL
+        ELSE printf(
+            '%02d:%02d',
+            CAST(FLOOR(60 / avg_speed_kph) AS INT),
+            CAST(((60 / avg_speed_kph - FLOOR(60 / avg_speed_kph)) * 60) AS INT)
+        ) END AS avg_pace,
+    midpoint AS midpoint,
+    elevation_gain,
+    elevation_loss,
+    avg_hr,
+    max_hr,
+    avg_cadence,
+    max_cadence
+FROM km_data_stage_3
+ORDER BY km;

gpxtractor/sql/lap_data_query.sql

@@ -0,0 +1,86 @@
+WITH lap_data AS (
+    SELECT
+        lap AS lap,
+        MIN(timestamp) AS start_time,
+        MAX(timestamp) AS end_time,
+        MAX(distance) AS max_distance,
+        ROUND(SUM(CASE
+            WHEN diff_alt > 0
+            THEN diff_alt
+            ELSE 0 END))::USMALLINT AS elevation_gain,
+        ABS(ROUND(SUM(CASE
+            WHEN diff_alt < 0
+            THEN diff_alt
+            ELSE 0 END)))::USMALLINT AS elevation_loss,
+        ROUND(AVG(heart_rate))::UTINYINT AS avg_hr,
+        MAX(heart_rate)::UTINYINT AS max_hr,
+        ROUND(AVG(cadence))::UTINYINT AS avg_cadence,
+        MAX(cadence)::UTINYINT AS max_cadence
+    FROM {table_name}
+    GROUP BY lap
+    ORDER BY lap
+), stage_2 AS (
+    SELECT
+        lap,
+        start_time,
+        end_time,
+        LAG(end_time, 1) OVER (ORDER BY lap) AS lap_start_time,
+        LAG(max_distance, 1) OVER (ORDER BY lap) AS lap_start_distance,
+        max_distance,
+        elevation_gain,
+        elevation_loss,
+        avg_hr,
+        max_hr,
+        avg_cadence,
+        max_cadence
+    FROM lap_data
+    ORDER BY lap
+), stage_3 AS (
+    SELECT
+        lap,
+        CASE
+            WHEN lap > 1
+            THEN date_diff('second', lap_start_time , end_time)
+            ELSE date_diff('second', start_time, end_time) END AS elapsed_time,
+        CASE
+            WHEN lap > 1
+            THEN max_distance - lap_start_distance 
+            ELSE max_distance END AS distance_km,
+        CASE
+            WHEN lap > 1
+            THEN (lap_start_distance + distance_km / 2)
+            ELSE (distance_km / 2) END AS midpoint,
+        elevation_gain,
+        elevation_loss,
+        avg_hr,
+        max_hr,
+        avg_cadence,
+        max_cadence
+    FROM stage_2
+    ORDER BY lap
+)
+
+SELECT
+    lap,
+    distance_km AS distance,
+    CASE
+        WHEN elapsed_time == 0
+        THEN 0
+        ELSE (distance_km / elapsed_time * 3600) END AS avg_speed_kph,
+    CASE 
+        WHEN avg_speed_kph == 0
+        THEN NULL
+        ELSE printf(
+            '%02d:%02d',
+            CAST(FLOOR(60 / avg_speed_kph) AS INT),
+            CAST(((60 / avg_speed_kph - FLOOR(60 / avg_speed_kph)) * 60) AS INT)
+        ) END AS avg_pace,
+    midpoint AS midpoint,
+    elevation_gain,
+    elevation_loss,
+    avg_hr,
+    max_hr,
+    avg_cadence,
+    max_cadence
+FROM stage_3
+ORDER BY lap;

gpxtractor/sql/overall_stats.sql

@@ -0,0 +1,42 @@
+WITH overall_stats_stage1 AS (
+    SELECT
+        MIN(timestamp) AS start_time,
+        MAX(timestamp) AS end_time,
+        date_diff('second', start_time, end_time)::INT as elapsed_time,
+        ROUND(MAX(distance), 2)::FLOAT AS total_distance,
+        ROUND((total_distance / elapsed_time) * 3600, 2)::FLOAT AS avg_speed,
+        MAX(speed)::FLOAT AS max_speed,
+        printf(
+            '%02d:%02d',
+            CAST(FLOOR(60 / avg_speed) AS INT),
+            CAST(((60 / avg_speed - FLOOR(60 / avg_speed)) * 60) AS INT)
+        ) AS avg_pace,
+        ROUND(SUM(CASE
+            WHEN diff_alt > 0
+            THEN diff_alt
+            ELSE 0 END))::INTEGER AS elevation_gain,
+        ABS(ROUND(SUM(CASE
+            WHEN diff_alt < 0
+            THEN diff_alt
+            ELSE 0 END)))::INTEGER AS elevation_loss,
+        ROUND(AVG(heart_rate))::UTINYINT as avg_heart_rate,
+        MAX(heart_rate) as max_heart_rate,
+        ROUND(AVG(cadence))::UTINYINT AS avg_cadence,
+        MAX(cadence) AS max_cadence,
+    FROM {table_name}
+)
+
+SELECT
+    start_time,
+    elapsed_time,
+    total_distance AS distance,
+    avg_speed,
+    max_speed,
+    avg_pace,
+    elevation_gain,
+    elevation_loss,
+    avg_heart_rate,
+    max_heart_rate,
+    avg_cadence,
+    max_cadence,
+FROM overall_stats_stage1;

gpxtractor/sql/preprocess_data.sql

@@ -0,0 +1,50 @@
+WITH stage_1 AS (
+    SELECT
+        timestamp,
+        latitude,
+        longitude,
+        altitude,
+        LAG(altitude, 1) OVER (ORDER BY timestamp) AS prev_alt,
+        distance,
+        LAG(distance, 1) OVER (ORDER BY timestamp) AS prev_dist,
+        speed,
+        heart_rate::UTINYINT AS heart_rate,
+        cadence::UTINYINT AS cadence,
+        lap::USMALLINT as lap,
+    FROM {table_name}
+    ORDER BY timestamp
+), stage_2 AS (
+    SELECT
+        ROW_NUMBER() OVER (ORDER BY timestamp) AS index,
+        timestamp,
+        latitude,
+        longitude,
+        altitude,
+        altitude - prev_alt AS diff_alt,
+        distance,
+        distance - prev_dist AS diff_dist,
+        speed AS speed_mps,
+        heart_rate,
+        cadence,
+        lap,
+    FROM stage_1
+    ORDER BY index
+)
+
+SELECT
+    timestamp,
+    latitude,
+    longitude,
+    ROUND(altitude, 2)::FLOAT AS altitude, -- in meters
+    diff_alt,
+    CASE
+        WHEN index > 1
+        THEN ROUND((diff_alt / diff_dist) * 100, 2)::FLOAT
+        ELSE 'NaN'::FLOAT END AS gradient, -- as percentage
+    (distance / 1000)::FLOAT AS distance, -- in km
+    ROUND(speed_mps * 3.6, 2)::FLOAT AS speed, -- in kph
+    heart_rate,
+    cadence, -- in revolutions per minute (unmodified)
+    lap,
+FROM stage_2
+ORDER BY index;

gpxtractor/sql/preprocess_running_data.sql

@@ -0,0 +1,58 @@
+WITH stage_1 AS (
+    SELECT
+        timestamp,
+        latitude,
+        longitude,
+        altitude,
+        LAG(altitude, 1) OVER (ORDER BY timestamp) AS prev_alt,
+        distance,
+        LAG(distance, 1) OVER (ORDER BY timestamp) AS prev_dist,
+        speed,
+        heart_rate::UTINYINT AS heart_rate,
+        (cadence * 2)::UTINYINT AS cadence,
+        lap::USMALLINT as lap,
+    FROM {table_name}
+    ORDER BY timestamp
+), stage_2 AS (
+    SELECT
+        ROW_NUMBER() OVER (ORDER BY timestamp) AS index,
+        timestamp,
+        latitude,
+        longitude,
+        altitude,
+        altitude - prev_alt AS diff_alt,
+        distance,
+        distance - prev_dist AS diff_dist,
+        speed AS speed_mps,
+        heart_rate,
+        cadence,
+        lap,
+    FROM stage_1
+    ORDER BY index
+)
+
+SELECT
+    timestamp,
+    latitude,
+    longitude,
+    ROUND(altitude, 2)::FLOAT AS altitude, -- in meters
+    diff_alt,
+    CASE
+        WHEN index > 1
+        THEN ROUND((diff_alt / diff_dist) * 100, 2)::FLOAT
+        ELSE 'NaN'::FLOAT END AS gradient, -- as percentage
+    (distance / 1000)::FLOAT AS distance, -- in km
+    ROUND(speed_mps * 3.6, 2)::FLOAT AS speed, -- in kph
+    CASE 
+        WHEN speed == 0 OR isnan(speed)
+        THEN NULL
+        ELSE printf(
+            '%02d:%02d',
+            CAST(FLOOR(60 / speed) AS INT),
+            CAST(((60 / speed - FLOOR(60 / speed)) * 60) AS INT))
+    END AS pace,
+    heart_rate,
+    cadence, -- in steps per minute
+    lap,
+FROM stage_2
+ORDER BY index;

gpxtractor-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: gpxtractor
+Version: 0.1.0
+Summary: GPX, TCX and FIT data extraction for Python
+Author-email: Charlie Stapylton <278091496+c-stap@users.noreply.github.com>
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml>=6.0.2
+Requires-Dist: numpy>=2.3.1
+Requires-Dist: pyarrow>=20.0.0
+Requires-Dist: pandas>=2.3.1
+Requires-Dist: duckdb>=1.4.4
+Provides-Extra: cli
+Requires-Dist: visidata; extra == "cli"
+Dynamic: license-file
+
+# gpxtractor
+
+**GPX, TCX and FIT data extraction for Python**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Description
+
+
+## Features
+
+
+## Installation
+
+```bash
+git clone 
+cd gpxtractor
+pip install .
+```
+
+## Usage Example
+Use the `gpxtractor.extract_data` function that returns a gpxtractor.Activity instance.
+
+```python
+import gpxtractor
+
+activity = gpxtractor.extract_data("your-gpx-tcx-or-fit_file.gpx")
+
+print(activity.sport) # Output: name of the sport in the file as a string
+
+```
+
+The records attribute is a `pandas.DataFrame` holding the records extracted from the file\n
+with the `gpxtractor.extract_data` function. So the usual `pandas.DataFrame` methods can be applied
+
+```python
+print(activity.records.head())
+```
+
+Once an instance of an Activity as been created with the `extract_data` function, the method\n
+`transform_records` can be used to calculate distance and speed if missing from the file as well as\n
+elevation incremental difference, gradient and in the case of running activities, pace.
+
+```python
+activity.transform_records()
+print(activity.records.head())
+```
+
+And once the records have been transformed with `transform_records`, it is possible to use the 2\n
+following methods to calculate aggregated data for kilometre and lap splits.
+
+```python
+activity.compute_km_splits()
+print(activity.km_splits)
+
+activity.compute_lap_splits()
+print(activity.lap_splits)
+```
+Note: the `compute_lap_splits` will only compute lap splits if the file contains lap data which is not\n
+the case for GPX files. It does not update the `lap_splits` attribute otherwise.
+
+

gpxtractor-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+gpxtractor/__init__.py,sha256=XDtN5-aHWDjY_wz8lpCWqVbIDGyRZK9dll4KipI5ISs,275
+gpxtractor/_core.py,sha256=aJ4s9fQFxliY-51Yo6g6a2FWq-GVCCzZ3W5mw1uthkw,11069
+gpxtractor/_fit_extraction.py,sha256=Np9rXPXFLmwCHnpJuc1CiCClvaKWD6oiY5JgK2AsHB4,2933
+gpxtractor/_transformation.py,sha256=WVoloI5-b7nYHM3LuxGLy6d_OGBblvfEvnHQaKgoob8,3377
+gpxtractor/_utils.py,sha256=Naa2ZwQm9aBuvN5bEHpAixUgqs_xcKIWE3x0m4ZK4es,887
+gpxtractor/_xml_extraction.py,sha256=29ijNf51iBq08jHSaZtZIAnsRZW9a7b85y6XcTMB0fY,5066
+gpxtractor/cli.py,sha256=2bLVZzDeKfhknKl7leLfdq5t94wvl99W1p1YSKe8vtM,1867
+gpxtractor/sql/compute_distance_and_speed.sql,sha256=bOgO_p1e6R7x-e4QGdloYfjUH2YFVmqZlTSnDWpXMpo,1404
+gpxtractor/sql/compute_speed.sql,sha256=DLxB7HV-cBfGr3pp1uqv30C_tvH8_Y1EvIwC9bJ6_aE,1328
+gpxtractor/sql/haversine_formula.sql,sha256=Rm1MvZ-CohRkG1ydvJl21fjaEnEUUhGlaqMFj4dlVQA,303
+gpxtractor/sql/km_data_query.sql,sha256=KQO2fgpF8jvwaPaXw8qV7ypTOVg7ZLiVTzR_a5ybiPI,2485
+gpxtractor/sql/lap_data_query.sql,sha256=W4eUF3t9fwd5yn8825ZSlj4in4hhmumTesh4h_U6AQ0,2334
+gpxtractor/sql/overall_stats.sql,sha256=U7gZO8EICPagSaUpGYHT197VUhyOysUJYD-00dD1NdE,1295
+gpxtractor/sql/preprocess_data.sql,sha256=lChlMfkIpjNMf6eVEFZME-Vk2_CKCgZDfrLquuIBB5s,1289
+gpxtractor/sql/preprocess_running_data.sql,sha256=obHbGR2I0BwSKv4DmIOAaRDSWjF4ZjG85eYXa4YEULc,1517
+gpxtractor-0.1.0.dist-info/licenses/LICENSE,sha256=yq10OHiKCRtJ9QAdp_Wsdbds46X9ZLfOB4cXjGJOuoM,1067
+gpxtractor-0.1.0.dist-info/METADATA,sha256=tEXhKYPVtpkaqHYmDXt_1sRxg5FFFP_fNi0RYaY5xDw,2143
+gpxtractor-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gpxtractor-0.1.0.dist-info/entry_points.txt,sha256=SOAH_X7mtPe7XiwjnYobOrVpE0Hq1l-VZqiUCHon4gY,51
+gpxtractor-0.1.0.dist-info/top_level.txt,sha256=qhnkz7mFbaMSwYDfPSKSgyn3ViXa2t37GenvvHkKSDo,11
+gpxtractor-0.1.0.dist-info/RECORD,,

gpxtractor-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gpxtractor-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gpxtractor = gpxtractor.cli:main

gpxtractor-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 Charles Stapylton-Smith
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

gpxtractor-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gpxtractor