sstools 0.2.6__tar.gz → 0.2.8__tar.gz

{sstools-0.2.6 → sstools-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sstools
-Version: 0.2.6
+Version: 0.2.8
 Summary: swimstats tools
 Home-page: https://swimstats.net
 Author: Roman Arnet
@@ -10,9 +10,14 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-Requires-Dist: xlrd
 
 # sstools - Swimstats Tools
+0.2.8
+- Add season 2025 FINA SCM
+
+0.2.7
+- Trunc FINA calculation
+- Add Rudolph-Punkttabelle 2025
 
 0.2.6
 - Fix available styles

{sstools-0.2.6 → sstools-0.2.8}/README.md

@@ -1,4 +1,10 @@
 # sstools - Swimstats Tools
+0.2.8
+- Add season 2025 FINA SCM
+
+0.2.7
+- Trunc FINA calculation
+- Add Rudolph-Punkttabelle 2025
 
 0.2.6
 - Fix available styles

{sstools-0.2.6 → sstools-0.2.8}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="sstools",  # Replace with your own username
-    version="0.2.6",
+    version="0.2.8",
     author="Roman Arnet",
     author_email="arnet@dlab.ch",
     description="swimstats tools",
@@ -22,6 +22,5 @@ setuptools.setup(
     ],
     python_requires='>=3.6',
     install_requires=[
-        'xlrd',
     ],
 )

{sstools-0.2.6 → sstools-0.2.8}/sstools/ssconv.py

@@ -2,9 +2,6 @@ from datetime import datetime
 import logging
 import os
 import pickle
-import sys
-
-import xlrd
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
@@ -12,58 +9,131 @@ logger.setLevel(logging.INFO)
 
 class SsConverter:
     def __init__(self):
-        self._supported_rudolph_seasons = [2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024]
+        self._supported_rudolph_seasons = [
+            2004,
+            2005,
+            2006,
+            2007,
+            2008,
+            2009,
+            2010,
+            2011,
+            2012,
+            2013,
+            2014,
+            2015,
+            2016,
+            2017,
+            2018,
+            2019,
+            2020,
+            2021,
+            2022,
+            2023,
+            2024,
+            2025,
+        ]
         # There is no Rudolphtabelle for 2021. 2021 bases on times swam 2019 too.
-        self._rudolph_season_base = 2024  # rudolph_season_base bases on times swam the season before
-
-        self._supported_fina_seasons = {'SCM': [2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024],
-                                        'LCM': [2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025]
-                                        }
-        self._fina_season_base = {'SCM': 2024,  # Validity Period: 1.9.YYYY-31.8.YYYY+1
-                                  'LCM': 2025}  # Validity Period: 1.1.XXXX-31.12.XXXX
-        self._fina_base_table_path = os.path.join(os.path.dirname(__file__), 'fina_base_times.pkl')
-        self._rudolph_points_table_path = os.path.join(os.path.dirname(__file__), 'rudolph_points_table.xls')
+        self._rudolph_season_base = 2025  # rudolph_season_base bases on times swam the season before
+
+        self._supported_fina_seasons = {
+            "SCM": [
+                2008,
+                2009,
+                2010,
+                2011,
+                2012,
+                2013,
+                2014,
+                2015,
+                2016,
+                2017,
+                2018,
+                2019,
+                2020,
+                2021,
+                2022,
+                2023,
+                2025,
+            ],
+            "LCM": [
+                2008,
+                2009,
+                2010,
+                2011,
+                2012,
+                2013,
+                2014,
+                2015,
+                2016,
+                2017,
+                2018,
+                2019,
+                2020,
+                2021,
+                2022,
+                2023,
+                2024,
+                2025,
+            ],
+        }
+        self._fina_season_base = {
+            "SCM": 2025,  # Validity Period: 1.9.YYYY-31.8.YYYY+1
+            "LCM": 2025,
+        }  # Validity Period: 1.1.XXXX-31.12.XXXX
+        self._fina_base_table_path = os.path.join(os.path.dirname(__file__), "fina_base_times.pkl")
+        self._rudolph_punkttabelle_path = os.path.join(os.path.dirname(__file__), "rudolph_punkttabelle.pkl")
         self._dict_style_styleid = {
-            '50m Freestyle': 'Style-1',
-            '100m Freestyle': 'Style-2',
-            '200m Freestyle': 'Style-3',
-            '400m Freestyle': 'Style-5',
-            '800m Freestyle': 'Style-6',
-            '1500m Freestyle': 'Style-8',
-            '50m Backstroke': 'Style-9',
-            '100m Backstroke': 'Style-10',
-            '200m Backstroke': 'Style-11',
-            '50m Breaststroke': 'Style-12',
-            '100m Breaststroke': 'Style-13',
-            '200m Breaststroke': 'Style-14',
-            '50m Butterfly': 'Style-15',
-            '100m Butterfly': 'Style-16',
-            '200m Butterfly': 'Style-17',
-            '200m Medley': 'Style-18',
-            '400m Medley': 'Style-19',
-            '100m Medley': 'Style-20'}
+            "50m Freestyle": "Style-1",
+            "100m Freestyle": "Style-2",
+            "200m Freestyle": "Style-3",
+            "400m Freestyle": "Style-5",
+            "800m Freestyle": "Style-6",
+            "1500m Freestyle": "Style-8",
+            "50m Backstroke": "Style-9",
+            "100m Backstroke": "Style-10",
+            "200m Backstroke": "Style-11",
+            "50m Breaststroke": "Style-12",
+            "100m Breaststroke": "Style-13",
+            "200m Breaststroke": "Style-14",
+            "50m Butterfly": "Style-15",
+            "100m Butterfly": "Style-16",
+            "200m Butterfly": "Style-17",
+            "200m Medley": "Style-18",
+            "400m Medley": "Style-19",
+            "100m Medley": "Style-20",
+        }
 
         # dictionary concerning the syle vs. styleid relation
         self._dict_styleid_style = {v: k for k, v in self._dict_style_styleid.items()}
 
         # Rudolph functionality
