python-fitparse 2.0.0__py3-none-any.whl

fitparse/records.py

@@ -0,0 +1,418 @@
+import math
+import struct
+
+from itertools import zip_longest
+
+
+class RecordBase:
+    # namedtuple-like base class. Subclasses should must __slots__
+    __slots__ = ()
+
+    # TODO: switch back to namedtuple, and don't use default arguments as None
+    #       and see if that gives us any performance improvements
+
+    def __init__(self, *args, **kwargs):
+        for slot_name, value in zip_longest(self.__slots__, args, fillvalue=None):
+            setattr(self, slot_name, value)
+        for slot_name, value in kwargs.items():
+            setattr(self, slot_name, value)
+
+
+class MessageHeader(RecordBase):
+    __slots__ = ('is_definition', 'is_developer_data', 'local_mesg_num', 'time_offset')
+
+    def __repr__(self):
+        return '<MessageHeader: %s%s -- local mesg: #%d%s>' % (
+            'definition' if self.is_definition else 'data',
+            '(developer)' if self.is_developer_data else '',
+            self.local_mesg_num,
+            ', time offset: %d' % self.time_offset if self.time_offset else '',
+        )
+
+
+class DefinitionMessage(RecordBase):
+    __slots__ = ('header', 'endian', 'mesg_type', 'mesg_num', 'field_defs', 'dev_field_defs')
+    type = 'definition'
+
+    @property
+    def name(self):
+        return self.mesg_type.name if self.mesg_type else 'unknown_%d' % self.mesg_num
+
+    def __repr__(self):
+        return '<DefinitionMessage: %s (#%d) -- local mesg: #%d, field defs: [%s], dev field defs: [%s]>' % (
+            self.name,
+            self.mesg_num,
+            self.header.local_mesg_num,
+            ', '.join([fd.name for fd in self.field_defs]),
+            ', '.join([fd.name for fd in self.dev_field_defs]),
+        )
+
+
+class FieldDefinition(RecordBase):
+    __slots__ = ('field', 'def_num', 'base_type', 'size')
+
+    @property
+    def name(self):
+        return self.field.name if self.field else 'unknown_%d' % self.def_num
+
+    @property
+    def type(self):
+        return self.field.type if self.field else self.base_type
+
+    def __repr__(self):
+        return '<FieldDefinition: %s (#%d) -- type: %s (%s), size: %d byte%s>' % (
+            self.name,
+            self.def_num,
+            self.type.name, self.base_type.name,
+            self.size, 's' if self.size != 1 else '',
+        )
+
+
+class DevFieldDefinition(RecordBase):
+    __slots__ = ('field', 'dev_data_index', 'base_type', 'def_num', 'size')
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # For dev fields, the base_type and type are always the same.
+        self.base_type = self.type
+
+    @property
+    def name(self):
+        return self.field.name if self.field else 'unknown_dev_%d_%d' % (self.dev_data_index, self.def_num)
+
+    @property
+    def type(self):
+        return self.field.type
+
+    def __repr__(self):
+        return '<DevFieldDefinition: %s:%s (#%d) -- type: %s, size: %d byte%s>' % (
+            self.name,
+            self.dev_data_index,
+            self.def_num,
+            self.type.name,
+            self.size, 's' if self.size != 1 else '',
+        )
+
+
+class DataMessage(RecordBase):
+    __slots__ = ('header', 'def_mesg', 'fields')
+    type = 'data'
+
+    def get(self, field_name, as_dict=False):
+        # SIMPLIFY: get rid of as_dict
+        for field_data in self.fields:
+            if field_data.is_named(field_name):
+                return field_data.as_dict() if as_dict else field_data
+
+    def get_raw_value(self, field_name):
+        field_data = self.get(field_name)
+        if field_data:
+            return field_data.raw_value
+        return None
+
+    def get_value(self, field_name):
+        # SIMPLIFY: get rid of this completely
+        field_data = self.get(field_name)
+        if field_data:
+            return field_data.value
+
+    def get_values(self):
+        # SIMPLIFY: get rid of this completely
+        return {f.name if f.name else f.def_num: f.value for f in self.fields}
+
+    @property
+    def name(self):
+        return self.def_mesg.name
+
+    @property
+    def mesg_num(self):
+        # SIMPLIFY: get rid of this
+        return self.def_mesg.mesg_num
+
+    @property
+    def mesg_type(self):
+        # SIMPLIFY: get rid of this
+        return self.def_mesg.mesg_type
+
+    def as_dict(self):
+        # TODO: rethink this format
+        return {
+            'name': self.name,
+            'fields': [f.as_dict() for f in self.fields],
+        }
+
+    def __iter__(self):
+        # Sort by whether this is a known field, then its name
+        return iter(sorted(self.fields, key=lambda fd: (int(fd.field is None), fd.name)))
+
+    def __repr__(self):
+        return '<DataMessage: %s (#%d) -- local mesg: #%d, fields: [%s]>' % (
+            self.name, self.mesg_num, self.header.local_mesg_num,
+            ', '.join([f"{fd.name}: {fd.value}" for fd in self.fields]),
+        )
+
+    def __str__(self):
+        # SIMPLIFY: get rid of this
+        return '%s (#%d)' % (self.name, self.mesg_num)
+
+
+class FieldData(RecordBase):
+    __slots__ = ('field_def', 'field', 'parent_field', 'value', 'raw_value', 'units')
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(self, *args, **kwargs)
+        if not self.units and self.field:
+            # Default to units on field, otherwise None.
+            # NOTE:Not a property since you may want to override this in a data processor
+            self.units = self.field.units
+
+    @property
+    def name(self):
+        return self.field.name if self.field else 'unknown_%d' % self.def_num
+
+    # TODO: Some notion of flags
+
+    def is_named(self, name):
+        if self.field:
+            if name in (self.field.name, self.field.def_num):
+                return True
+        if self.parent_field:
+            if name in (self.parent_field.name, self.parent_field.def_num):
+                return True
+        if self.field_def:
+            if name == self.field_def.def_num:
+                return True
+        return False
+
+    @property
+    def def_num(self):
+        # Prefer to return the def_num on the field
+        # since field_def may be None if this field is dynamic
+        return self.field.def_num if self.field else self.field_def.def_num
+
+    @property
+    def base_type(self):
+        # Try field_def's base type, if it doesn't exist, this is a
+        # dynamically added field, so field doesn't be None
+        return self.field_def.base_type if self.field_def else self.field.base_type
+
+    @property
+    def is_base_type(self):
+        return self.field.is_base_type if self.field else True
+
+    @property
+    def type(self):
+        return self.field.type if self.field else self.base_type
+
+    @property
+    def field_type(self):
+        return self.field.field_type if self.field else 'field'
+
+    def as_dict(self):
+        return {
+            'name': self.name, 'def_num': self.def_num, 'base_type': self.base_type.name,
+            'type': self.type.name, 'units': self.units, 'value': self.value,
+            'raw_value': self.raw_value,
+        }
+
+    def __repr__(self):
+        return '<FieldData: %s: %s%s, def num: %d, type: %s (%s), raw value: %s>' % (
+            self.name, self.value, ' [%s]' % self.units if self.units else '',
+            self.def_num, self.type.name, self.base_type.name, self.raw_value,
+        )
+
+    def __str__(self):
+        return '{}: {}{}'.format(
+            self.name, self.value, ' [%s]' % self.units if self.units else '',
+        )
+
+
+class BaseType(RecordBase):
+    __slots__ = ('name', 'identifier', 'fmt', 'parse')
+    values = None  # In case we're treated as a FieldType
+
+    @property
+    def size(self):
+        return struct.calcsize(self.fmt)
+
+    @property
+    def type_num(self):
+        return self.identifier & 0x1F
+
+    def __repr__(self):
+        return '<BaseType: %s (#%d [0x%X])>' % (
+            self.name, self.type_num, self.identifier,
+        )
+
+
+class FieldType(RecordBase):
+    __slots__ = ('name', 'base_type', 'values')
+
+    def __repr__(self):
+        return f'<FieldType: {self.name} ({self.base_type})>'
+
+
+class MessageType(RecordBase):
+    __slots__ = ('name', 'mesg_num', 'fields')
+
+    def __repr__(self):
+        return '<MessageType: %s (#%d)>' % (self.name, self.mesg_num)
+
+
+class FieldAndSubFieldBase(RecordBase):
+    __slots__ = ()
+
+    @property
+    def base_type(self):
+        return self.type if self.is_base_type else self.type.base_type
+
+    @property
+    def is_base_type(self):
+        return isinstance(self.type, BaseType)
+
+    def render(self, raw_value):
+        if self.type.values and (raw_value in self.type.values):
+            return self.type.values[raw_value]
+        return raw_value
+
+
+class Field(FieldAndSubFieldBase):
+    __slots__ = ('name', 'type', 'def_num', 'scale', 'offset', 'units', 'components', 'subfields')
+    field_type = 'field'
+
+
+class SubField(FieldAndSubFieldBase):
+    __slots__ = ('name', 'def_num', 'type', 'scale', 'offset', 'units', 'components', 'ref_fields')
+    field_type = 'subfield'
+
+
+class DevField(FieldAndSubFieldBase):
+    __slots__ = ('dev_data_index', 'def_num', 'type', 'name', 'units', 'native_field_num',
+                 # The rest of these are just to be compatible with Field objects. They're always None
+                 'scale', 'offset', 'components', 'subfields')
+    field_type = 'devfield'
+
+
+class ReferenceField(RecordBase):
+    __slots__ = ('name', 'def_num', 'value', 'raw_value')
+
+
+class ComponentField(RecordBase):
+    __slots__ = ('name', 'def_num', 'scale', 'offset', 'units', 'accumulate', 'bits', 'bit_offset')
+    field_type = 'component'
+
+    def render(self, raw_value):
+        if raw_value is None:
+            return None
+
+        # If it's a tuple, then it's a byte array and unpack it as such
+        # (only type that uses this is compressed speed/distance)
+        if isinstance(raw_value, tuple):
+            # Profile.xls sometimes contains more components than the read raw
+            # value is able to hold (typically the *event_timestamp_12* field in
+            # *hr* messages).
+            # This test allows to ensure *unpacked_num* is not right-shifted
+            # more than necessary.
+            if self.bit_offset and self.bit_offset >= len(raw_value) << 3:
+                raise ValueError()
+
+            unpacked_num = 0
+
+            # Unpack byte array as little endian
+            for value in reversed(raw_value):
+                unpacked_num = (unpacked_num << 8) + value
+
+            raw_value = unpacked_num
+
+        # Mask and shift like a normal number
+        if isinstance(raw_value, int):
+            raw_value = (raw_value >> self.bit_offset) & ((1 << self.bits) - 1)
+
+        return raw_value
+
+
+class Crc:
+    """FIT file CRC computation."""
+
+    CRC_TABLE = (
+        0x0000, 0xCC01, 0xD801, 0x1400, 0xF001, 0x3C00, 0x2800, 0xE401,
+        0xA001, 0x6C00, 0x7800, 0xB401, 0x5000, 0x9C01, 0x8801, 0x4400,
+    )
+
+    FMT = 'H'
+
+    def __init__(self, value=0, byte_arr=None):
+        self.value = value
+        if byte_arr:
+            self.update(byte_arr)
+
+    def __repr__(self):
+        return '<{} {}>'.format(self.__class__.__name__, self.value or "-")
+
+    def __str__(self):
+        return self.format(self.value)
+
+    def update(self, byte_arr):
+        """Read bytes and update the CRC computed."""
+        if byte_arr:
+            self.value = self.calculate(byte_arr, self.value)
+
+    @staticmethod
+    def format(value):
+        """Format CRC value to string."""
+        return '0x%04X' % value
+
+    @classmethod
+    def calculate(cls, byte_arr, crc=0):
+        """Compute CRC for input bytes."""
+        for byte in byte_arr:
+            # Taken verbatim from FIT SDK docs
+            tmp = cls.CRC_TABLE[crc & 0xF]
+            crc = (crc >> 4) & 0x0FFF
+            crc = crc ^ tmp ^ cls.CRC_TABLE[byte & 0xF]
+
+            tmp = cls.CRC_TABLE[crc & 0xF]
+            crc = (crc >> 4) & 0x0FFF
+            crc = crc ^ tmp ^ cls.CRC_TABLE[(byte >> 4) & 0xF]
+        return crc
+
+
+def parse_string(string):
+    try:
+        s = string[:string.index(0x00)]
+    except ValueError:
+        # FIT specification defines the 'string' type as follows: "Null
+        # terminated string encoded in UTF-8 format".
+        #
+        # However 'string' values are not always null-terminated when encoded,
+        # according to FIT files created by Garmin devices (e.g. DEVICE.FIT file
+        # from a fenix3).
+        #
+        # So in order to be more flexible, in case index() could not find any
+        # null byte, we just decode the whole bytes-like object.
+        s = string
+
+    return s.decode(encoding='utf-8', errors='replace') or None
+
+# The default base type
+BASE_TYPE_BYTE = BaseType(name='byte', identifier=0x0D, fmt='B', parse=lambda x: None if all(b == 0xFF for b in x) else x)
+
+BASE_TYPES = {
+    0x00: BaseType(name='enum', identifier=0x00, fmt='B', parse=lambda x: None if x == 0xFF else x),
+    0x01: BaseType(name='sint8', identifier=0x01, fmt='b', parse=lambda x: None if x == 0x7F else x),
+    0x02: BaseType(name='uint8', identifier=0x02, fmt='B', parse=lambda x: None if x == 0xFF else x),
+    0x83: BaseType(name='sint16', identifier=0x83, fmt='h', parse=lambda x: None if x == 0x7FFF else x),
+    0x84: BaseType(name='uint16', identifier=0x84, fmt='H', parse=lambda x: None if x == 0xFFFF else x),
+    0x85: BaseType(name='sint32', identifier=0x85, fmt='i', parse=lambda x: None if x == 0x7FFFFFFF else x),
+    0x86: BaseType(name='uint32', identifier=0x86, fmt='I', parse=lambda x: None if x == 0xFFFFFFFF else x),
+    0x07: BaseType(name='string', identifier=0x07, fmt='s', parse=parse_string),
+    0x88: BaseType(name='float32', identifier=0x88, fmt='f', parse=lambda x: None if math.isnan(x) else x),
+    0x89: BaseType(name='float64', identifier=0x89, fmt='d', parse=lambda x: None if math.isnan(x) else x),
+    0x0A: BaseType(name='uint8z', identifier=0x0A, fmt='B', parse=lambda x: None if x == 0x0 else x),
+    0x8B: BaseType(name='uint16z', identifier=0x8B, fmt='H', parse=lambda x: None if x == 0x0 else x),
+    0x8C: BaseType(name='uint32z', identifier=0x8C, fmt='I', parse=lambda x: None if x == 0x0 else x),
+    0x0D: BASE_TYPE_BYTE,
+    0x8E: BaseType(name='sint64', identifier=0x8E, fmt='q', parse=lambda x: None if x == 0x7FFFFFFFFFFFFFFF else x),
+    0x8F: BaseType(name='uint64', identifier=0x8F, fmt='Q', parse=lambda x: None if x == 0xFFFFFFFFFFFFFFFF else x),
+    0x90: BaseType(name='uint64z', identifier=0x90, fmt='Q', parse=lambda x: None if x == 0 else x),
+}

