rowingdata 3.6.26__tar.gz → 3.7.1__tar.gz

{rowingdata-3.6.26/rowingdata.egg-info → rowingdata-3.7.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: rowingdata
-Version: 3.6.26
+Version: 3.7.1
 Summary: The rowingdata library to create colorful plots from CrewNerd, Painsled and other rowing data tools
-Home-page: 
+Home-page: https://github.com/sanderroosendaal/rowingdata
 Author: Sander Roosendaal
 Author-email: roosendaalsander@gmail.com
 License: MIT
@@ -15,6 +15,7 @@ Requires-Dist: scipy
 Requires-Dist: matplotlib
 Requires-Dist: pandas
 Requires-Dist: fitparse
+Requires-Dist: fit-tool>=0.9.14
 Requires-Dist: arrow>=1.0.2
 Requires-Dist: python-dateutil
 Requires-Dist: docopt

rowingdata-3.7.1/rowingdata/fitwrite.py

@@ -0,0 +1,344 @@
+"""
+FIT file export for rowingdata.
+Exports rowingdata DataFrames to Garmin FIT format for compatibility with
+Intervals.icu and other platforms.
+"""
+from __future__ import absolute_import
+from __future__ import print_function
+
+import datetime
+import numpy as np
+from dateutil import parser as ps
+import arrow
+
+try:
+    from fit_tool.base_type import BaseType
+    from fit_tool.developer_field import DeveloperField
+    from fit_tool.fit_file_builder import FitFileBuilder
+    from fit_tool.profile.messages.developer_data_id_message import DeveloperDataIdMessage
+    from fit_tool.profile.messages.field_description_message import FieldDescriptionMessage
+    from fit_tool.profile.messages.file_id_message import FileIdMessage
+    from fit_tool.profile.messages.activity_message import ActivityMessage
+    from fit_tool.profile.messages.session_message import SessionMessage
+    from fit_tool.profile.messages.lap_message import LapMessage
+    from fit_tool.profile.messages.record_message import RecordMessage
+    from fit_tool.profile.messages.event_message import EventMessage
+    from fit_tool.profile.profile_type import (
+        FileType, Manufacturer, Sport, SubSport,
+        Event, EventType, Activity,
+    )
+    FIT_TOOL_AVAILABLE = True
+except ImportError:
+    FIT_TOOL_AVAILABLE = False
+
+# Developer field definitions for rowing-specific columns (no native FIT equivalent).
+# StrokeDistance is here: native cycle_length is uint8/scale100 (max 2.55m), wrong for rowing (7–12m typical).
+# (field_id, df_column, name, base_type, size, scale, units)
+ROWING_DEV_FIELDS = [
+    (0, ' DriveLength (meters)', 'DriveLength', BaseType.UINT16, 2, 100, 'm'),
+    (1, ' DriveTime (ms)', 'DriveTime', BaseType.UINT16, 2, 1, 'ms'),
+    (2, ' DragFactor', 'DragFactor', BaseType.UINT16, 2, 1, ''),
+    (3, ' StrokeRecoveryTime (ms)', 'StrokeRecoveryTime', BaseType.UINT16, 2, 1, 'ms'),
+    (4, ' AverageDriveForce (lbs)', 'AverageDriveForceLbs', BaseType.UINT16, 2, 10, 'lbs'),
+    (5, ' PeakDriveForce (lbs)', 'PeakDriveForceLbs', BaseType.UINT16, 2, 10, 'lbs'),
+    (6, ' AverageDriveForce (N)', 'AverageDriveForceN', BaseType.UINT16, 2, 10, 'N'),
+    (7, ' PeakDriveForce (N)', 'PeakDriveForceN', BaseType.UINT16, 2, 10, 'N'),
+    (8, ' AverageBoatSpeed (m/s)', 'AverageBoatSpeed', BaseType.UINT16, 2, 100, 'm/s'),
+    (9, ' WorkoutState', 'WorkoutState', BaseType.UINT8, 1, 1, ''),
+    (10, ' StrokeDistance (meters)', 'StrokeDistance', BaseType.UINT16, 2, 100, 'm'),
+]
+
+# Sport string to FIT enum mapping
+SPORT_MAP = {
+    'rowing': Sport.ROWING,
+    'water': Sport.ROWING,
+    'indoor_rowing': Sport.ROWING,
+    'indoor rowing': Sport.ROWING,
+    'run': Sport.RUNNING,
+    'running': Sport.RUNNING,
+    'bike': Sport.CYCLING,
+    'cycling': Sport.CYCLING,
+    'swim': Sport.SWIMMING,
+    'swimming': Sport.SWIMMING,
+    'other': Sport.GENERIC,
+}
+
+
+def _valid_position(lat, lon):
+    """True if lat/lon are valid degrees for FIT (rough bounds)."""
+    return (not (np.isnan(lat) or np.isnan(lon)) and
+            -90 <= lat <= 90 and -180 <= lon <= 180 and (lat != 0 or lon != 0))
+
+
+def _sport_to_fit(sport_str):
+    """Map sport string to FIT Sport enum."""
+    if sport_str is None:
+        return Sport.ROWING
+    key = str(sport_str).lower().strip()
+    return SPORT_MAP.get(key, Sport.ROWING)
+
+
+def write_fit(file_name, df, row_date="2016-01-01", notes="Exported by Rowingdata",
+              sport="rowing", use_developer_fields=True):
+    """
+    Write rowingdata DataFrame to a FIT activity file.
+
+    Parameters
+    ----------
+    file_name : str
+        Output file path (e.g. 'activity.fit')
+    df : pandas.DataFrame
+        DataFrame with rowingdata columns (TimeStamp, Horizontal, Cadence, etc.)
+    row_date : str or datetime
+        Workout date (used when timestamps are relative)
+    notes : str
+        Activity notes
+    sport : str
+        Sport type: 'rowing', 'indoor_rowing', 'other', etc.
+    use_developer_fields : bool
+        If True, include rowing-specific columns as developer fields when present.
+        If False, export only standard FIT fields (timestamp, distance, cadence,
+        heart_rate, power, speed, position).
+    """
+    if not FIT_TOOL_AVAILABLE:
+        raise ImportError("fit-tool is required for FIT export. Install with: pip install fit-tool")
+
+    # Get or compute cum_dist
+    if 'cum_dist' not in df.columns and ' Horizontal (meters)' in df.columns:
+        from .csvparsers import make_cumvalues
+        res = make_cumvalues(df[' Horizontal (meters)'])
+        df = df.copy()
+        df['cum_dist'] = res[0]
+
+    nr_rows = len(df)
+    if nr_rows == 0:
+        raise ValueError("Cannot export empty DataFrame to FIT")
+
+    # Parse row_date and determine timestamps
+    dateobj = ps.parse(str(row_date))
+    timezero = arrow.get(datetime.datetime(2000, 1, 1)).timestamp()
+    seconds = df['TimeStamp (sec)'].values
+
+    if seconds[0] < timezero:
+        # Relative timestamps: add row_date
+        unixtimes = seconds + arrow.get(dateobj).timestamp()
+    else:
+        unixtimes = seconds
+
+    # FIT timestamps in milliseconds (fit-tool convention for timestamp fields)
+    start_time_ms = int(unixtimes[0] * 1000)
+    total_elapsed_ms = int((unixtimes[-1] - unixtimes[0]) * 1000) if nr_rows > 1 else 0
+    total_elapsed_s = (unixtimes[-1] - unixtimes[0]) if nr_rows > 1 else 0.0  # seconds, for Activity/Session/Lap
+
+    # Arrays for record messages
+    try:
+        distance_m = df['cum_dist'].values
+    except KeyError:
+        distance_m = df[' Horizontal (meters)'].values
+
+    try:
+        cadence = np.round(df[' Cadence (stokes/min)'].values).astype(int)
+    except KeyError:
+        cadence = np.zeros(nr_rows, dtype=int)
+
+    try:
+        heart_rate = df[' HRCur (bpm)'].values.astype(int)
+        heart_rate = np.clip(heart_rate, 0, 255)  # uint8
+    except KeyError:
+        heart_rate = np.zeros(nr_rows, dtype=int)
+
+    try:
+        power = df[' Power (watts)'].values.astype(int)
+        power = np.clip(power, 0, 65535)  # uint16
+    except KeyError:
+        power = np.zeros(nr_rows, dtype=int)
+
+    try:
+        pace = df[' Stroke500mPace (sec/500m)'].values
+        # enhanced_speed in m/s; avoid div by zero
+        pace_safe = np.where(pace > 0, pace, np.inf)
+        enhanced_speed = 500.0 / pace_safe
+        enhanced_speed = np.where(np.isfinite(enhanced_speed), enhanced_speed, 0)
+    except KeyError:
+        enhanced_speed = np.zeros(nr_rows)
+
+    try:
+        lat = df[' latitude'].values
+        lon = df[' longitude'].values
+    except KeyError:
+        lat = np.zeros(nr_rows)
+        lon = np.zeros(nr_rows)
+
+    # Developer fields: which columns exist and their arrays
+    use_dev = use_developer_fields and FIT_TOOL_AVAILABLE
+    dev_arrays = {}
+    dev_specs = []
+    DEV_DATA_IDX = 0
+    if use_dev:
+        for fd in ROWING_DEV_FIELDS:
+            field_id, col, name, base_type, size, scale, units = fd
+            if col in df.columns:
+                arr = df[col].values
+                arr = np.nan_to_num(arr, nan=0.0, posinf=0.0, neginf=0.0)
+                # Clip to avoid overflow: encoded = value * scale must fit in base_type
+                if base_type == BaseType.UINT8:
+                    arr = np.clip(arr, 0, 255)
+                elif base_type == BaseType.UINT16:
+                    max_display = 65535.0 / scale if scale else 65535.0
+                    arr = np.clip(arr, 0, max_display)
+                dev_arrays[field_id] = arr
+                dev_specs.append((field_id, col, name, base_type, size, scale, units))
+
+    # Build FIT file
+    min_str = 50 if dev_specs else 8
+    builder = FitFileBuilder(auto_define=True, min_string_size=min_str)
+
+    # File ID
+    file_id = FileIdMessage()
+    file_id.type = FileType.ACTIVITY
+    file_id.manufacturer = Manufacturer.GARMIN.value
+    file_id.product = 0
+    file_id.time_created = start_time_ms
+    file_id.serial_number = 0x12345678
+    builder.add(file_id)
+
+    # Activity message
+    activity = ActivityMessage()
+    activity.timestamp = start_time_ms
+    activity.total_timer_time = total_elapsed_s  # seconds; fit-tool applies scale 1000
+    activity.num_sessions = 1
+    activity.type = Activity.MANUAL
+    activity.event = Event.TIMER
+    activity.event_type = EventType.START
+    builder.add(activity)
+
+    # Timer start event
+    event_start = EventMessage()
+    event_start.event = Event.TIMER
+    event_start.event_type = EventType.START
+    event_start.timestamp = start_time_ms
+    builder.add(event_start)
+
+    # Session message
+    total_dist = float(distance_m[-1]) if nr_rows > 0 else 0
+    try:
+        total_calories = int(df[' Calories (kCal)'].max())
+    except (KeyError, ValueError):
+        total_calories = 0
+
+    avg_hr = int(np.mean(heart_rate[heart_rate > 0])) if np.any(heart_rate > 0) else 0
+    max_hr = int(np.max(heart_rate)) if nr_rows > 0 else 0
+    avg_cadence = int(np.mean(cadence[cadence > 0])) if np.any(cadence > 0) else 0
+    avg_power = int(np.mean(power[power > 0])) if np.any(power > 0) else 0
+
+    session = SessionMessage()
+    session.message_index = 0
+    session.timestamp = start_time_ms
+    session.start_time = start_time_ms
+    session.total_elapsed_time = total_elapsed_s  # seconds; fit-tool applies scale 1000
+    session.total_timer_time = total_elapsed_s
+    session.total_distance = int(round(total_dist))  # fit-tool applies scale 100
+    session.total_calories = total_calories
+    session.sport = _sport_to_fit(sport)
+    session.sub_sport = SubSport.GENERIC
+    if avg_hr > 0:
+        session.avg_heart_rate = avg_hr
+    if max_hr > 0:
+        session.max_heart_rate = max_hr
+    if avg_cadence > 0:
+        session.avg_cadence = avg_cadence
+    if avg_power > 0:
+        session.avg_power = avg_power
+    builder.add(session)
+
+    # Lap message (one lap for the whole session for now)
+    lap = LapMessage()
+    lap.message_index = 0
+    lap.timestamp = int(unixtimes[-1] * 1000) if nr_rows > 0 else start_time_ms
+    lap.start_time = start_time_ms
+    lap.total_elapsed_time = total_elapsed_s  # seconds; fit-tool applies scale 1000
+    lap.total_timer_time = total_elapsed_s
+    lap.total_distance = int(round(total_dist))  # fit-tool applies scale 100
+    lap.total_calories = total_calories
+    lap.sport = _sport_to_fit(sport)
+    lap.sub_sport = SubSport.GENERIC
+    if avg_hr > 0:
+        lap.avg_heart_rate = avg_hr
+    if max_hr > 0:
+        lap.max_heart_rate = max_hr
+    if avg_cadence > 0:
+        lap.avg_cadence = avg_cadence
+    if avg_power > 0:
+        lap.avg_power = avg_power
+    # fit-tool expects position in degrees (it applies semicircle conversion internally)
+    if _valid_position(lat[0], lon[0]) and _valid_position(lat[-1], lon[-1]):
+        lap.start_position_lat = float(lat[0])
+        lap.start_position_long = float(lon[0])
+        lap.end_position_lat = float(lat[-1])
+        lap.end_position_long = float(lon[-1])
+    builder.add(lap)
+
+    # Developer data (ID + field descriptions) when we have developer fields
+    DEV_DATA_IDX = 0
+    if dev_specs:
+        dev_id_msg = DeveloperDataIdMessage()
+        dev_id_msg.application_id = b'rowingdata'
+        dev_id_msg.developer_data_index = DEV_DATA_IDX
+        builder.add(dev_id_msg)
+        for field_id, col, name, base_type, size, scale, units in dev_specs:
+            fd_msg = FieldDescriptionMessage()
+            fd_msg.developer_data_index = DEV_DATA_IDX
+            fd_msg.field_definition_number = field_id
+            fd_msg.fit_base_type_id = base_type.value
+            fd_msg.field_name = name
+            fd_msg.scale = int(scale) if scale == int(scale) else scale
+            fd_msg.offset = 0
+            fd_msg.units = units
+            builder.add(fd_msg)
+
+    # Record messages
+    for i in range(nr_rows):
+        dev_fields = []
+        if dev_specs:
+            for field_id, col, name, base_type, size, scale, units in dev_specs:
+                arr = dev_arrays[field_id]
+                val = float(arr[i])
+                if val != 0 or field_id == 9:  # WorkoutState can be 0
+                    # Pass display value; fit-tool encodes as raw = (value + offset) * scale.
+                    # FieldDescription has same scale so readers decode: display = raw/scale.
+                    dev = DeveloperField(
+                        developer_data_index=DEV_DATA_IDX,
+                        field_id=field_id,
+                        size=size,
+                        name=name,
+                        base_type=base_type,
+                        scale=scale,
+                        offset=0,
+                        units=units
+                    )
+                    dev.set_value(0, val)
+                    dev_fields.append(dev)
+        rec = RecordMessage(developer_fields=dev_fields) if dev_fields else RecordMessage()
+        rec.timestamp = int(unixtimes[i] * 1000)
+        rec.distance = float(distance_m[i])  # fit-tool applies scale 100
+        rec.heart_rate = heart_rate[i] if heart_rate[i] > 0 else None
+        rec.cadence = cadence[i] if cadence[i] > 0 else None
+        rec.power = power[i] if power[i] > 0 else None
+        # fit-tool expects display value (m/s); it applies scale 1000 internally
+        rec.enhanced_speed = float(enhanced_speed[i]) if enhanced_speed[i] > 0 else None
+
+        if not (np.isnan(lat[i]) or lat[i] == 0) and not (np.isnan(lon[i]) or lon[i] == 0):
+            rec.position_lat = float(lat[i])
+            rec.position_long = float(lon[i])
+
+        builder.add(rec)
+
+    # Timer stop event
+    event_stop = EventMessage()
+    event_stop.event = Event.TIMER
+    event_stop.event_type = EventType.STOP_ALL
+    event_stop.timestamp = int(unixtimes[-1] * 1000) if nr_rows > 0 else start_time_ms
+    builder.add(event_stop)
+
+    fit_file = builder.build()
+    fit_file.to_file(file_name)

{rowingdata-3.6.26 → rowingdata-3.7.1}/rowingdata/rowingdata.py

@@ -5,7 +5,7 @@ from __future__ import print_function
 from six.moves import range
 from six.moves import input
 
-__version__ = "3.6.26"
+__version__ = "3.7.1"
 
 from collections import Counter
 
@@ -83,10 +83,12 @@ try:
     from . import gpxwrite
     from . import trainingparser
     from . import writetcx
+    from . import fitwrite
 except (ValueError,ImportError): # pragma: no cover
     import rowingdata.gpxwrite
     import rowingdata.trainingparser
     import rowingdata.writetcx
+    import rowingdata.fitwrite
 
 import requests
 
@@ -166,7 +168,7 @@ def main(): # pragma: no cover
 def my_autopct(pct, cutoff=5): # pragma: no cover
     return ('%4.1f%%' % pct) if pct > cutoff else ''
 
-def nanstozero(nr):
+def nanstozero(nr: float) -> float:
     if isnan(nr) or isinf(nr):
         return 0
     else:
@@ -187,7 +189,7 @@ def post_progress(secret,progressurl,progress): # pragma: no cover
 
 
 # toekomstmuziek - nog niet gebruikt
-def make_subplot(ax,r,df,param,mode=['distance','ote'],bars=None,barnames=None): # pragma: no cover
+def make_subplot(ax,r,df,param,mode=['distance','ote'],bars=None,barnames=None,barlimits=None,barverbosenames=None): # pragma: no cover
     if 'distance' in mode:
         xcolumn = 'cum_dist'
         dist_max = 1000
@@ -207,10 +209,13 @@ def make_subplot(ax,r,df,param,mode=['distance','ote'],bars=None,barnames=None):
         if barlimits is None:
             barlimits = ['lim_ut2','lim_ut1','lim_at','lim_tr','lim_an','lim_max']
         if barverbosenames is None:
-            barverbosenames = list(self.rwr.hrzones)
+            barverbosenames = list(r.rwr.hrzones)
 
     colors = ['gray','y','g','blue','violet','r']
 
+    dist_increments = df.loc[:, xcolumn].diff()
+    dist_increments[0] = dist_increments[1]
+
     for i in range(len(bars)):
         ax.bar(df.loc[:,xcolumn],df.loc[:,barnames[i]],
                width=dist_increments,
@@ -259,11 +264,12 @@ def make_subplot(ax,r,df,param,mode=['distance','ote'],bars=None,barnames=None):
             majorLocator = (1000)
 
 
+    majorTickFormatter = FuncFormatter(format_pace_tick)
     ax.yaxis.set_major_formatter(majorTickFormatter)
     if 'time' in mode:
         ax.set_xlabel('Time (sec)')
     else:
-        ax.set_axlabel('Distance (m)')
+        ax.set_xlabel('Distance (m)')
 
     if end_dist < dist_max:
         ax.set_xticks(list(range(dist_tick, end_dist, dist_tick)))
@@ -1228,7 +1234,7 @@ class summarydata: # pragma: no cover
                 totmin = totmin + 1
 
             stri2 += "{nr:0>2}{sep}{td:0>5}{sep} {inttime:0>5} {sep}".format(
-                nr=i + 1,
+                nr=index + 1,
                 sep=separator,
                 td=td,
                 inttime=inttime
@@ -1676,7 +1682,7 @@ def boatedit(fileName="my1x.txt"): # pragma: no cover
         ))
         if (strin != ""):
             try:
-                rg.spread = float(spread)
+                rg.spread = float(strin)
             except ValueError:
                 print("Not a valid number. Keeping original value")
     else:
@@ -1688,7 +1694,7 @@ def boatedit(fileName="my1x.txt"): # pragma: no cover
         ))
         if (strin != ""):
             try:
-                rg.span = float(span)
+                rg.span = float(strin)
             except ValueError:
                 print("Not a valid number. Keeping original value")
 
@@ -2178,6 +2184,67 @@ class rowingdata:
     """
 
     def __init__(self, *args, **kwargs):
+        """Initialize a rowingdata object from a CSV file or pandas DataFrame.
+        
+        This is the main class for reading and analyzing rowing workout data.
+        It parses CSV files from various rowing ergometer and on-the-water 
+        rowing systems, performs data validation and enrichment, and provides
+        methods for analysis, visualization, and export.
+        
+        Parameters
+        ----------
+        csvfile : str, optional
+            Path to the CSV file containing rowing data. Can be gzipped (.gz).
+            If not provided, a DataFrame must be passed via the 'df' parameter.
+        df : pandas.DataFrame, optional
+            A pre-loaded DataFrame containing rowing data. If provided, csvfile
+            is ignored.
+        rower : rowingdata.rower, optional
+            A rower object containing personal data (HR thresholds, FTP, etc.).
+            Defaults to a new rower() instance with default values.
+        rowtype : str, optional
+            Type of rowing data ('Indoor Rower', 'OTW', etc.). 
+            Defaults to 'Indoor Rower'.
+        absolutetimestamps : bool, optional
+            If True, timestamps are kept as Unix time (seconds since 1970).
+            If False (default), timestamps are relative to workout start.
+        debug : bool, optional
+            If True, enables debug output. Defaults to False.
+        
+        Attributes
+        ----------
+        df : pandas.DataFrame
+            The main data frame containing all rowing metrics.
+        readfilename : str
+            Name of the source file or 'rowing dataframe' if created from df.
+        rwr : rowingdata.rower
+            The rower object with personal training zones.
+        rowtype : str
+            Type of rowing data.
+        empty : bool
+            True if the DataFrame is empty.
+        duration : float
+            Total workout duration in seconds.
+        dragfactor : float
+            Drag factor from the rowing data (for ergometer data).
+        stroke_count : int
+            Total number of strokes in the workout.
+        
+        Examples
+        --------
+        >>> # Load from CSV file
+        >>> row = rowingdata(csvfile="workout.csv")
+        >>> row.summary()
+        
+        >>> # Load from DataFrame
+        >>> import pandas as pd
+        >>> df = pd.read_csv("workout.csv")
+        >>> row = rowingdata(df=df)
+        
+        >>> # With custom rower data
+        >>> my_rower = rower(hrut2=140, hrmax=190, ftp=250)
+        >>> row = rowingdata(csvfile="workout.csv", rower=my_rower)
+        """
 
         if 'debug' in kwargs: # pragma: no cover
             debug = kwargs['debug']
@@ -3061,6 +3128,36 @@ class rowingdata:
             with open(fileName,'wb+') as f_out:
                 f_out.write(bytes)
 
+    def exporttofit(self, fileName, notes="Exported by Rowingdata",
+                    sport="rowing", use_developer_fields=True):
+        """Export rowingdata to FIT format for Intervals.icu and other platforms.
+
+        Parameters
+        ----------
+        fileName : str
+            Output file path (e.g. 'activity.fit')
+        notes : str
+            Activity notes
+        sport : str
+            Sport type: 'rowing', 'indoor_rowing', 'water', 'other'
+        use_developer_fields : bool
+            If True, include rowing-specific columns (DriveLength, StrokeDistance,
+            etc.) when present. Requires fit-tool and Intervals.icu importer support.
+        """
+        if not self.empty:
+            df = self.df.copy()
+            res = make_cumvalues(df[' Horizontal (meters)'])
+            df[' Horizontal (meters)'] = res[0]
+            df['cum_dist'] = res[0]
+            fitwrite.write_fit(
+                fileName, df,
+                row_date=self.rowdatetime.isoformat(),
+                notes=notes, sport=sport,
+                use_developer_fields=use_developer_fields
+            )
+        else:  # pragma: no cover
+            raise ValueError("Cannot export empty rowingdata session to FIT")
+
     def split_by_intervals(self):
         """ Returns the work intervals as separate rowingdata objects"""
         if self.empty:

{rowingdata-3.6.26 → rowingdata-3.7.1}/rowingdata/tcxtools.py

@@ -380,16 +380,35 @@ def tcxtodf3(path):
                 extensions_element = trackpoint.find(".//{http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2}Extensions")
                 if extensions_element is not None:
                     # print child elements of extensions_element
-                    watts_node = extensions_element.find(".//{http://www.garmin.com/xmlschemas/ActivityExtension/v2}TPX/{http://www.garmin.com/xmlschemas/ActivityExtension/v2}Watts")
+                    # looks like so
+                    #<ns0:Extensions xmlns:ns0="http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2" xmlns:ns1="http://www.garmin.com/xmlschemas/ActivityExtension/v2">
+                    #<ns1:ActivityTrackpointExtension>
+                    #  <ns0:Extensions>
+                    #    <ns0:Check>29</ns0:Check>
+                    #    <ns0:Bounce>1</ns0:Bounce>
+                    #    <ns0:Speed>0.23</ns0:Speed>
+                    #    <ns0:AvgSpeed>2.29</ns0:AvgSpeed>
+                    #    <ns0:Mps>0.00</ns0:Mps>
+                    #  </ns0:Extensions>
+                    #</ns1:ActivityTrackpointExtension>
+                    #</ns0:Extensions>
+                    # extract Check and Watts from the extensions
+                    watts_node = extensions_element.find(".//{http://www.garmin.com/xmlschemas/ActivityExtension/v2}ActivityTrackpointExtension/{http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2}Extensions/{http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2}Watts")
+                    check_factor = extensions_element.find(".//{http://www.garmin.com/xmlschemas/ActivityExtension/v2}ActivityTrackpointExtension/{http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2}Extensions/{http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2}Check")
+
+                    if watts_node is None:
+                        watts_node = extensions_element.find(".//{http://www.garmin.com/xmlschemas/ActivityExtension/v2}TPX/{http://www.garmin.com/xmlschemas/ActivityExtension/v2}Watts")
                     
                     watts = float(clean_string(watts_node.text)) if watts_node is not None else 0
 
-                    check_factor = extensions_element.find(".//{http://www.garmin.com/xmlschemas/ActivityExtension/v2}TPX/{http://www.garmin.com/xmlschemas/ActivityExtension/v2}Check")
+                    #check_factor = extensions_element.find(".//{http://www.garmin.com/xmlschemas/ActivityExtension/v2}TPX/{http://www.garmin.com/xmlschemas/ActivityExtension/v2}Check")
                     try:
                         check_factor = float(clean_string(check_factor.text)) if check_factor is not None else 0
                     except ValueError:
                         check_factor = 0
 
+
+
                 speed_node = trackpoint.find(".//{http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2}Speed")
                 speed = float(clean_string(speed_node.text)) if speed_node is not None else 0
 

{rowingdata-3.6.26 → rowingdata-3.7.1/rowingdata.egg-info}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: rowingdata
-Version: 3.6.26
+Version: 3.7.1
 Summary: The rowingdata library to create colorful plots from CrewNerd, Painsled and other rowing data tools
-Home-page: 
+Home-page: https://github.com/sanderroosendaal/rowingdata
 Author: Sander Roosendaal
 Author-email: roosendaalsander@gmail.com
 License: MIT
@@ -15,6 +15,7 @@ Requires-Dist: scipy
 Requires-Dist: matplotlib
 Requires-Dist: pandas
 Requires-Dist: fitparse
+Requires-Dist: fit-tool>=0.9.14
 Requires-Dist: arrow>=1.0.2
 Requires-Dist: python-dateutil
 Requires-Dist: docopt

{rowingdata-3.6.26 → rowingdata-3.7.1}/rowingdata.egg-info/SOURCES.txt

@@ -63,6 +63,7 @@ rowingdata/ergdatatotcx.py
 rowingdata/ergstickplot.py
 rowingdata/ergstickplottime.py
 rowingdata/ergsticktotcx.py
+rowingdata/fitwrite.py
 rowingdata/gpxtools.py
 rowingdata/gpxwrite.py
 rowingdata/konkatenaadje.py
@@ -128,6 +129,7 @@ testdata/boatcoach.csv
 testdata/boatcoach_fixed_distance.csv
 testdata/boatcoach_otw.csv
 testdata/correctedpainsled.csv
+testdata/cottwich.csv
 testdata/coxmate.csv
 testdata/crewnerd_interval.csv
 testdata/crewnerddata.CSV

{rowingdata-3.6.26 → rowingdata-3.7.1}/rowingdata.egg-info/requires.txt

@@ -4,6 +4,7 @@ scipy
 matplotlib
 pandas
 fitparse
+fit-tool>=0.9.14
 arrow>=1.0.2
 python-dateutil
 docopt