-        logger.debug('Initialize rudolph functionality')
-
-        wb = xlrd.open_workbook(self._rudolph_points_table_path)
-        self._xl_sheet = dict()
-        for season in self._supported_rudolph_seasons:
-            self._xl_sheet[season] = wb.sheet_by_name('Rudolph_%s' % season)
-        self._dict_style_rudolphcolumn = {'50m Freestyle': 2, '100m Freestyle': 3, '200m Freestyle': 4,
-                                          '400m Freestyle': 5,
-                                          '800m Freestyle': 6, '1500m Freestyle': 7,
-                                          '50m Breaststroke': 8, '100m Breaststroke': 9, '200m Breaststroke': 10,
-                                          '50m Butterfly': 11, '100m Butterfly': 12, '200m Butterfly': 13,
-                                          '50m Backstroke': 14, '100m Backstroke': 15, '200m Backstroke': 16,
-                                          '200m Medley': 17, '400m Medley': 18}
-        # Fina functionality
-        logger.debug('Initialize fina functionality')
+        logger.debug("Initialize rudolph functionality")
+        with open(self._rudolph_punkttabelle_path, "rb") as handle:
+            self._rudolph_punkttablle = pickle.load(handle)
+        self._dict_style_rudolphcolumn = {
+            "50m Freestyle": 0,
+            "100m Freestyle": 1,
+            "200m Freestyle": 2,
+            "400m Freestyle": 3,
+            "800m Freestyle": 4,
+            "1500m Freestyle": 5,
+            "50m Breaststroke": 6,
+            "100m Breaststroke": 7,
+            "200m Breaststroke": 8,
+            "50m Butterfly": 9,
+            "100m Butterfly": 10,
+            "200m Butterfly": 11,
+            "50m Backstroke": 12,
+            "100m Backstroke": 13,
+            "200m Backstroke": 14,
+            "200m Medley": 15,
+            "400m Medley": 16,
+        }
 
-        with open(self._fina_base_table_path, 'rb') as handle:
+        # Fina functionality
+        logger.debug("Initialize fina functionality")
+        with open(self._fina_base_table_path, "rb") as handle:
             self._finabasetimes = pickle.load(handle)
 
     def get_rudolphpts_from_seconds(self, gender, style, agegroup, seconds, season_base=None):
@@ -92,23 +162,19 @@ class SsConverter:
             seconds.append(tmp)
             seconds_type_list = False
 
-        if gender == 'M':
-            # 1 because of header
-            ageoffset = 1
-        elif gender == 'F':
-            ageoffset = 20 * 12 + 1
+        if gender == "M":
+            ageoffset = 0
+        elif gender == "F":
+            ageoffset = 20 * 12
         else:
-            raise ValueError('unsupported gender: %s' % gender)
+            raise ValueError("unsupported gender: %s" % gender)
 
         if style not in self._dict_style_rudolphcolumn:
             raise ValueError('unsupported style for rudolphpoints: "%s"' % style)
-        try:
-            col = self._xl_sheet[season_base].col(self._dict_style_rudolphcolumn[style])
-        except KeyError as e:
-            raise type(e)(type(e)('"%s" - unknown style in rudolph_points_table.xls' % e)).with_traceback(sys.exc_info()[2])
+        style_idx = self._dict_style_rudolphcolumn[style]
 
         if season_base not in self._supported_rudolph_seasons:
-            raise ValueError('unsupported season: %s' % season_base)
+            raise ValueError("unsupported season: %s" % season_base)
 
         if agegroup < 8:
             agegroup = 8
@@ -121,18 +187,19 @@ class SsConverter:
             match = False
             for ptsIdx in range(0, 20):
                 idx = ageoffset + (agegroup - 8) * 20 + ptsIdx
-                d = datetime.strptime(col[idx].value, '%M:%S,%f')
-                curtime = d.minute * 60 + d.second + d.microsecond / 10 ** 6.
+
+                curtime = self._rudolph_punkttablle[str(season_base)][idx][style_idx]
                 if curtime > sec:
                     if ptsIdx == 0:
                         return 20
                     y1 = (20 - ptsIdx) - 1
-                    y2 = (20 - ptsIdx)
+                    y2 = 20 - ptsIdx
                     x1 = curtime
                     x2 = prevtime
                     x = sec
-                    currudolphpts = round((y2 - y1) / (x2 - x1) * (x - x1) + y1 + 1,
-                                          1)  # linear interpolation between rudolph points
+                    currudolphpts = round(
+                        (y2 - y1) / (x2 - x1) * (x - x1) + y1 + 1, 1
+                    )  # linear interpolation between rudolph points
                     rudolphpts.append(currudolphpts)
                     match = True
                     break
@@ -172,25 +239,22 @@ class SsConverter:
             rudolphpts_type_list = False
 
         if max(rudolphpts) > 20 or min(rudolphpts) < 1:
-            raise ValueError('Rudolphpts must be between 1:20: %s' % rudolphpts)
+            raise ValueError("Rudolphpts must be between 1:20: %s" % rudolphpts)
 
-        if gender == 'M':
+        if gender == "M":
             # 1 because of header