fitparse/utils.py

@@ -0,0 +1,67 @@
+import io
+import re
+from collections.abc import Iterable
+
+from pathlib import PurePath
+
+
+class FitParseError(ValueError):
+    pass
+
+class FitEOFError(FitParseError):
+    pass
+
+class FitCRCError(FitParseError):
+    pass
+
+class FitHeaderError(FitParseError):
+    pass
+
+
+METHOD_NAME_SCRUBBER = re.compile(r'\W|^(?=\d)')
+UNIT_NAME_TO_FUNC_REPLACEMENTS = (
+    ('/', ' per '),
+    ('%', 'percent'),
+    ('*', ' times '),
+)
+
+def scrub_method_name(method_name, convert_units=False):
+    if convert_units:
+        for replace_from, replace_to in UNIT_NAME_TO_FUNC_REPLACEMENTS:
+            method_name = method_name.replace(
+                replace_from, '%s' % replace_to,
+            )
+    return METHOD_NAME_SCRUBBER.sub('_', method_name)
+
+
+def fileish_open(fileish, mode):
+    """
+    Convert file-ish object to BytesIO like object.
+    :param fileish: the file-ihs object (str, BytesIO, bytes, file contents)
+    :param str mode: mode for the open function.
+    :rtype: BytesIO
+    """
+    if mode is not None and any(m in mode for m in ['+', 'w', 'a', 'x']):
+        attr = 'write'
+    else:
+        attr = 'read'
+    if hasattr(fileish, attr) and hasattr(fileish, 'seek'):
+        # BytesIO-like object
+        return fileish
+    elif isinstance(fileish, str):
+        # file path
+        return open(fileish, mode)
+
+    # pathlib obj
+    if isinstance(fileish, PurePath):
+        return fileish.open(mode)
+
+    # file contents
+    return io.BytesIO(fileish)
+
+
+def is_iterable(obj):
+    """Check, if the obj is iterable but not string or bytes.
+    :rtype bool"""
+    # Speed: do not use iter() although it's more robust, see also https://stackoverflow.com/questions/1952464/
+    return isinstance(obj, Iterable) and not isinstance(obj, (str, bytes))

