rowingdata 3.6.6__tar.gz → 3.6.7__tar.gz

{rowingdata-3.6.6/rowingdata.egg-info → rowingdata-3.6.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rowingdata
-Version: 3.6.6
+Version: 3.6.7
 Summary: The rowingdata library to create colorful plots from CrewNerd, Painsled and other rowing data tools
 Home-page: 
 Author: Sander Roosendaal
@@ -9,6 +9,25 @@ License: MIT
 Keywords: rowing ergometer concept2
 Classifier: Programming Language :: Python :: 3
 License-File: LICENSE
+Requires-Dist: Cython
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: fitparse
+Requires-Dist: arrow>=1.0.2
+Requires-Dist: python-dateutil
+Requires-Dist: docopt
+Requires-Dist: tqdm
+Requires-Dist: rowingphysics>=0.2.3
+Requires-Dist: iso8601
+Requires-Dist: lxml
+Requires-Dist: xmltodict
+Requires-Dist: nose_parameterized
+Requires-Dist: timezonefinder
+Requires-Dist: pycairo
+Requires-Dist: tk
+Requires-Dist: requests
 
 **************
 Rowingdata

{rowingdata-3.6.6 → rowingdata-3.6.7}/rowingdata/checkdatafiles.py

@@ -1,5 +1,6 @@
 from __future__ import absolute_import
 from __future__ import print_function
+import polars as pl
 
 try:
     from . import rowingdata
@@ -151,6 +152,11 @@ def checkfile(f2, verbose=False):
     else:
         row = rowingdata.rowingdata(csvfile=f2)
 
+    row.write_csv(f2+'pl.csv')
+    row2 = rowingdata.rowingdata_pl(csvfile=f2 + 'pl.csv')
+    os.remove(f2 + 'pl.csv')
+    row2 = rowingdata.rowingdata_pl(df=pl.from_pandas(row.df))
+
     nr_of_rows = row.number_of_rows
     distmax = row.df['cum_dist'].max()
     timemax = row.df['TimeStamp (sec)'].max() - row.df['TimeStamp (sec)'].min()

{rowingdata-3.6.6 → rowingdata-3.6.7}/rowingdata/csvparsers.py

@@ -1969,10 +1969,18 @@ class HeroParser(CSVParser):
 
 class SmartRowParser(CSVParser):
     def __init__(self, *args, **kwargs):
+        if args:
+            csvfile = args[0]
+        else: # pragma: no cover
+            csvfile = kwargs['csvfile']
+
+        separator = get_separator(5, csvfile)
+        kwargs['sep'] = separator
+
         super(SmartRowParser, self).__init__(*args, **kwargs)
 
         self.cols = [
-            'Second (#)',
+            'Timestamp (UTC)',
             'Distance (m)',
             'Stroke rate (SPM)',
             'Heart rate (bpm)',
@@ -1986,7 +1994,7 @@ class SmartRowParser(CSVParser):
             '', #' AverageDriveForce (lbs)',
             '', #' PeakDriveForce (lbs)',
             '', #' lapIdx',
-            '', #Second (#)',
+            'Second (#)',
             '', #' latitude',
             '', #' longitude',
             ]

{rowingdata-3.6.6 → rowingdata-3.6.7}/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.6"
+__version__ = "3.6.7"
 
 from collections import Counter
 
@@ -40,7 +40,7 @@ import math
 from math import cos
 
 import pickle
-
+import gzip
 import time
 import warnings
 import sys
@@ -58,6 +58,7 @@ import numpy as np
 from numpy import isinf, isnan
 
 import pandas as pd
+import polars as pl
 from pandas import DataFrame, Series
 
 
@@ -1778,6 +1779,40 @@ def addpowerzones(df, ftp, powerperc):
 
     return df
 
+def addpowerzones_pl(df, ftp, powerperc):
+    percut2, percut1, percat, perctr, percan = np.array(powerperc) / 100.
+
+    ut2, ut1, at, tr, an = ftp * np.array(powerperc) / 100.
+
+    df = df.with_columns([
+        (pl.when(pl.col(" Power (watts)") <= ut2).then(pl.col(" Power (watts)"))
+         .otherwise(pl.lit(0))).alias("pw_ut2"),
+        (pl.when(pl.col(" Power (watts)") > ut2, pl.col(" Power (watts)") <= ut1).then(pl.col(" Power (watts)"))
+         .otherwise(pl.lit(0))).alias("pw_ut1"),
+        (pl.when(pl.col(" Power (watts)") > ut1, pl.col(" Power (watts)") <= at).then(pl.col(" Power (watts)"))
+         .otherwise(pl.lit(0))).alias("pw_at"),
+        (pl.when(pl.col(" Power (watts)") > at, pl.col(" Power (watts)") <= tr).then(pl.col(" Power (watts)")).otherwise(pl.lit(0))).alias("pw_tr"),
+        (pl.when(pl.col(" Power (watts)") > tr, pl.col(" Power (watts)") <= an).then(pl.col(" Power (watts)")).otherwise(pl.lit(0))).alias("pw_an"),
+        (pl.when(pl.col(" Power (watts)") > an, pl.col(" Power (watts)") <= 360).then(pl.col(" Power (watts)")).otherwise(pl.lit(0))).alias("pw_max"),
+    ]
+                         )
+
+    return df
+
+
+def addzones_pl(df, ut2, ut1, at, tr, an, mmax):
+    df = df.with_columns([
+        (pl.when(pl.col(" HRCur (bpm)") <= ut2).then(pl.col(" HRCur (bpm)")).otherwise(pl.lit(0))).alias("hr_ut2"),
+        (pl.when(pl.col(" HRCur (bpm)") > ut2, pl.col(" HRCur (bpm)") <= ut1).then(pl.col(" HRCur (bpm)")).otherwise(pl.lit(0))).alias("hr_ut1"),
+        (pl.when(pl.col(" HRCur (bpm)") > ut1, pl.col(" HRCur (bpm)") <= at).then(pl.col(" HRCur (bpm)")).otherwise(pl.lit(0))).alias("hr_at"),
+        (pl.when(pl.col(" HRCur (bpm)") > at, pl.col(" HRCur (bpm)") <= tr).then(pl.col(" HRCur (bpm)")).otherwise(pl.lit(0))).alias("hr_tr"),
+        (pl.when(pl.col(" HRCur (bpm)") > tr, pl.col(" HRCur (bpm)") <= an).then(pl.col(" HRCur (bpm)")).otherwise(pl.lit(0))).alias("hr_an"),
+        (pl.when(pl.col(" HRCur (bpm)") > an, pl.col(" HRCur (bpm)") <= 360).then(pl.col(" HRCur (bpm)")).otherwise(pl.lit(0))).alias("hr_max"),
+    ]
+                         )
+
+    return df
+
 def addzones(df, ut2, ut1, at, tr, an, mmax):
         # define an additional data frame that will hold the multiple bar plot data and the hr
         # limit data for the plot, it also holds a cumulative distance column
@@ -1868,6 +1903,249 @@ def getaddress(spm,vw,vb):
 
     return i,j,k
 
+
+class rowingdata_pl:
+    """
+    This is used if you want to get a polars DataFrame. This class is much more finicky about
+    the data, and might fail reading a csv file where the class rowingdata succeeds.
+
+    There are no plans to exactly reproduce the pandas version's functionality here.
+
+    The intention is to be strict about the width and data types of the resulting data frame. 
+    """
+    def __init__(self, *args, **kwargs):
+        if 'debug' in kwargs: # pragma: no cover
+            debug = kwargs['debug']
+        else:
+            debug = False
+
+        self.debug = debug
+
+        readFile = None
+        if 'csvfile' in kwargs:
+            readFile = kwargs['csvfile']
+
+        rwr = kwargs.get('rower', rower())
+
+        rowtype = kwargs.get('rowtype', 'Indoor Rower')
+            
+
+        sled_df = pl.DataFrame()
+        if 'df' in kwargs:
+            sled_df = kwargs['df']
+            readFile = None
+        elif readFile:
+            try:
+                try:
+                    sled_df = pl.read_csv(readFile,encoding='utf-8', infer_schema_length=1000)
+                except IOError: # pragma: no cover
+                    sled_df = pl.read_csv(readFile + '.gz',encoding='utf-8')
+                except:
+                    sled_df = pl.DataFrame()
+            except IOError: # pragma: no cover
+                try:
+                    f = open(readFile)
+                    sled_df = pl.read_csv(f)
+                    f.close()
+                except IOError:
+                    try:
+                        f = open(readFile + '.gz')
+                        sled_df = pl.read_csv(f)
+                        f.close()
+                    except:
+                        sled_df = pl.DataFrame()
+            except UnicodeEncodeError: # pragma: no cover
+                try:
+                    f = open(readFile)
+                    sled_df = pl.read_csv(f)
+                    f.close()
+                except IOError:
+                    try:
+                        f = open(readFile + '.gz')
+                        sled_df = pl.read_csv(f)
+                        f.close()
+                    except:
+                        sled_df = pl.DataFrame()
+
+
+        self.readfilename = 'rowing dataframe'
+
+        if readFile:
+            try:
+                self.readfilename = readFile.name
+            except AttributeError:
+                self.readfilename = readFile
+
+        self.readFile = readFile
+        self.rwr = rwr
+        self.rowtype = rowtype
+
+        self.empty = False
+        if sled_df.is_empty():
+            self.empty = True
+
+        othernames = ['catch','finish','peakforceangle',
+                      'wash','slip','index',
+                      'cum_dist',
+                      'hr_an','hr_at','hr_tr','hr_ut1','hr_ut2','hr_max',
+#                      'lim_an','lim_at','lim_tr','lim_ut1','lim_ut2',
+#                      'limpw_an','limpw_at','limpw_tr',
+#                      'limpw_ut1','limpw_ut2',
+                      'pw_an','pw_at','pw_max','pw_tr','pw_ut1','pw_ut2',
+#                      'lim_max','hr_max',
+                      ' latitude',' longitude']
+
+        # check for missing column names
+        mandatorynames = [
+            'TimeStamp (sec)',
+            ' Horizontal (meters)',
+            ' Cadence (stokes/min)',
+            ' HRCur (bpm)',
+            ' Stroke500mPace (sec/500m)',
+            ' Power (watts)',
+            ' DriveLength (meters)',
+            ' StrokeDistance (meters)',
+            ' DriveTime (ms)',
+            ' DragFactor',
+            ' StrokeRecoveryTime (ms)',
+            ' AverageDriveForce (lbs)',
+            ' AverageBoatSpeed (m/s)',
+            ' PeakDriveForce (lbs)',
+            ' AverageDriveForce (N)',
+            ' PeakDriveForce (N)',
+            ' lapIdx',
+            ' ElapsedTime (sec)',
+            ' Calories (kCal)',
+            ' WorkoutState',
+        ]
+
+
+        self.defaultnames = othernames+mandatorynames
+
+        if readFile and not sled_df.is_empty():
+            for name in self.defaultnames:
+                if name in sled_df.columns:
+                    if sled_df[name].dtype == pl.String:
+                        if name != ' lapIdx':
+                            sled_df = sled_df.with_columns(
+                                (pl.col(name).str.strip_chars_start()).cast(pl.Float64).alias(name)
+                            )
+                
+
+        if ' ElapsedTime (sec)' not in sled_df.columns and not sled_df.is_empty():
+            sled_df = sled_df.with_columns((pl.col("TimeStamp (sec)")-sled_df[0, "TimeStamp (sec)"]).alias(" ElapsedTime (sec)"))
+
+        if not sled_df.is_empty():
+            for name in self.defaultnames:
+                if name not in sled_df.columns:
+                    if debug:
+                        print(name + " is not found in data")
+                    sled_df = sled_df.with_columns((pl.lit(0)).alias(name))
+                    if name == "TimeStamp (sec)":
+                        sled_df = sled_df.rename({"TimeStamp (sec utc)" : name})
+                    if name == ' WorkoutState':
+                        sled_df = sled_df.with_columns((pl.lit(4)).alias(name))
+                    if name == ' Calories (kCal)':
+                        sled_df = sled_df.with_columns((pl.lit(1)).alias(name))
+                    if name == ' Stroke500mPace (sec/500m)': # pragma: no cover
+                        dd = sled_df[' Horizontal (meters)'].diff()
+                        dt = sled_df[' ElapsedTime (sec)'].diff()
+                        velo = dd / dt
+                        sled_df = sled_df.with_columns((500. / velo).alias(name))
+                    if name == ' AverageBoatSpeed (m/s)':
+                        try:
+                            velo = 500./sled_df[' Stroke500mPace (sec/500m)']
+                        except (KeyError,ValueError): # pragma: no cover
+                            dd = sled_df[' Horizontal (meters)'].diff()
+                            dt = sled_df[' ElapsedTime (sec)'].diff()
+                            velo = dd / dt
+                        sled_df = sled_df.with_columns((velo).alias(name))
+                    if name == ' AverageDriveForce (lbs)':
+                        try: # pragma: no cover
+                            forcen = sled_df[' AverageDriveForce (N)']
+                            sled_df = sled_df.with_columns((pl.col(" AverageDriveForce (lbs)") / lbstoN).alias(name))
+                        except (KeyError, TypeError):
+                            sled_df = sled_df.with_columns((pl.lit(0)).alias(name))
+                    if name == ' AverageDriveForce (N)':
+                        try:
+                            forcelbs = sled_df[' AverageDriveForce (lbs)']
+                            sled_df = sled_df.with_columns((pl.col(" AverageDriveForce (lbs)") * lbstoN).alias(name))
+                        except KeyError: # pragma: no cover
+                            sled_df = sled_df.with_columns((pl.lit(0)).alias(name))
+                    if name == ' PeakDriveForce (lbs)':
+                        try: # pragma: no cover
+                            forcen = sled_df[' PeakDriveForce (N)']
+                            sled_df = sled_df.with_columns((pl.col(forcen / lbstoN).alias(name)))
+                        except (KeyError, TypeError):
+                            sled_df = sled_df.with_columns((pl.lit(0)).alias(name))
+                    if name == ' PeakDriveForce (N)':
+                        try:
+                            forcelbs = sled_df[' PeakDriveForce (lbs)']
+                            sled_df = sled_df.with_columns((pl.col(" PeakDriveForce (lbs)") * lbstoN).alias(name))
+                        except KeyError: # pragma: no cover
+                            sled_df = sled_df.with_columns((pl.lit(0)).alias(name))
+                    if name == ' Cadence (stokes/min)':
+                        try:
+                            spm = sled_df[' Cadence (strokes/min)']
+                            if debug: # pragma: no cover
+                                print('Cadence found')
+                            sled_df = sled_df.with_columns((spm).alias(name))
+                        except KeyError: # pragma: no cover
+                            pass
+
+        sled_df = sled_df.drop([c for c in sled_df.columns if c not in self.defaultnames])
+
+        # add drive energy
+        sled_df = sled_df.with_columns((pl.col(" Power (watts)")/pl.col(" Cadence (stokes/min)")).alias("driveenergy"))
+
+        self.duration = 0
+        
+        if not sled_df.is_empty():
+            sled_df = addzones_pl(
+                sled_df,
+                self.rwr.ut2,
+                self.rwr.ut1,
+                self.rwr.at,
+                self.rwr.tr,
+                self.rwr.an,
+                self.rwr.max
+            )
+
+            sled_df = sled_df.filter(pl.col(" WorkoutState") != 12)
+            sled_df = sled_df.with_columns(pl.col(" Cadence (stokes/min)").cast(pl.Float64))
+
+            sled_df = addpowerzones_pl(sled_df, self.rwr.ftp, self.rwr.powerperc)
+
+            self.duration = sled_df['TimeStamp (sec)'].max()-sled_df['TimeStamp (sec)'].min()
+            
+        self.df = sled_df
+        self.number_of_rows = self.df.shape[0]
+
+
+    def write_csv(self, writeFile, compressed=False):
+        data = self.df.clone()
+        data = data.drop([
+            'hr_ut2',
+            'hr_ut1',
+            'hr_at',
+            'hr_tr',
+            'hr_an',
+            'hr_max',
+            'pw_ut2',
+            'pw_ut1',
+            'pw_at',
+            'pw_tr',
+            'pw_an',
+            'pw_max',
+        ])
+
+        if compressed:
+            with gzip.open(writeFile + '.gz','wb') as f:
+                return data.write_csv(f)
+
+        return data.write_csv(writeFile)
+            
+
 class rowingdata:
     """ This is the main class. Read the data from the csv file and do all
     kinds
@@ -2097,11 +2375,6 @@ class rowingdata:
             hrmean = sled_df[' HRCur (bpm)'].mean()
             hrstd = sled_df[' HRCur (bpm)'].std()
 
-            if hrmean != 0 and hrstd != 0:
-                sled_df[' HRCur (bpm)'].replace(to_replace=0, value=np.nan,
-                                                inplace=True)
-                sled_df[' HRCur (bpm)'].ffill(inplace=True)
-
             self.dragfactor = sled_df[' DragFactor'].mean()
             # do stroke count
             dt = sled_df['TimeStamp (sec)'].diff()
@@ -2173,7 +2446,8 @@ class rowingdata:
 
         # add HR zone data to dataframe
         if len(sled_df):
-            self.df = addzones(sled_df, self.rwr.ut2,
+            self.df = addzones(sled_df,
+                               self.rwr.ut2,
                                self.rwr.ut1,
                                self.rwr.at,
                                self.rwr.tr,
@@ -2199,7 +2473,7 @@ class rowingdata:
         else:
             self.duration = 0
 
-
+            
     def __add__(self, other):
         self_df = self.df.copy()
         other_df = other.df.copy()
@@ -2278,20 +2552,6 @@ class rowingdata:
         self.df[' DragFactor'] = dragfactor
         self.dragfactor = dragfactor
 
-    def get_minutes_averages(self, columnname):
-        """ Returns a list of values, the mean for each minute of the session
-        """
-
-        df = self.df.copy()
-        df['dt'] = df['TimeStamp (sec)'].apply(lambda x: arrow.get(x).datetime)
-        df.set_index('dt',inplace=True)
-
-        try:
-            result = df[columnname].resample('T').mean().values
-        except KeyError:
-            return []
-
-        return result
 
     def getvalues(self, keystring):
         """ Just a tool to get a column of the row data as a numpy array

{rowingdata-3.6.6 → rowingdata-3.6.7/rowingdata.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rowingdata
-Version: 3.6.6
+Version: 3.6.7
 Summary: The rowingdata library to create colorful plots from CrewNerd, Painsled and other rowing data tools
 Home-page: 
 Author: Sander Roosendaal
@@ -9,6 +9,25 @@ License: MIT
 Keywords: rowing ergometer concept2
 Classifier: Programming Language :: Python :: 3
 License-File: LICENSE
+Requires-Dist: Cython
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: fitparse
+Requires-Dist: arrow>=1.0.2
+Requires-Dist: python-dateutil
+Requires-Dist: docopt
+Requires-Dist: tqdm
+Requires-Dist: rowingphysics>=0.2.3
+Requires-Dist: iso8601
+Requires-Dist: lxml
+Requires-Dist: xmltodict
+Requires-Dist: nose_parameterized
+Requires-Dist: timezonefinder
+Requires-Dist: pycairo
+Requires-Dist: tk
+Requires-Dist: requests
 
 **************
 Rowingdata

{rowingdata-3.6.6 → rowingdata-3.6.7}/testdata/testdatasummary.csv

@@ -1,8 +1,6 @@
 filename,type,nr_lines,year,month,day,hour,minute,second,dist,seconds,nrintervals,lap 1 time,lap 1 dist,timezone,lap 1 time new,lap 1 dist new,,,,
 quiske_per_stroke_new.csv,quiske,139,2022,11,7,7,58,35,930,382,1,382,930,UTC,382,928,,,,
 boatcoach_fixed_distance.csv,boatcoach,493,2022,6,13,12,31,37,1996,495,4,109,494,UTC,109,494,,,,
-smartrow_intervals.csv,smartrow,739,0,0,0,0,0,0,6979,2335,1,2335,6979,UTC,2335,6970,,,,
-smartrow.csv,smartrow,878,0,0,0,0,0,0,7836,3005,1,3005,7836,UTC,3005,7829,,,,
 rowpro_carrick.csv,rp,1212,2022,1,19,17,33,0,10023,3608,10,422,1495,UTC,422,1493,,,,
 fromnk.csv.gz,nklinklogbook,430,2021,7,7,17,33,28,3005,1062,12,60,250,UTC,60,250,,,,
 herodata.csv,hero,300,2021,4,26,13,37,33,3512,896,1,896,3512,UTC,896,3509,,,,

{rowingdata-3.6.6 → rowingdata-3.6.7}/testdata/testtcx.tcx

@@ -1280,7 +1280,7 @@
           </Trackpoint>
         </Track>
       </Lap>
-      <Notes>&lt;Element 'Notes' at 0x7f4989bccae0&gt;</Notes>
+      <Notes>&lt;Element 'Notes' at 0x7f7e54795680&gt;</Notes>
     </Activity>
   </Activities>
   <Creator>

{rowingdata-3.6.6 → rowingdata-3.6.7}/tests/test_rowingdata.py

@@ -258,12 +258,6 @@ class TestStringParser:
         assert_equal(t6,d6)
         assert_equal(t7,d7)
 
-class TestMinutes:
-    def test_minutes(self):
-        row = rowingdata.rowingdata(csvfile='testdata/testdata.csv')
-
-        res = row.get_minutes_averages(' Cadence (stokes/min)')
-        assert_equal(len(res),9)
 
 class TestPhysics:
     row = rowingdata.rowingdata(csvfile='testdata/testdata.csv')
@@ -731,7 +725,7 @@ class TestSequence(unittest.TestCase):
         if filetype  not in ['unknown','c2log']:
             assert_not_equal(res,0)
         if res != 0:
-            for key,value in six.iteritems(res):
+            for key,value in res.items():
                 if key not in ['summary']:
                     if expected[key] != 0:
                         assert_equal(value,expected[key])