-            ageoffset = 1
-        elif gender == 'F':
-            ageoffset = 20 * 12 + 1
+            ageoffset = 0
+        elif gender == "F":
+            ageoffset = 20 * 12
         else:
-            raise ValueError('unsupported gender: %s' % gender)
+            raise ValueError("unsupported gender: %s" % gender)
 
         if style not in self._dict_style_rudolphcolumn:
             raise ValueError('unsupported style: "%s"' % style)
-        try:
-            col = self._xl_sheet[season_base].col(self._dict_style_rudolphcolumn[style])
-        except KeyError as e:
-            raise type(e)(type(e)('"%s" - unknown style in rudolph_points_table.xls' % e)).with_traceback(sys.exc_info()[2])
+        style_idx = self._dict_style_rudolphcolumn[style]
 
         if season_base not in self._supported_rudolph_seasons:
-            raise ValueError('unsupported season: %s' % season_base)
+            raise ValueError("unsupported season: %s" % season_base)
 
         if agegroup < 8:
             agegroup = 8
@@ -201,11 +265,8 @@ class SsConverter:
 
         for rudolphpt in rudolphpts:
             idx = ageoffset + (agegroup - 8) * 20 + (20 - int(rudolphpt))
-            d = datetime.strptime(col[idx].value, '%M:%S,%f')
-            t_bottom = d.minute * 60 + d.second + d.microsecond / 10 ** 6.
-            d = datetime.strptime(col[idx - 1].value, '%M:%S,%f')
-            t_top = d.minute * 60 + d.second + d.microsecond / 10 ** 6.
-
+            t_bottom = self._rudolph_punkttablle[str(season_base)][idx][style_idx]
+            t_top = self._rudolph_punkttablle[str(season_base)][idx - 1][style_idx]
             seconds.append((t_top - t_bottom) * (rudolphpt - int(rudolphpt)) + t_bottom)
 
         if not rudolphpts_type_list:
@@ -229,18 +290,18 @@ class SsConverter:
         :type: int or List[int]
         """
 
-        if not ((gender == 'M') or (gender == 'F')):
-            raise ValueError('unknown gender: %s' % gender)
+        if not ((gender == "M") or (gender == "F")):
+            raise ValueError("unknown gender: %s" % gender)
 
-        if not ((course == 'SCM') or (course == 'LCM')):
-            raise ValueError('unknown course: %s' % course)
+        if not ((course == "SCM") or (course == "LCM")):
+            raise ValueError("unknown course: %s" % course)
 
         if not season_base:
             season_base = self._fina_season_base[course]
         season_base = int(season_base)
 
         if season_base not in self._supported_fina_seasons[course]:
-            raise ValueError('unsupported season: %s' % season_base)
+            raise ValueError("unsupported season: %s" % season_base)
 
         seconds_type_list = True
         if not isinstance(seconds, list):
@@ -253,10 +314,12 @@ class SsConverter:
         basetime = self._finabasetimes[season_base][style][gender][course]
 
         if not basetime:
-            raise ValueError('BaseTime could not be found with arguments "%s, %s, %s, %s"' % (season_base, course, gender, style))
+            raise ValueError(
+                'BaseTime could not be found with arguments "%s, %s, %s, %s"' % (season_base, course, gender, style)
+            )
 
         for sec in seconds:
-            finapts.append(round(1000 * (basetime / sec) ** 3))
+            finapts.append(int(1000 * (basetime / sec) ** 3))
 
         if not seconds_type_list:
             return finapts[0]
@@ -278,15 +341,15 @@ class SsConverter:
         :type: frac or List[frac]
         """
 
-        if not ((gender == 'M') or (gender == 'F')):
-            raise ValueError('unknown gender: %s' % gender)
-        if not ((course == 'SCM') or (course == 'LCM')):
-            raise ValueError('unknown course: %s' % course)
+        if not ((gender == "M") or (gender == "F")):
+            raise ValueError("unknown gender: %s" % gender)
+        if not ((course == "SCM") or (course == "LCM")):
+            raise ValueError("unknown course: %s" % course)
         if not season_base:
             season_base = self._fina_season_base[course]
         season_base = int(season_base)
         if season_base not in self._supported_fina_seasons[course]:
-            raise ValueError('unsupported season: %s' % season_base)
+            raise ValueError("unsupported season: %s" % season_base)
 
         finapts_type_list = True
         if not isinstance(finapts, list):
@@ -299,7 +362,9 @@ class SsConverter:
         basetime = self._finabasetimes[season_base][style][gender][course]
 
         if not basetime:
-            raise ValueError('BaseTime could not be found with arguments "%s, %s, %s, %s"' % (course, gender, style, seconds))
+            raise ValueError(
+                'BaseTime could not be found with arguments "%s, %s, %s, %s"' % (course, gender, style, seconds)
+            )
 
         for fina in finapts:
             seconds.append(round(1.0 / ((fina / 1000.0) ** (1 / 3.0) / basetime), 2))
@@ -328,10 +393,10 @@ class SsConverter:
         return list(self._dict_styleid_style.values())
 
     def get_fina_validity_period(self, course):
-        if course == 'SCM':
-            return '1. Sept. %s - 31. Aug. %s' % (self._fina_season_base[course], self._fina_season_base[course] + 1)
-        elif course == 'LCM':
-            return '1. Jan. %s - 31. Dec. %s' % (self._fina_season_base[course], self._fina_season_base[course])
+        if course == "SCM":
+            return "1. Sept. %s - 31. Aug. %s" % (self._fina_season_base[course], self._fina_season_base[course] + 1)
+        elif course == "LCM":
+            return "1. Jan. %s - 31. Dec. %s" % (self._fina_season_base[course], self._fina_season_base[course])
         return None
 
     def get_fina_season_base(self, course):
