Changeset 53bb3e5 in OpenWorkouts-current

Timestamp:

Jan 9, 2019, 12:31:33 PM (5 years ago)

Author:

borja <borja@…>

Branches:

current, feature/docs, master

Children:

119412d

Parents:

e3d7b13

Message:

(#13) - fit files parsing + (#26) - generate .gpx from .fit

• Added fitparse as a new dependency IMPORTANT: please install it in your existing envs:

pip install python-fitparse

• Added new attribute to workouts to store attached fit files as Blob objects. IMPORTANT: please update any workouts you have in your db, adding the fit_file attribute to them (None by default)

• Added new module with the code needed to interact with .fit files (parse, gather data, transform to gpx)

• Added code to "load" a workout from a fit file

• Added tools and helpers to transform values (meters->kilometers, meters-per-second->kms-per-hour, semicircles-to-degrees, etc)

• Refactored some imports

Files:

• ow/fit.py (added)
• ow/models/workout.py (modified) (6 diffs)
• ow/tests/models/test_workout.py (modified) (2 diffs)
• ow/utilities.py (modified) (3 diffs)
• setup.py (modified) (1 diff)

ow/models/workout.py

@@ -7 +7 @@
 from repoze.folder import Folder
 from pyramid.security import Allow, Everyone
-from ow.utilities import GPXMinidomParser
+
+from ow.utilities import (
+    GPXMinidomParser,
+    copy_blob,
+    create_blob,
+)
+
+from ow.fit import Fit
 
 
@@ -56 +63 @@
         self.tracking_file = kw.get('tracking_file', None)  # Blob
         self.tracking_filetype = ''  # unicode string
+        # attr to store ANT fit files. For now this file is used to
+        # generate a gpx-encoded tracking file we then use through
+        # the whole app
+        self.fit_file = kw.get('fit_file', None)  # Blob
 
     @property
@@ -188 +199 @@
         return None
 
+    @property
+    def tracking_file_path(self):
+        """
+        Get the path to the blob file attached as a tracking file.
+
+        First check if the file was not committed to the db yet (new workout
+        not saved yet) and use the path to the temporary file on the fs.
+        If none is found there, go for the real blob file in the blobs
+        directory
+        """
+        path = None
+        if self.tracking_file:
+            path = self.tracking_file._p_blob_uncommitted
+            if path is None:
+                path = self.tracking_file._p_blob_committed
+        return path
+
+    @property
+    def fit_file_path(self):
+        """
+        Get the path to the blob file attached as a fit file.
+
+        First check if the file was not committed to the db yet (new workout
+        not saved yet) and use the path to the temporary file on the fs.
+        If none is found there, go for the real blob file in the blobs
+        directory
+        """
+        path = None
+        if self.fit_file:
+            path = self.fit_file._p_blob_uncommitted
+            if path is None:
+                path = self.fit_file._p_blob_committed
+        return path
+
     def load_from_file(self):
         """
@@ -195 +240 @@
         if self.tracking_filetype == 'gpx':
             self.load_from_gpx()
+        elif self.tracking_filetype == 'fit':
+            self.load_from_fit()
 
     def load_from_gpx(self):
@@ -283 +330 @@
         return parser.tracks
 
+    def load_from_fit(self):
+        """
+        Try to load data from an ANT-compatible .fit file (if any has been
+        added to this workout).
+
+        "Load data" means:
+
+        1. Copy over the uploaded fit file to self.fit_file, so we can keep
+           that copy around for future use
+
+        2. generate a gpx object from the fit file
+
+        3. save the gpx object as the tracking_file, which then will be used
+           by the current code to display and gather data to be displayed/shown
+           to the user.
+
+        4. Grab some basic info from the fit file and store it in the Workout
+        """
+        # backup the fit file
+        self.fit_file = copy_blob(self.tracking_file)
+
+        # create an instance of our Fit class
+        fit = Fit(self.fit_file_path)
+        fit.load()
+
+        # fit -> gpx and store that as the main tracking file
+        self.tracking_file = create_blob(fit.gpx, 'gpx')
+        self.tracking_filetype = 'gpx'
+
+        # grab the needed data from the fit file, update the workout
+        self.start = fit.data['start']
+        # ensure this datetime start object is timezone-aware
+        self.start = self.start.replace(tzinfo=timezone.utc)
+        # duration comes in seconds, store a timedelta
+        self.duration = timedelta(seconds=fit.data['duration'])
+        # distance comes in meters
+        self.distance = Decimal(fit.data['distance']) / Decimal(1000.00)
+        self.uphill = Decimal(fit.data['uphill'])
+        self.downhill = Decimal(fit.data['downhill'])
+        # If the user did not provide us with a title, build one from the
+        # info in the fit file
+        if not self.title:
+            self.title = fit.name
+
+        if fit.data['avg_hr']:
+            self.hr_avg = Decimal(fit.data['avg_hr'])
+            self.hr_min = Decimal(fit.data['min_hr'])
+            self.hr_max = Decimal(fit.data['max_hr'])
+
+        if fit.data['avg_cad']:
+            self.cad_avg = Decimal(fit.data['avg_cad'])
+            self.cad_min = Decimal(fit.data['min_cad'])
+            self.cad_max = Decimal(fit.data['max_cad'])
+
+        if fit.data['avg_atemp']:
+            self.atemp_avg = Decimal(fit.data['avg_atemp'])
+            self.atemp_min = Decimal(fit.data['min_atemp'])
+            self.atemp_max = Decimal(fit.data['max_atemp'])
+
+        return True
+
     @property
     def has_tracking_file(self):
@@ -290 +398 @@
     def has_gpx(self):
         return self.has_tracking_file and self.tracking_filetype == 'gpx'
+
+    @property
+    def has_fit(self):
+        return self.fit_file is not None

ow/tests/models/test_workout.py

@@ -3 +3 @@
 from datetime import datetime, timedelta, timezone
 from decimal import Decimal
-from unittest.mock import patch
+from unittest.mock import patch, Mock
 
 import pytest
@@ -195 +195 @@
         assert workout.atemp['max'] == 12
         assert workout.atemp['avg'] == 5
+
+    def test_tracking_file_path(self):
+        workout = Workout()
+        # no tracking file, path is None
+        assert workout.tracking_file_path is None
+        # workout still not saved to the db
+        workout.tracking_file = Mock()
+        workout.tracking_file._p_blob_uncommitted = '/tmp/blobtempfile'
+        workout.tracking_file._p_blob_committed = None
+        assert workout.tracking_file_path == '/tmp/blobtempfile'
+        workout.tracking_file._p_blob_uncommitted = None
+        workout.tracking_file._p_blob_committed = '/var/db/blobs/blobfile'
+        assert workout.tracking_file_path == '/var/db/blobs/blobfile'
 
     def test_load_from_file_invalid(self):

ow/utilities.py

@@ -1 +1 @@
 import re
-import datetime
+from datetime import datetime
+from decimal import Decimal
+from shutil import copyfileobj
+
 from unidecode import unidecode
 from xml.dom import minidom
-from decimal import Decimal
+from ZODB.blob import Blob
 
 
@@ -79 +82 @@
                 rfc3339 = trkpt.getElementsByTagName('time')[0].firstChild.data
                 try:
-                    t = datetime.datetime.strptime(
+                    t = datetime.strptime(
                         rfc3339, '%Y-%m-%dT%H:%M:%S.%fZ')
                 except ValueError:
-                    t = datetime.datetime.strptime(
+                    t = datetime.strptime(
                         rfc3339, '%Y-%m-%dT%H:%M:%SZ')
 
@@ -113 +116 @@
                     'cad': cad,
                     'atemp': atemp})
+
+
+def semicircles_to_degrees(semicircles):
+    return semicircles * (180 / pow(2, 31))
+
+
+def degrees_to_semicircles(degrees):
+    return degrees * (pow(2, 31) / 180)
+
+
+def miles_to_kms(miles):
+    factor = 0.62137119
+    return miles / factor
+
+
+def kms_to_miles(kms):
+    factor = 0.62137119
+    return kms * factor
+
+
+def meters_to_kms(meters):
+    return meters / 1000
+
+
+def kms_to_meters(kms):
+    return kms * 1000
+
+
+def mps_to_kmph(mps):
+    """
+    Transform a value from meters-per-second to kilometers-per-hour
+    """
+    return mps * 3.6
+
+
+def kmph_to_mps(kmph):
+    """
+    Transform a value from kilometers-per-hour to meters-per-second
+    """
+    return kmph * 0.277778
+
+
+def copy_blob(blob):
+    """
+    Create a copy of a blob object, returning another blob object that is
+    the copy of the given blob file.
+    """
+    new_blob = Blob()
+    if getattr(blob, 'file_extension', None):
+        new_blob.file_extension = blob.file_extension
+    with blob.open('r') as orig_blob, new_blob.open('w') as dest_blob:
+        orig_blob.seek(0)
+        copyfileobj(orig_blob, dest_blob)
+    return new_blob
+
+
+def create_blob(data, file_extension):
+    """
+    Create a ZODB blob file from some data, return the blob object
+    """
+    blob = Blob()
+    blob.file_extension = file_extension
+    with blob.open('w') as open_blob:
+        # use .encode() to convert the string to bytes if needed
+        if not isinstance(data, bytes):
+            data = data.encode('utf-8')
+        open_blob.write(data)
+    return blob

setup.py

@@ -28 +28 @@
     'gpxpy',
     'lxml',
-    'pytz'
+    'pytz',
+    'fitparse'
 ]