python_fitparse-2.0.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: python-fitparse
+Version: 2.0.0
+Summary: Python library to parse ANT/Garmin .FIT files
+Project-URL: Homepage, https://www.github.com/nbr23/python-fitparse
+Project-URL: Repository, https://www.github.com/nbr23/python-fitparse
+Project-URL: Issues, https://github.com/nbr23/python-fitparse/issues
+Author-email: David Cooper <dave@kupesoft.com>, nbr23 <max@23.tf>
+License: MIT License
+        
+        Copyright (c) 2011-2025, David Cooper <david@dtcooper.com>
+        Copyright (c) 2017-2025, Carey Metcalfe <carey@cmetcalfe.ca>
+        
+        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.
+License-File: LICENSE
+Keywords: ant,files,fit,garmin,parse
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Provides-Extra: generate
+Requires-Dist: openpyxl==3.1.5; extra == 'generate'
+Requires-Dist: requests; extra == 'generate'
+Description-Content-Type: text/markdown
+
+python-fitparse
+===============
+
+> :warning: **NOTE:** *I have **limited to no time** to work on this package
+> these days!*
+> 
+> I am looking for a maintainer to help with issues and updating/releasing the package.
+> Please reach out via email at <david@dtcooper.com> if you have interest in helping.
+>
+> If you're having trouble using this package for whatever reason, might we suggest using
+> an alternative library: [fitdecode](https://github.com/polyvertex/fitdecode) by
+> [polyvertex](https://github.com/polyvertex).
+>
+> Cheers,
+>
+> David
+
+Here's a Python library to parse ANT/Garmin `.FIT` files.
+[![Build Status](https://github.com/dtcooper/python-fitparse/workflows/test/badge.svg)](https://github.com/dtcooper/python-fitparse/actions?query=workflow%3Atest)
+
+
+Install from [![PyPI](https://img.shields.io/pypi/v/fitparse.svg)](https://pypi.python.org/pypi/fitparse/):
+```
+pip install fitparse
+```
+
+FIT files
+------------
+- FIT files contain data stored in a binary file format.
+- The FIT (Flexible and Interoperable Data Transfer) file protocol is specified
+  by [ANT](http://www.thisisant.com/).
+- The SDK, code examples, and detailed documentation can be found in the
+  [ANT FIT SDK](http://www.thisisant.com/resources/fit).
+
+
+Usage
+-----
+A simple example of printing records from a fit file:
+
+```python
+import fitparse
+
+# Load the FIT file
+fitfile = fitparse.FitFile("my_activity.fit")
+
+# Iterate over all messages of type "record"
+# (other types include "device_info", "file_creator", "event", etc)
+for record in fitfile.get_messages("record"):
+
+    # Records can contain multiple pieces of data (ex: timestamp, latitude, longitude, etc)
+    for data in record:
+
+        # Print the name and value of the data (and the units if it has any)
+        if data.units:
+            print(" * {}: {} ({})".format(data.name, data.value, data.units))
+        else:
+            print(" * {}: {}".format(data.name, data.value))
+
+    print("---")
+```
+
+The library also provides a `fitdump` script for command line usage:
+```
+$ fitdump --help
+usage: fitdump [-h] [-v] [-o OUTPUT] [-t {readable,json}] [-n NAME] [--ignore-crc] FITFILE
+
+Dump .FIT files to various formats
+
+positional arguments:
+  FITFILE               Input .FIT file (Use - for stdin)
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -v, --verbose
+  -o OUTPUT, --output OUTPUT
+                        File to output data into (defaults to stdout)
+  -t {readable,json}, --type {readable,json}
+                        File type to output. (DEFAULT: readable)
+  -n NAME, --name NAME  Message name (or number) to filter
+  --ignore-crc          Some devices can write invalid crc's, ignore these.
+```
+
+See the documentation for more: http://dtcooper.github.io/python-fitparse
+
+
+Major Changes From Original Version
+-----------------------------------
+
+After a few years of laying dormant we are back to active development!
+The old version is archived as
+[`v1-archive`](https://github.com/dtcooper/python-fitparse/releases/tag/v1-archive).
+
+  * New, hopefully cleaner public API with a clear division between accessible
+    and internal parts. (Still unstable and partially complete.)
+
+  * Proper documentation!
+    [Available here](https://dtcooper.github.io/python-fitparse/).
+
+  * Unit tests and example programs.
+
+  * **(WIP)** Command line tools (eg a `.FIT` to `.CSV` converter).
+
+  * Component fields and compressed timestamp headers now supported and not
+    just an afterthought. Closes issues #6 and #7.
+
+  * FIT file parsing is generic enough to support all types. Going to have
+    specific `FitFile` subclasses for more popular file types like activities.
+
+  * **(WIP)** Converting field types to normalized values (for example,
+    `bool`, `date_time`, etc) done in a consistent way, that's easy to
+    customize by subclassing the converter class. I'm going to use something
+    like the Django form-style `convert_<field name>` idiom on this class.
+
+  * The FIT profile is its own complete python module, rather than using
+    `profile.def`.
+
+    * Bonus! The profile generation script is _less_ ugly (but still an
+      atrocity) and supports every
+      [ANT FIT SDK](http://www.thisisant.com/resources/fit) from version 1.00
+      up to 5.10.
+
+  * A working `setup.py` module. Closes issue #2, finally! I'll upload the
+    package to [PyPI](http://pypi.python.org/) when it's done.
+
+  * Support for parsing one record at a time. This can be done using
+    `<FitFile>.parse_one()` for now, but I'm not sure of the exact
+    implementation yet.
+
+
+Updating to new FIT SDK versions
+--------------------------------
+- Download the latest [ANT FIT SDK](http://www.thisisant.com/resources/fit).
+- Update the profile:
+```
+python3 scripts/generate_profile.py /path/to/fit_sdk.zip fitparse/profile.py
+```
+
+
+License
+-------
+
+This project is licensed under the MIT License - see the [`LICENSE`](LICENSE)
+file for details.

python_fitparse-2.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+fitparse/__init__.py,sha256=XigqA8TTG1j9B3PyV7PfAfJhVL2NQVGQrMtfmElEuNM,336
+fitparse/base.py,sha256=9Prisb5xfPGM79kszvfATVIgYMC3gWnHWaX1kqoHmAQ,24202
+fitparse/processors.py,sha256=gQNdFiT5xVn3R9uX-cjijL2JQ3cKtuygjAPKIZ7J53Q,5357
+fitparse/profile.py,sha256=WVsU060VBVSQfJzMHojHG6GSmPK88OT4VGgRVAs0910,582980
+fitparse/records.py,sha256=bjiuG6P2SrRHxmGWjcNbj29nnM6UAl9sw-toR2rFudk,14396
+fitparse/utils.py,sha256=cYmAKRktsiTKpxAAvp9XwjfN2BKzEP9-0fAKoTTu_Sw,1750
+python_fitparse-2.0.0.dist-info/METADATA,sha256=avMAmoxsvuC60-1pD8xXAbiPIHl9n6ugGReVW04ZbXE,7408
+python_fitparse-2.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_fitparse-2.0.0.dist-info/entry_points.txt,sha256=cM-FrZMgY175Od7pYZX7yu48XDynph8o2w-FBOBIyRU,49
+python_fitparse-2.0.0.dist-info/licenses/LICENSE,sha256=RK-rKfCYWql9q58dgvYwpDuo-N4g0L4iXxr8D5ubMIo,1157
+python_fitparse-2.0.0.dist-info/RECORD,,

python_fitparse-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

python_fitparse-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fitdump = scripts.fitdump:main