@@ -342,51 +407,51 @@ class SsConverter:
 
     def set_fina_season_base(self, course, season):
         if season not in self._supported_fina_seasons[course]:
-            raise ValueError('unsupported season: %s' % season)
+            raise ValueError("unsupported season: %s" % season)
         self._fina_season_base[course] = season
 
     def set_rudolph_season_base(self, season):
         if season not in self._supported_rudolph_seasons:
-            raise ValueError('unsupported season: %s' % season)
+            raise ValueError("unsupported season: %s" % season)
         self._rudolph_season_base = season
 
     @staticmethod
     def get_agegroup_json_from_agegroup_url(agegroup_url):
-        strlist = agegroup_url.split('_')
-        if strlist[0] == 'x' and strlist[0] == 'x':
-            return 'Open'
+        strlist = agegroup_url.split("_")
+        if strlist[0] == "x" and strlist[0] == "x":
+            return "Open"
         if strlist[0] == strlist[1]:
             return strlist[0]
-        raise ValueError('not convertable %s' % agegroup_url)
+        raise ValueError("not convertable %s" % agegroup_url)
 
     @staticmethod
     def get_agegroup_str_from_agegroup_url(agegroup_url):
-        selected_athletes_places = agegroup_url.split('_')
-        agegroup_str = agegroup_url.replace('_', '-') + 'y'
+        selected_athletes_places = agegroup_url.split("_")
+        agegroup_str = agegroup_url.replace("_", "-") + "y"
         if len(selected_athletes_places) == 2:
             if selected_athletes_places[0] == selected_athletes_places[1]:
-                if selected_athletes_places[0] == 'x':
-                    agegroup_str = 'open'
+                if selected_athletes_places[0] == "x":
+                    agegroup_str = "open"
                 else:
-                    agegroup_str = selected_athletes_places[0] + 'y'
-            if selected_athletes_places[1] != 'x' and int(selected_athletes_places[1]) > 20:
-                agegroup_str += ' Masters'
-        return agegroup_str.replace('x', '')
+                    agegroup_str = selected_athletes_places[0] + "y"
+            if selected_athletes_places[1] != "x" and int(selected_athletes_places[1]) > 20:
+                agegroup_str += " Masters"
+        return agegroup_str.replace("x", "")
 
     @staticmethod
     def get_agegroup_url_from_agegroup_json(agegroup_json):
-        strlist = agegroup_json.split('-')
+        strlist = agegroup_json.split("-")
         for idx in list(range(len(strlist))):
             strlist[idx] = strlist[idx].strip()
-            if strlist[idx] == '':
-                strlist[idx] = 'x'
+            if strlist[idx] == "":
+                strlist[idx] = "x"
 
         if len(strlist) > 1:
-            return '%s_%s' % (strlist[0], strlist[1])
-        if strlist[0] == 'Open':
-            return 'x_x'
+            return "%s_%s" % (strlist[0], strlist[1])
+        if strlist[0] == "Open":
+            return "x_x"
 
-        return '%s_%s' % (strlist[0], strlist[0])
+        return "%s_%s" % (strlist[0], strlist[0])
 
     @staticmethod
     def get_year_fraction_from_datetime(date_in):
@@ -413,40 +478,70 @@ class SsConverter:
         :return: seconds
         """
         if not isinstance(swimtime, list):
-            try:
-                swimtime_sec = datetime.strptime(swimtime, "%M:%S.%f")
-            except ValueError:
-                try:
-                    swimtime_sec = datetime.strptime(swimtime, "%S.%f")
-                except ValueError:
-                    swimtime_sec = datetime.strptime(swimtime, "%H:%M:%S.%f")
-            return swimtime_sec.microsecond * 10 ** -6 + swimtime_sec.second + swimtime_sec.minute * 60 + swimtime_sec.hour * 3600
+            parts = swimtime.split(":")  # Split by colon to check the format
+            if len(parts) == 1:  # Format: %S.%f
+                seconds = float(parts[0])
+            elif len(parts) == 2:  # Format: %M:%S.%f
+                minutes, seconds = map(float, parts)
+                seconds += minutes * 60
+            elif len(parts) == 3:  # Format: %H:%M:%S.%f
+                hours, minutes, seconds = map(float, parts)
+                seconds += minutes * 60 + hours * 3600
+            else:
+                raise ValueError("Invalid time format")
+            return seconds
         else:
             swimtimes_sec = list()
             for entry in swimtime:
-                try:
-                    swimtime_sec = datetime.strptime(entry, "%M:%S.%f")
-                except ValueError:
-                    try:
-                        swimtime_sec = datetime.strptime(entry, "%S.%f")
-                    except ValueError:
-                        swimtime_sec = datetime.strptime(entry, "%H:%M:%S.%f")
-                swimtimes_sec.append(swimtime_sec.microsecond * 10 ** -6 + swimtime_sec.second + swimtime_sec.minute * 60 + swimtime_sec.hour * 3600)
+                parts = entry.split(":")  # Split by colon to check the format
+                if len(parts) == 1:  # Format: %S.%f
+                    seconds = float(parts[0])
+                elif len(parts) == 2:  # Format: %M:%S.%f
+                    minutes, seconds = map(float, parts)
+                    seconds += minutes * 60
+                elif len(parts) == 3:  # Format: %H:%M:%S.%f
+                    hours, minutes, seconds = map(float, parts)
+                    seconds += minutes * 60 + hours * 3600
+                else:
+                    raise ValueError("Invalid time format")
+                swimtimes_sec.append(seconds)
             return swimtimes_sec
 
 
 ssconv = SsConverter()
 
-if __name__ == '__main__':
-    print(ssconv.get_rudolphpts_from_seconds('F', '50m Butterfly', 5, 26.15, 2016))
-    print(ssconv.get_finapts_from_seconds('LCM', 'M', '50m Freestyle', [23.96], 2009))
-    print(ssconv.get_finapts_from_seconds('LCM', 'M', '100m Breaststroke', [56.88]))
-    print(ssconv.get_rudolphpts_from_seconds('F', '200m Backstroke', 9, [203.87], 2024))
-    print(ssconv.get_seconds_from_finapts('LCM', 'M', '100m Freestyle', 900))
-    print(ssconv.get_finapts_from_seconds('SCM', 'M', '50m Freestyle', [20.24], 2020))
+if __name__ == "__main__":
+    ssconv = SsConverter()
+    print(ssconv.get_seconds_from_swimtime("1:23.45"))
+
+    # print(ssconv.get_rudolphpts_from_seconds("F", "50m Butterfly", 5, 26.15, 2016))
+    # print(ssconv.get_seconds_from_rudolphpts("F", "50m Butterfly", 5, 20, 2016))
+
+    print(ssconv.get_rudolphpts_from_seconds("M", "50m Freestyle", 16, 24.73, 2024))
+    print(ssconv.get_seconds_from_rudolphpts("M", "50m Freestyle", 16, 13.9, 2024))
+
+    # print(ssconv.get_rudolphpts_from_seconds("M", "200m Freestyle", 13, 134.41, 2024))
+    # print(ssconv.get_seconds_from_rudolphpts("M", "200m Freestyle", 13, 10, 2024))
+
+    print(ssconv.get_finapts_from_seconds("LCM", "M", "1500m Freestyle", 16 * 60 + 45.63, 2024))
+    print(ssconv.get_seconds_from_finapts("LCM", "M", "1500m Freestyle", 649, 2024))
+
+    print(ssconv.get_finapts_from_seconds("LCM", "M", "1500m Freestyle", 14 * 60 + 30.67, 2025))
+    print(ssconv.get_seconds_from_finapts("LCM", "M", "1500m Freestyle", 1000, 2025))
+
+    print(ssconv.get_finapts_from_seconds("LCM", "M", "1500m Freestyle", 21 * 60 + 40.60, 2025))
+    print(ssconv.get_seconds_from_finapts("LCM", "M", "1500m Freestyle", 300, 2025))
+
+    print(ssconv.get_rudolphpts_from_seconds("M", "50m Backstroke", 16, 26.54, 2025))
+
+    # print(ssconv.get_finapts_from_seconds("LCM", "M", "50m Freestyle", [23.96], 2009))
+    # print(ssconv.get_finapts_from_seconds("LCM", "M", "100m Breaststroke", [56.88]))
+    # print(ssconv.get_rudolphpts_from_seconds("F", "200m Backstroke", 9, [203.87], 2024))
+    # print(ssconv.get_seconds_from_finapts("LCM", "M", "100m Freestyle", 900))
+    # print(ssconv.get_finapts_from_seconds("SCM", "M", "50m Freestyle", [20.24], 2020))
 
-    print(ssconv.get_finapts_from_seconds('LCM', 'F', '200m Freestyle', 112.98))
+    # print(ssconv.get_finapts_from_seconds("LCM", "F", "200m Freestyle", 112.98))
 
-    ssconv.set_fina_season_base('SCM', 2024)
-    ssconv.set_fina_season_base('LCM', 2024)
-    ssconv.set_rudolph_season_base(2024)
+    # ssconv.set_fina_season_base("SCM", 2024)
+    # ssconv.set_fina_season_base("LCM", 2024)
+    # ssconv.set_rudolph_season_base(2024)

{sstools-0.2.6 → sstools-0.2.8}/sstools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sstools
-Version: 0.2.6
+Version: 0.2.8
 Summary: swimstats tools
 Home-page: https://swimstats.net
 Author: Roman Arnet
@@ -10,9 +10,14 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-Requires-Dist: xlrd
 
 # sstools - Swimstats Tools
+0.2.8
+- Add season 2025 FINA SCM
+
+0.2.7
+- Trunc FINA calculation
+- Add Rudolph-Punkttabelle 2025
 
 0.2.6
 - Fix available styles

{sstools-0.2.6 → sstools-0.2.8}/sstools.egg-info/SOURCES.txt

@@ -3,12 +3,11 @@ README.md
 setup.py
 sstools/__init__.py
 sstools/fina_base_times.pkl
-sstools/rudolph_points_table.xls
+sstools/rudolph_punkttabelle.pkl
 sstools/ssconv.py
 sstools.egg-info/PKG-INFO
 sstools.egg-info/SOURCES.txt
 sstools.egg-info/dependency_links.txt
-sstools.egg-info/requires.txt
 sstools.egg-info/top_level.txt
 tests/__init__.py
 tests/test_ssconv.py

sstools-0.2.8/tests/test_ssconv.py

@@ -0,0 +1,87 @@
+import logging.config
+import unittest
+
+from sstools.ssconv import ssconv
+
+logging.config.dictConfig({
+    'version': 1,
+    'disable_existing_loggers': False,
+    'formatters': {
+        'default': {
+            'format': '%(asctime)s %(name)-30s %(levelname)-8s %(message)s',
+            '()': 'multiline_formatter.formatter.MultilineMessagesFormatter',
+        },
+    },
+    'handlers': {
+        'console': {
+            'level': 'INFO',
+            'class': 'logging.StreamHandler',
+            'formatter': 'default',
+        },
+    },
+    'loggers': {
+        # '' root logger
+        '': {
+            'level': 'DEBUG',
+            'handlers': ['console'],
+        },
+    },
+})
+
+logger = logging.getLogger()
+
+
+
+
+class ConverterTest(unittest.TestCase):
+    # Conversion is verified with the FINA Points Calculator 6.47605
+    @classmethod
+    def setUpClass(cls):
+        pass
+
+    # preparing to test
+    def setUp(self):
+        """ Setting up for the test """
+
+    def tearDown(self):
+        """Cleaning up after the test"""
+
+    def test_finapts(self):
+        finapts_refs = [1, 999, 1000, 1001]
+        available_styles = ssconv.get_available_styles()
+        genders = ['M', 'F']
+        courses = ['SCM', 'LCM']
+        for finapts_ref in finapts_refs:
+            for style in available_styles:
+                for gender in genders:
+                    for course in courses:
+                        if style != '100m Medley' and course != 'LCM':
+                            swimtime = ssconv.get_seconds_from_finapts(course, gender, style, finapts_ref)
+                            finapts = ssconv.get_finapts_from_seconds(course, gender, style, swimtime)
+                            self.assertAlmostEqual(finapts_ref, finapts, delta=1)
+
+
+    def test_get_rudolphpts_from_seconds(self):
+        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 9, 20), 20)
+        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 9, [76.07, 75, 74], 2024), [14.9, 15.9, 16.8])
+
+
+        # # https://www.swimrankings.net/index.php?page=athleteDetail&athleteId=4605725&pbest=2013
+        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 8, 106.65, 2024), 0)
+        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 9, 76.07, 2024), 14.9)
+        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 10, 66.99, 2024), 18.7)
+        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 11, 61.2, 2024), 18.9)
+        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 12, 57.16, 2024), 18.9)
+        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 13, 55.56, 2024), 17.4)
+        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 14, 52.67, 2024), 18.6)
+        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 15, 50.9, 2024), 19.1)
+        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 16, 50.68, 2024), 18.5)
+
+
+    def test_get_seconds_from_rudolphpts(self):
+        self.assertEqual(ssconv.get_seconds_from_rudolphpts('M', '100m Freestyle', 9, [15.3, 16.2, 17.2], 2024), [75.633, 74.652, 73.562])
+
+
+if __name__ == '__main__':
+    suite = unittest.TestLoader().loadTestsFromTestCase(ConverterTest)
+    unittest.TextTestRunner(verbosity=2).run(suite)

sstools-0.2.6/sstools.egg-info/requires.txt

@@ -1 +0,0 @@
-xlrd

sstools-0.2.6/tests/test_ssconv.py

@@ -1,200 +0,0 @@
-import logging.config
-import unittest
-
-from sstools.ssconv import ssconv
-
-logging.config.dictConfig({
-    'version': 1,
-    'disable_existing_loggers': False,
-    'formatters': {
-        'default': {
-            'format': '%(asctime)s %(name)-30s %(levelname)-8s %(message)s',
-            '()': 'multiline_formatter.formatter.MultilineMessagesFormatter',
-        },
-    },
-    'handlers': {
-        'console': {
-            'level': 'INFO',
-            'class': 'logging.StreamHandler',
-            'formatter': 'default',
-        },
-    },
-    'loggers': {
-        # '' root logger
-        '': {
-            'level': 'DEBUG',
-            'handlers': ['console'],
-        },
-    },
-})
-
-logger = logging.getLogger()
-#                                                      Freestyle                                  Backstroke                 Breaststroke                       Butterfly                     Medley
-#                       50       100      200         400         800         1500        50       100      200         50       100         200         50       100      200         100       200         400
-m_lcm_fina_1000_2023 = ['20.91', '46.86', '01:42.00', '03:40.07', '07:32.12', '14:31.02', '23.71', '51.60', '01:51.92', '25.95', '56.88', '02:05.95', '22.27', '49.45', '01:50.34', '01:54.0', '04:03.84']
-f_lcm_fina_1000_2023 = ['23.67', '51.71', '01:52.98', '03:56.40', '08:04.79', '15:20.48', '26.98', '57.45', '02:03.35', '29.30', '01:04.13', '02:18.95', '24.43', '55.48', '02:01.81', '02:06.12', '04:26.36']
-m_scm_fina_1000_2023 = ['20.16', '44.84', '01:39.37', '03:32.25', '07:23.42', '14:06.88', '22.11', '48.33', '01:45.63', '24.95', '55.28', '02:00.16', '21.75', '47.78', '01:46.85', '49.28', '01:49.63', '03:54.81']
-f_scm_fina_1000_2023 = ['22.93', '50.25', '01:50.31', '03:51.30', '07:57.42', '15:08.24', '25.25', '54.89', '01:58.94', '28.37', '01:02.36', '02:14.57', '24.38', '54.05', '01:59.61', '56.51', '02:01.86', '04:18.94']
-
-m_lcm_fina_1000_2022 = ['20.91', '46.91', '01:42.00', '03:40.07', '07:32.12', '14:31.02', '23.8', '51.85', '01:51.92', '25.95', '56.88', '02:06.12', '22.27', '49.45', '01:50.73', '01:54.0', '04:03.84']
-f_lcm_fina_1000_2022 = ['23.67', '51.71', '01:52.98', '03:56.46', '08:04.79', '15:20.48', '26.98', '57.45', '02:03.35', '29.30', '01:04.13', '02:18.95', '24.43', '55.48', '02:01.81', '02:06.12', '04:26.36']
-m_scm_fina_1000_2022 = ['20.16', '44.84', '01:39.37', '03:32.25', '07:23.42', '14:06.88', '22.22', '48.33', '01:45.63', '24.95', '55.28', '02:00.16', '21.75', '47.78', '01:48.24', '49.28', '01:49.63', '03:54.81']
-f_scm_fina_1000_2022 = ['22.93', '50.25', '01:50.31', '03:53.92', '07:59.34', '15:18.01', '25.27', '54.89', '01:58.94', '28.56', '01:02.36', '02:14.57', '24.38', '54.59', '01:59.61', '56.51', '02:01.86', '04:18.94']
-
-m_lcm_fina_1000_2021 = ['20.91', '46.91', '01:42.00', '03:40.07', '07:32.12', '14:31.02', '24.0', '51.85', '01:51.92', '25.95', '56.88', '02:06.12', '22.27', '49.5', '01:50.73', '01:54.0', '04:03.84']
-m_scm_fina_1000_2021 = ['20.16', '44.94', '01:39.37', '03:32.25', '07:23.42', '14:08.06', '22.22', '48.33', '01:45.63', '25.25', '55.34', '02:00.16', '21.75', '47.78', '01:48.24', '49.28', '01:49.63', '03:54.81']
-f_lcm_fina_1000_2021 = ['23.67', '51.71', '01:52.98', '03:56.46', '08:04.79', '15:20.48', '26.98', '57.57', '02:03.35', '29.40', '01:04.13', '02:19.11', '24.43', '55.48', '02:01.81', '02:06.12', '04:26.36']
-f_scm_fina_1000_2021 = ['22.93', '50.25', '01:50.43', '03:53.92', '07:59.34', '15:18.01', '25.60', '54.89', '01:58.94', '28.56', '01:02.36', '02:14.57', '24.38', '54.61', '01:59.61', '56.51', '02:01.86', '04:18.94']
-
-m_lcm_fina_1000_2020 = ['20.91', '46.91', '01:42.0', '03:40.07', '07:32.12', '14:31.02', '24.0', '51.85', '01:51.92', '25.95', '56.88', '02:06.12', '22.27', '49.5', '01:50.73', '01:54.0', '04:03.84']
-m_scm_fina_1000_2020 = ['20.24', '44.94', '01:39.37', '03:32.25', '07:23.42', '14:08.06', '22.22', '48.88', '01:45.63', '25.25', '55.61', '02:00.16', '21.75', '48.08', '01:48.24', '50.26', '01:49.63', '03:54.81']
-f_lcm_fina_1000_2020 = ['23.67', '51.71', '01:52.98', '03:56.46', '08:04.79', '15:20.48', '26.98', '57.57', '02:03.35', '29.40', '01:04.13', '02:19.11', '24.43', '55.48', '02:01.81', '02:06.12', '04:26.36']
-f_scm_fina_1000_2020 = ['22.93', '50.25', '01:50.43', '03:53.92', '07:59.34', '15:18.01', '25.67', '54.89', '01:59.23', '28.56', '01:02.36', '02:14.57', '24.38', '54.61', '01:59.61', '56.51', '02:01.86', '04:18.94']
-
-m_lcm_fina = ssconv.get_seconds_from_swimtime(m_lcm_fina_1000_2023)
-f_lcm_fina = ssconv.get_seconds_from_swimtime(f_lcm_fina_1000_2023)
-
-m_scm_fina = ssconv.get_seconds_from_swimtime(m_scm_fina_1000_2023)
-f_scm_fina = ssconv.get_seconds_from_swimtime(f_scm_fina_1000_2023)
-
-
-class ConverterTest(unittest.TestCase):
-    # Conversion is verified with the FINA Points Calculator 6.47605
-    @classmethod
-    def setUpClass(cls):
-        pass
-
-    # preparing to test
-    def setUp(self):
-        """ Setting up for the test """
-
-    def tearDown(self):
-        """Cleaning up after the test"""
-
-    def test_get_finapts_from_seconds(self):
-        # Male
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '50m Freestyle', [m_lcm_fina[0]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '50m Freestyle', [m_scm_fina[0]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '100m Freestyle', [m_lcm_fina[1]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '100m Freestyle', [m_scm_fina[1]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '200m Freestyle', [m_lcm_fina[2]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '200m Freestyle', [m_scm_fina[2]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '400m Freestyle', [m_lcm_fina[3]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '400m Freestyle', [m_scm_fina[3]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '800m Freestyle', [m_lcm_fina[4]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '800m Freestyle', [m_scm_fina[4]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '1500m Freestyle', [m_lcm_fina[5]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '1500m Freestyle', [m_scm_fina[5]]), [1000])
-
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '50m Backstroke', [m_lcm_fina[6]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '50m Backstroke', [m_scm_fina[6]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '100m Backstroke', [m_lcm_fina[7]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '100m Backstroke', [m_scm_fina[7]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '200m Backstroke', [m_lcm_fina[8]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '200m Backstroke', [m_scm_fina[8]]), [1000])
-
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '50m Breaststroke', [m_lcm_fina[9]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '50m Breaststroke', [m_scm_fina[9]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '100m Breaststroke', [m_lcm_fina[10]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '100m Breaststroke', [m_scm_fina[10]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '200m Breaststroke', [m_lcm_fina[11]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '200m Breaststroke', [m_scm_fina[11]]), [1000])
-
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '50m Butterfly', [m_lcm_fina[12]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '50m Butterfly', [m_scm_fina[12]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '100m Butterfly', [m_lcm_fina[13]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '100m Butterfly', [m_scm_fina[13]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '200m Butterfly', [m_lcm_fina[14]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '200m Butterfly', [m_scm_fina[14]]), [1000])
-
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '100m Medley', [m_scm_fina[15]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '200m Medley', [m_lcm_fina[15]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '200m Medley', [m_scm_fina[16]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'M', '400m Medley', [m_lcm_fina[16]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'M', '400m Medley', [m_scm_fina[17]]), [1000])
-
-        # Female
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '50m Freestyle', [f_lcm_fina[0]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '50m Freestyle', [f_scm_fina[0]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '100m Freestyle', [f_lcm_fina[1]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '100m Freestyle', [f_scm_fina[1]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '200m Freestyle', [f_lcm_fina[2]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '200m Freestyle', [f_scm_fina[2]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '400m Freestyle', [f_lcm_fina[3]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '400m Freestyle', [f_scm_fina[3]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '800m Freestyle', [f_lcm_fina[4]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '800m Freestyle', [f_scm_fina[4]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '1500m Freestyle', [f_lcm_fina[5]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '1500m Freestyle', [f_scm_fina[5]]), [1000])
-
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '50m Backstroke', [f_lcm_fina[6]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '50m Backstroke', [f_scm_fina[6]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '100m Backstroke', [f_lcm_fina[7]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '100m Backstroke', [f_scm_fina[7]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '200m Backstroke', [f_lcm_fina[8]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '200m Backstroke', [f_scm_fina[8]]), [1000])
-
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '50m Breaststroke', [f_lcm_fina[9]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '50m Breaststroke', [f_scm_fina[9]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '100m Breaststroke', [f_lcm_fina[10]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '100m Breaststroke', [f_scm_fina[10]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '200m Breaststroke', [f_lcm_fina[11]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '200m Breaststroke', [f_scm_fina[11]]), [1000])
-
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '50m Butterfly', [f_lcm_fina[12]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '50m Butterfly', [f_scm_fina[12]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '100m Butterfly', [f_lcm_fina[13]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '100m Butterfly', [f_scm_fina[13]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '200m Butterfly', [f_lcm_fina[14]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '200m Butterfly', [f_scm_fina[14]]), [1000])
-
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '100m Medley', [f_scm_fina[15]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '200m Medley', [f_lcm_fina[15]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '200m Medley', [f_scm_fina[16]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('LCM', 'F', '400m Medley', [f_lcm_fina[16]]), [1000])
-        self.assertEqual(ssconv.get_finapts_from_seconds('SCM', 'F', '400m Medley', [f_scm_fina[17]]), [1000])
-
-    # @unittest.skip
-    def test_get_seconds_from_finapts(self):
-        self.assertEqual(ssconv.get_seconds_from_finapts('SCM', 'M', '100m Freestyle', 1000), 44.84)
-        self.assertEqual(ssconv.get_seconds_from_finapts('LCM', 'M', '100m Freestyle', 1000), 46.86)
-        self.assertEqual(ssconv.get_seconds_from_finapts('SCM', 'F', '100m Freestyle', 1000), 50.25)
-        self.assertEqual(ssconv.get_seconds_from_finapts('LCM', 'F', '100m Freestyle', 1000), 51.71)
-
-        self.assertEqual(ssconv.get_seconds_from_finapts('SCM', 'M', '100m Butterfly', 1000), 47.78)
-        self.assertEqual(ssconv.get_seconds_from_finapts('LCM', 'M', '100m Butterfly', 1000), 49.45)
-        self.assertEqual(ssconv.get_seconds_from_finapts('SCM', 'F', '100m Butterfly', 1000), 54.05)
-        self.assertEqual(ssconv.get_seconds_from_finapts('LCM', 'F', '100m Butterfly', 1000), 55.48)
-
-    @unittest.skip
-    def test_get_rudolphpts_from_seconds(self):
-        print(ssconv.get_rudolphpts_from_seconds('F', '100m Breaststroke', 20, 122.83))
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 9, 20), 20)
-
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 9, [76.07, 75, 74]), [14.9, 15.9, 16.8])
-
-        # https://www.swimrankings.net/index.php?page=athleteDetail&athleteId=4605725&pbest=2013
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 8, 106.65), 0)
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 9, 76.07), 14.9)
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 10, 66.99), 18.9)
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 11, 61.2), 19.4)
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 12, 57.16), 19.4)
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 13, 55.56), 17.9)
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 14, 52.8), 18.9)
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 15, 50.9), 19.4)
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('M', '100m Freestyle', 16, 50.68), 18.8)
-
-        # https://www.swimrankings.net/index.php?page=athleteDetail&athleteId=4043784&pbest=2009
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('F', '200m Freestyle', 17, 131.62), 11.2)
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('F', '200m Freestyle', 18, 126.16), 14.2)
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('F', '200m Freestyle', 19, 125.46), 13.3)
-        self.assertEqual(ssconv.get_rudolphpts_from_seconds('F', '200m Freestyle', 20, 122.83), 14.8)
-
-    @unittest.skip
-    def test_get_seconds_from_rudolphpts(self):
-        self.assertEqual(ssconv.get_seconds_from_rudolphpts('M', '100m Freestyle', 9, [15.3, 16.2, 17.2]), [75.633, 74.652, 73.562])
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(ConverterTest)
-    unittest.TextTestRunner(verbosity=2).run(suite)