bepfe-export-parser 0.6.3__tar.gz

bepfe_export_parser-0.6.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Lance Watermelon
+
+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.

bepfe_export_parser-0.6.3/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: bepfe-export-parser
+Version: 0.6.3
+Summary: Parses CSV files exported from Bepfe race manager software.
+License: MIT
+License-File: LICENSE
+Author: Lars Wagner
+Author-email: wagner1975@web.de
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Description-Content-Type: text/markdown
+
+# bepfe-export-parser
+Python library for parsing CSV files exported from Bepfe racing software.
+
+To be continued......

bepfe_export_parser-0.6.3/README.md

@@ -0,0 +1,4 @@
+# bepfe-export-parser
+Python library for parsing CSV files exported from Bepfe racing software.
+
+To be continued......

bepfe_export_parser-0.6.3/pyproject.toml

@@ -0,0 +1,78 @@
+[project]
+name = "bepfe-export-parser"
+version = "0.6.3"
+description = "Parses CSV files exported from Bepfe race manager software."
+authors = [
+    {name = "Lars Wagner",email = "wagner1975@web.de"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.12,<4.0"
+dependencies = [
+]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[dependency-groups]
+dev = [
+    "mypy (>=1.19.1,<2.0.0)",
+    "pytest (>=9.0.2,<10.0.0)",
+    "ruff (>=0.14.13,<0.15.0)",
+    "pytest-mock (>=3.15.1,<4.0.0)",
+    "pytest-cov (>=7.1.0,<8.0.0)",
+    "coverage (>=7.14.1,<8.0.0)",
+    "python-semantic-release (>=10.5.3,<11.0.0)",
+]
+
+[tool.semantic_release]
+version_toml = ["pyproject.toml:project.version"]
+
+# to have a first version when no github version tags are available yet
+initial_version = "0.1.0"
+
+# commit message conventions
+commit_parser = "conventional"
+
+# how to format the git tag
+tag_format = "v{version}"
+
+# uses this command for building the package
+build_command = "poetry build"
+
+# allow versions starting like 0.x.y
+allow_zero_version = true
+
+upload_to_vcs_release = true
+
+[tool.semantic_release.remote]
+name = "origin"
+
+[tool.semantic_release.branches.main]
+match = "main"
+prerelease = false
+
+[tool.semantic_release.branches.develop]
+match = "develop"
+prerelease = true
+prerelease_token = "rc"
+
+[tool.mypy]
+strict = true
+files = "./src"
+exclude = ".*__init__\\.py$"
+
+[tool.pytest]
+pythonpath = ["./src"]
+testpaths = ["tests"]
+
+[tool.coverage.run]
+source = ["bepfe_export_parser"]
+omit = [
+    "tests/*",
+]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = false

bepfe_export_parser-0.6.3/src/bepfe_export_parser/exceptions.py

@@ -0,0 +1,6 @@
+class ConvertingError(Exception):
+    pass
+
+
+class InvalidRowError(Exception):
+    pass

bepfe_export_parser-0.6.3/src/bepfe_export_parser/util.py

@@ -0,0 +1,67 @@
+from decimal import Decimal
+
+
+def convert_comma_string_to_decimal(s: str) -> Decimal:
+    return Decimal(s.replace(",", "."))
+
+
+def convert_time_string_to_decimal(s: str) -> Decimal:
+    result = Decimal("0.0")
+
+    point_parts = s.split(".")
+    if len(point_parts) > 2:
+        raise IndexError("Too many point separated parts")
+    if len(point_parts) > 1:
+        result = result + Decimal(f"0.{point_parts[1]}")
+
+    colon_parts = point_parts[0].split(":")
+    if len(colon_parts) > 3:
+        raise IndexError("Too many colon separated parts")
+    colon_parts.reverse()
+    if len(colon_parts) > 0:
+        result += int(colon_parts[0])
+    if len(colon_parts) > 1:
+        result += int(colon_parts[1]) * 60
+    if len(colon_parts) > 2:
+        result += int(colon_parts[2]) * 3600
+
+    return result
+
+
+def normalize_date_string(date_str: str, separator: str = ".") -> str:
+    if len(separator) < 1:
+        raise ValueError("separator is invalid")
+
+    day, month, year = date_str.split(separator)
+
+    len_day = len(day)
+    if len_day < 1 or len_day > 2:
+        raise ValueError("day string has invalid length")
+    if not day.isnumeric():
+        raise ValueError("day string is not numeric")
+    d = int(day)
+    if d < 1 or d > 31:
+        raise ValueError("day value is out of range")
+
+    len_month = len(month)
+    if len_month < 1 or len_month > 2:
+        raise ValueError("month string has invalid length")
+    if not month.isnumeric():
+        raise ValueError("month string is not numeric")
+    m = int(month)
+    if m < 1 or m > 12:
+        raise ValueError("month value is out of range")
+
+    len_year = len(year)
+    if len_year != 2 and len_year != 4:
+        raise ValueError("year string has invalid length")
+    if not year.isnumeric():
+        raise ValueError("year string is not numeric")
+    y = int(year)
+    if len_year == 2:
+        offset = 2000 if y < 80 else 1900
+        y += offset
+    if y < 1000:
+        raise ValueError("year value is out of range")
+
+    return separator.join([f"{int(d):02d}", f"{int(m):02d}", f"{int(y):04d}"])

bepfe_export_parser-0.6.3/src/bepfe_export_parser/win/convert.py

@@ -0,0 +1,31 @@
+from decimal import Decimal
+
+from bepfe_export_parser.exceptions import ConvertingError
+from bepfe_export_parser.util import (
+    convert_comma_string_to_decimal,
+    convert_time_string_to_decimal,
+)
+
+
+def convert_str_to_int(s: str, err_msg: str | None = None) -> int:
+    try:
+        return int(s)
+    except Exception as exc:
+        new_exc = ConvertingError(err_msg) if err_msg else ConvertingError()
+        raise new_exc from exc
+
+
+def convert_comma_str_to_decimal(s: str, err_msg: str | None = None) -> Decimal:
+    try:
+        return convert_comma_string_to_decimal(s)
+    except Exception as exc:
+        new_exc = ConvertingError(err_msg) if err_msg else ConvertingError()
+        raise new_exc from exc
+
+
+def convert_time_str_to_decimal(s: str, err_msg: str | None = None) -> Decimal:
+    try:
+        return convert_time_string_to_decimal(s)
+    except Exception as exc:
+        new_exc = ConvertingError(err_msg) if err_msg else ConvertingError()
+        raise new_exc from exc

bepfe_export_parser-0.6.3/src/bepfe_export_parser/win/file.py

@@ -0,0 +1,55 @@
+import csv
+import re
+import os
+
+from datetime import date, datetime
+
+from bepfe_export_parser.util import normalize_date_string
+from bepfe_export_parser.win.model import FileData
+from bepfe_export_parser.win.parse.base import ContentParser
+from bepfe_export_parser.win.reader import StatefulRowReader
+
+
+class FileDataExtractor:
+    def __init__(
+        self,
+        filepath: str,
+        newline: str = "",
+        encoding: str = "cp1252",
+        delimiter: str = ";",
+    ) -> None:
+        self._filepath = filepath
+        self._newline = newline
+        self._encoding = encoding
+        self._delimiter = delimiter
+
+    def _extract_date_from_filename(self) -> date | None:
+        result = None
+
+        filename = os.path.basename(self._filepath)
+
+        match = re.search(r"\d{2}\.\d{2}\.\d{4}", filename)
+        if not match:
+            match = re.search(r"\d{2}\.\d{2}\.\d{2}", filename)
+
+        if match:
+            date_str = normalize_date_string(match.group())
+            result = datetime.strptime(date_str, "%d.%m.%Y").date()
+
+        return result
+
+    def extract(self) -> FileData:
+        date_from_filename = self._extract_date_from_filename()
+
+        with open(
+            self._filepath, newline=self._newline, encoding=self._encoding
+        ) as stream:
+            content = ContentParser(
+                StatefulRowReader(csv.reader(stream, delimiter=self._delimiter))
+            ).parse()
+
+            return FileData(
+                filepath=self._filepath,
+                date_from_filename=date_from_filename,
+                content=content,
+            )

bepfe_export_parser-0.6.3/src/bepfe_export_parser/win/model.py

@@ -0,0 +1,121 @@
+from dataclasses import dataclass
+from datetime import date
+from decimal import Decimal
+from enum import Enum
+
+
+class RaceTypeEnum(Enum):
+    MULTI_RACE = "Serienrennen"
+
+
+class RaceModeEnum(Enum):
+    F1 = "F1-Modus"
+    SLOT = "Slot-Modus"
+
+
+class HeatLengthUnitEnum(Enum):
+    SECONDS = "SECONDS"
+    LAPS = "LAPS"
+
+
+@dataclass
+class PersonalizedLapsInHeat:
+    driver_name: str
+    heat_num: int
+    lane_num: int
+    lap_count: Decimal
+
+
+@dataclass
+class DetailedLapTimeInHeat:
+    heat_num: int
+    lane_num: int
+    lap_time: Decimal
+    lap_num: int
+
+
+@dataclass
+class PersonalizedLapTimeInHeat:
+    driver_name: str
+    heat_num: int
+    lane_num: int
+    lap_time: Decimal
+
+
+@dataclass
+class HeatLength:
+    value: int
+    unit: HeatLengthUnitEnum
+
+
+@dataclass
+class QualifyingEntry:
+    position_num: int
+    driver_name: str
+    lap_time: Decimal
+
+
+@dataclass
+class ShortResultEntry:
+    position_num: int
+    driver_name: str
+    total_lap_count: Decimal
+    total_time: Decimal
+    average_lap_time: Decimal
+    fastest_lap: DetailedLapTimeInHeat
+
+
+@dataclass
+class LapsOnLane:
+    round_num: int
+    # for multiple driver appearances on the same lane: first round = 1, second round = 2, ...
+    lane_num: int
+    # lane number: 1, 2, 3, ...
+    lap_count: Decimal
+    # lap count on lane at round
+
+
+@dataclass
+class LapsPerLaneOverviewEntry:
+    driver_name: str
+    # name of the driver
+    heats: list[LapsOnLane]
+    # values for all heats driven
+
+
+@dataclass
+class LapTimeOnLane:
+    round_num: int
+    # for multiple driver appearances on the same lane: first round = 1, second round = 2, ...
+    lane_num: int
+    # lane number: 1, 2, 3, ...
+    lap_time: Decimal
+    # lap time on lane at round
+
+
+@dataclass
+class FastestLapsOverviewEntry:
+    driver_name: str
+    # name of the driver
+    heats: list[LapTimeOnLane]
+    # values for all lanes driven
+
+
+@dataclass
+class Content:
+    race_type: RaceTypeEnum
+    race_mode: RaceModeEnum
+    heat_length: HeatLength
+    qualifying: list[QualifyingEntry]
+    best_heat: PersonalizedLapsInHeat | None
+    fastest_lap: PersonalizedLapTimeInHeat | None
+    short_result: list[ShortResultEntry]
+    laps_per_lane_overview: list[LapsPerLaneOverviewEntry]
+    fastest_laps_overview: list[FastestLapsOverviewEntry]
+
+
+@dataclass
+class FileData:
+    filepath: str
+    date_from_filename: date | None
+    content: Content

bepfe_export_parser-0.6.3/src/bepfe_export_parser/win/parse/abstract.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from bepfe_export_parser.win.reader import StatefulRowReader
+
+
+class AbstractParser(ABC):
+    @abstractmethod
+    def parse(self) -> Any:
+        pass
+
+
+class DefaultParser(AbstractParser):
+    def __init__(self, reader: StatefulRowReader) -> None:
+        self._reader = reader
+
+    def _get_reader(self) -> StatefulRowReader:
+        return self._reader

bepfe_export_parser-0.6.3/src/bepfe_export_parser/win/parse/base.py

@@ -0,0 +1,103 @@
+from typing import Any
+
+from bepfe_export_parser.win.model import Content
+from bepfe_export_parser.win.parse.abstract import DefaultParser
+from bepfe_export_parser.win.parse.constants import (
+    BEST_HEAT_MARKER,
+    FASTEST_LAP_MARKER,
+    FASTEST_LAPS_OVERVIEW_MARKER,
+    HEAT_LENGTH_MARKER,
+    LAPS_PER_LANE_OVERVIEW_MARKER,
+    QUALIFYING_MARKER,
+    RACE_MODE_MARKER,
+    RACE_TYPE_MARKER,
+    SHORT_RESULT_MARKER,
+)
+from bepfe_export_parser.win.parse.heat_info import (
+    HeatLapsInfoParser,
+    HeatTimeInfoParser,
+)
+from bepfe_export_parser.win.parse.result import QualifyingParser, ShortResultParser
+from bepfe_export_parser.win.parse.settings import (
+    HeatLengthParser,
+    RaceModeParser,
+    RaceTypeParser,
+)
+from bepfe_export_parser.win.parse.overview import (
+    FastestLapsOverviewParser,
+    LapsPerLaneOverviewParser,
+)
+from bepfe_export_parser.win.reader import StatefulRowReader
+
+
+class ContentCollector:
+    _results: dict[str, Any]
+
+    def __init__(self) -> None:
+        self._results = {}
+
+    def add_result(self, key: str, result: Any) -> None:
+        self._results[key] = result
+
+    def construct_model(self) -> Content:
+        race_type = self._results.get(RACE_TYPE_MARKER)
+        if not race_type:
+            raise KeyError("race type result is missing")
+
+        race_mode = self._results.get(RACE_MODE_MARKER)
+        if not race_mode:
+            raise KeyError("race mode result is missing")
+
+        heat_length = self._results.get(HEAT_LENGTH_MARKER)
+        if not heat_length:
+            raise KeyError("heat length result is missing")
+
+        qualifying = self._results.get(QUALIFYING_MARKER, [])
+
+        best_heat = self._results.get(BEST_HEAT_MARKER)
+        fastest_lap = self._results.get(FASTEST_LAP_MARKER)
+        short_result = self._results.get(SHORT_RESULT_MARKER, [])
+
+        laps_per_lane_overview = self._results.get(LAPS_PER_LANE_OVERVIEW_MARKER, [])
+        fastest_laps_overview = self._results.get(FASTEST_LAPS_OVERVIEW_MARKER, [])
+
+        return Content(
+            race_type=race_type,
+            race_mode=race_mode,
+            heat_length=heat_length,
+            qualifying=qualifying,
+            best_heat=best_heat,
+            fastest_lap=fastest_lap,
+            short_result=short_result,
+            laps_per_lane_overview=laps_per_lane_overview,
+            fastest_laps_overview=fastest_laps_overview,
+        )
+
+
+class ContentParser(DefaultParser):
+    def __init__(self, reader: StatefulRowReader) -> None:
+        super().__init__(reader)
+        self._mapped_parsers: dict[str, type[DefaultParser]] = {
+            RACE_TYPE_MARKER: RaceTypeParser,
+            RACE_MODE_MARKER: RaceModeParser,
+            HEAT_LENGTH_MARKER: HeatLengthParser,
+            QUALIFYING_MARKER: QualifyingParser,
+            BEST_HEAT_MARKER: HeatLapsInfoParser,
+            FASTEST_LAP_MARKER: HeatTimeInfoParser,
+            SHORT_RESULT_MARKER: ShortResultParser,
+            LAPS_PER_LANE_OVERVIEW_MARKER: LapsPerLaneOverviewParser,
+            FASTEST_LAPS_OVERVIEW_MARKER: FastestLapsOverviewParser,
+        }
+
+    def parse(self) -> Content:
+        collector = ContentCollector()
+        reader = self._get_reader()
+        while (current_row := reader.fetch_next_row()) is not None:
+            if len(current_row) < 1:
+                continue
+            marker = current_row[0]
+            current_parser = self._mapped_parsers.get(marker)
+            if current_parser:
+                collector.add_result(marker, current_parser(reader).parse())
+
+        return collector.construct_model()

bepfe_export_parser-0.6.3/src/bepfe_export_parser/win/parse/constants.py

@@ -0,0 +1,17 @@
+HEAT_LABEL = "Lauf"
+LANE_LABEL = "Spur"
+
+ROUNDS_UNIT = "R"
+SECONDS_UNIT = "s"
+
+MINUTES_UNIT = "Minuten"
+
+RACE_TYPE_MARKER = "Typ"
+RACE_MODE_MARKER = "Modus"
+HEAT_LENGTH_MARKER = "Vorgabe"
+QUALIFYING_MARKER = "Qualifikation"
+FASTEST_LAP_MARKER = "Bestzeit"
+BEST_HEAT_MARKER = "Bester Lauf"
+SHORT_RESULT_MARKER = "Kurzergebnis"
+LAPS_PER_LANE_OVERVIEW_MARKER = "Ergebnis-Spurübersicht Runden"
+FASTEST_LAPS_OVERVIEW_MARKER = "Bestzeiten-Übersicht"

bepfe_export_parser-0.6.3/src/bepfe_export_parser/win/parse/heat_info.py

@@ -0,0 +1,86 @@
+from decimal import Decimal
+
+from bepfe_export_parser.win.convert import (
+    convert_str_to_int,
+    convert_comma_str_to_decimal,
+)
+from bepfe_export_parser.win.model import (
+    PersonalizedLapsInHeat,
+    PersonalizedLapTimeInHeat,
+)
+from bepfe_export_parser.win.parse.abstract import DefaultParser
+from bepfe_export_parser.win.parse.constants import (
+    HEAT_LABEL,
+    LANE_LABEL,
+    ROUNDS_UNIT,
+    SECONDS_UNIT,
+)
+from bepfe_export_parser.exceptions import ConvertingError
+
+
+class HeatRelatedParser(DefaultParser):
+    @staticmethod
+    def _convert_int_with_label(text: str, label: str, col_name: str) -> int:
+        parts = text.split()
+
+        if len(parts) != 2:
+            raise ConvertingError(f"text in {col_name} column is invalid")
+
+        label_part, value_part = parts
+
+        if not label_part.startswith(label):
+            raise ConvertingError(f"label part in {col_name} column is invalid")
+
+        return convert_str_to_int(
+            value_part, f"value part in {col_name} column is invalid"
+        )
+
+    @staticmethod
+    def _convert_decimal_with_unit(text: str, unit: str, col_name: str) -> Decimal:
+        parts = text.split()
+
+        if len(parts) != 2:
+            raise ConvertingError(f"text in {col_name} column is invalid")
+
+        value_part, unit_part = parts
+
+        result = convert_comma_str_to_decimal(
+            value_part, f"value part in {col_name} column is invalid"
+        )
+
+        if unit_part.strip() != unit:
+            raise ConvertingError(f"unit part in {col_name} column is invalid")
+
+        return result
+
+    def _extract_heat_common_info(self) -> tuple[str, str, int, int]:
+        current_row = self._get_reader().get_current_row_checked(5)
+
+        driver_name = current_row[1]
+        mixed = current_row[2]
+        heat_num = HeatRelatedParser._convert_int_with_label(
+            current_row[3], HEAT_LABEL, "heat"
+        )
+        lane_num = HeatRelatedParser._convert_int_with_label(
+            current_row[4], LANE_LABEL, "lane"
+        )
+
+        return (driver_name, mixed, heat_num, lane_num)
+
+
+class HeatLapsInfoParser(HeatRelatedParser):
+    def parse(self) -> PersonalizedLapsInHeat:
+        driver, text, heat, lane = self._extract_heat_common_info()
+        value = HeatRelatedParser._convert_decimal_with_unit(text, ROUNDS_UNIT, "laps")
+        return PersonalizedLapsInHeat(
+            driver_name=driver, heat_num=heat, lane_num=lane, lap_count=value
+        )
+
+
+class HeatTimeInfoParser(HeatRelatedParser):
+    def parse(self) -> PersonalizedLapTimeInHeat:
+        driver, text, heat, lane = self._extract_heat_common_info()
+        value = HeatRelatedParser._convert_decimal_with_unit(text, SECONDS_UNIT, "time")
+        return PersonalizedLapTimeInHeat(
+            driver_name=driver, heat_num=heat, lane_num=lane, lap_time=value
+        )

bepfe_export_parser-0.6.3/src/bepfe_export_parser/win/parse/overview.py

@@ -0,0 +1,127 @@
+from decimal import Decimal
+
+from bepfe_export_parser.exceptions import InvalidRowError
+from bepfe_export_parser.win.convert import (
+    convert_comma_str_to_decimal,
+    convert_str_to_int,
+)
+from bepfe_export_parser.win.model import (
+    FastestLapsOverviewEntry,
+    LapTimeOnLane,
+    LapsOnLane,
+    LapsPerLaneOverviewEntry,
+)
+from bepfe_export_parser.win.parse.abstract import DefaultParser
+from bepfe_export_parser.win.reader import StatefulRowReader
+
+
+class LanesRelatedOverviewParser:
+    _NUM_COLS_BEFORE_LANES = 2
+    _BROKEN_COL_STR = "'-"
+
+    def __init__(self, reader: StatefulRowReader) -> None:
+        self._reader = reader
+
+    def _fetch_header_lane_numbers(self) -> list[int]:
+        header_row = self._reader.fetch_next_row()
+        if header_row is None or len(header_row) == 0:
+            raise InvalidRowError("header is not available")
+
+        # header must contain at least three columns: blank, driver, first lane
+        header_len = len(header_row)
+        if header_len <= self._NUM_COLS_BEFORE_LANES:
+            raise InvalidRowError("header has too few columns")
+
+        # get the lane numbers from the header row
+        lane_numbers = []
+        i = self._NUM_COLS_BEFORE_LANES
+        while i < header_len:
+            col_str = header_row[i].strip()
+            if not col_str:
+                break
+            lane_numbers.append(
+                convert_str_to_int(col_str, "text in header lane column is invalid")
+            )
+            i = i + 1
+
+        return lane_numbers
+
+    def parse(self) -> list[tuple[str, list[tuple[int, int, Decimal]]]]:
+        entries = []
+
+        # header row with lane numbers must exist
+        lane_numbers = self._fetch_header_lane_numbers()
+        len_lanes = len(lane_numbers)
+
+        # the body must contain at least one row
+        current_row = self._reader.fetch_next_row()
+        if current_row is None or len(current_row) == 0:
+            raise InvalidRowError("row is not available")
+
+        # evaluate all body rows
+        while current_row is not None and len(current_row) > 0:
+            if len(current_row) < self._NUM_COLS_BEFORE_LANES + len_lanes:
+                raise InvalidRowError("row has too few columns")
+
+            driver_name = current_row[1].strip()
+            if len(driver_name) > 0:
+                round_num = 1
+                heats: list[tuple[int, int, Decimal]] = []
+                entries.append((driver_name, heats))
+            else:
+                round_num += 1
+
+            i = 0
+            while i < len_lanes:
+                col_idx = self._NUM_COLS_BEFORE_LANES + i
+                col_str = current_row[col_idx].strip()
+                if col_str and col_str != self._BROKEN_COL_STR:
+                    lane_num = lane_numbers[i]
+                    value = convert_comma_str_to_decimal(
+                        col_str, "text in lane column is invalid"
+                    )
+                    heats.append((round_num, lane_num, value))
+                i = i + 1
+
+            current_row = self._reader.fetch_next_row()
+
+        return entries
+
+
+class LapsPerLaneOverviewParser(DefaultParser):
+    def parse(self) -> list[LapsPerLaneOverviewEntry]:
+        return [
+            LapsPerLaneOverviewEntry(
+                driver_name=driver_name,
+                heats=[
+                    LapsOnLane(
+                        round_num=round_num, lane_num=lane_num, lap_count=lap_count
+                    )
+                    for round_num, lane_num, lap_count in heats
+                ],
+            )
+            for driver_name, heats in LanesRelatedOverviewParser(
+                self._get_reader()
+            ).parse()
+        ]
+
+
+class FastestLapsOverviewParser(DefaultParser):
+    def __init__(self, reader: StatefulRowReader) -> None:
+        self._reader = reader
+
+    def parse(self) -> list[FastestLapsOverviewEntry]:
+        return [
+            FastestLapsOverviewEntry(
+                driver_name=driver_name,
+                heats=[
+                    LapTimeOnLane(
+                        round_num=round_num, lane_num=lane_num, lap_time=lap_time
+                    )
+                    for round_num, lane_num, lap_time in heats
+                ],
+            )
+            for driver_name, heats in LanesRelatedOverviewParser(
+                self._get_reader()
+            ).parse()
+        ]

bepfe_export_parser-0.6.3/src/bepfe_export_parser/win/parse/result.py

@@ -0,0 +1,99 @@
+from bepfe_export_parser.win.convert import (
+    convert_comma_str_to_decimal,
+    convert_str_to_int,
+    convert_time_str_to_decimal,
+)
+from bepfe_export_parser.win.model import (
+    DetailedLapTimeInHeat,
+    QualifyingEntry,
+    ShortResultEntry,
+)
+from bepfe_export_parser.exceptions import InvalidRowError
+from bepfe_export_parser.win.parse.abstract import DefaultParser
+
+
+class QualifyingParser(DefaultParser):
+    def parse(self) -> list[QualifyingEntry]:
+        entries = []
+
+        reader = self._get_reader()
+
+        current_row = reader.fetch_next_row()
+        if current_row is None or len(current_row) == 0:
+            raise InvalidRowError("row is not available")
+
+        while current_row is not None and len(current_row) > 0:
+            if len(current_row) < 3:
+                raise InvalidRowError("row has too few columns")
+
+            entries.append(
+                QualifyingEntry(
+                    position_num=convert_str_to_int(
+                        current_row[0], "text in position column is invalid"
+                    ),
+                    driver_name=current_row[1],
+                    lap_time=convert_comma_str_to_decimal(
+                        current_row[2], "text in lap time column is invalid"
+                    ),
+                )
+            )
+            current_row = reader.fetch_next_row()
+
+        return entries
+
+
+class ShortResultParser(DefaultParser):
+    def parse(self) -> list[ShortResultEntry]:
+        entries = []
+
+        reader = self._get_reader()
+
+        header_row = reader.fetch_next_row()  # skip header
+        if header_row is None or len(header_row) == 0:
+            raise InvalidRowError("header is not available")
+
+        header_len = len(header_row)
+
+        current_row = reader.fetch_next_row()
+        if current_row is None or len(current_row) == 0:
+            raise InvalidRowError("row is not available")
+
+        while current_row is not None and len(current_row) > 0:
+            if len(current_row) < header_len:
+                raise InvalidRowError("row has too few columns")
+
+            entries.append(
+                ShortResultEntry(
+                    position_num=convert_str_to_int(
+                        current_row[0], "text in position column is invalid"
+                    ),
+                    driver_name=current_row[1],
+                    total_lap_count=convert_comma_str_to_decimal(
+                        current_row[2], "text in laps column is invalid"
+                    ),
+                    total_time=convert_time_str_to_decimal(
+                        current_row[3], "text in time column is invalid"
+                    ),
+                    average_lap_time=convert_comma_str_to_decimal(
+                        current_row[4], "text in average lap time column is invalid"
+                    ),
+                    fastest_lap=DetailedLapTimeInHeat(
+                        lap_time=convert_comma_str_to_decimal(
+                            current_row[5], "text in fastest lap time column is invalid"
+                        ),
+                        heat_num=convert_str_to_int(
+                            current_row[6], "text in fastest lap heat column is invalid"
+                        ),
+                        lane_num=convert_str_to_int(
+                            current_row[7], "text in fastest lap lane column is invalid"
+                        ),
+                        lap_num=convert_str_to_int(
+                            current_row[8], "text in fastest lap lap column is invalid"
+                        ),
+                    ),
+                )
+            )
+
+            current_row = reader.fetch_next_row()
+
+        return entries

bepfe_export_parser-0.6.3/src/bepfe_export_parser/win/parse/settings.py

@@ -0,0 +1,59 @@
+from bepfe_export_parser.exceptions import ConvertingError
+from bepfe_export_parser.win.convert import convert_str_to_int
+from bepfe_export_parser.win.model import (
+    HeatLength,
+    HeatLengthUnitEnum,
+    RaceModeEnum,
+    RaceTypeEnum,
+)
+from bepfe_export_parser.win.parse.abstract import DefaultParser
+from bepfe_export_parser.win.parse.constants import MINUTES_UNIT
+
+
+class HeatLengthParser(DefaultParser):
+    def parse(self) -> HeatLength:
+        parts = self._get_reader().get_current_row_checked(2)[1].split()
+
+        if len(parts) != 2:
+            raise ConvertingError("text in heat length column is invalid")
+
+        value_part, unit_part = parts
+
+        value = convert_str_to_int(
+            value_part, "value part in heat length column is invalid"
+        )
+
+        if unit_part.strip() != MINUTES_UNIT:
+            raise ConvertingError("unit part in heat length column is invalid")
+
+        seconds = value * 60
+
+        return HeatLength(value=seconds, unit=HeatLengthUnitEnum.SECONDS)
+
+
+class RaceModeParser(DefaultParser):
+    def parse(self) -> RaceModeEnum:
+        text = self._get_reader().get_current_row_checked(2)[1]
+
+        race_mode = next(
+            (entry for entry in RaceModeEnum if entry.value == text),
+            None,
+        )
+        if race_mode is None:
+            raise ConvertingError("value in race mode column is invalid")
+
+        return race_mode
+
+
+class RaceTypeParser(DefaultParser):
+    def parse(self) -> RaceTypeEnum:
+        text = self._get_reader().get_current_row_checked(2)[1]
+
+        race_type = next(
+            (entry for entry in RaceTypeEnum if entry.value == text),
+            None,
+        )
+        if race_type is None:
+            raise ConvertingError("value in race type column is invalid")
+
+        return race_type

bepfe_export_parser-0.6.3/src/bepfe_export_parser/win/reader.py

@@ -0,0 +1,23 @@
+from _csv import Reader
+from bepfe_export_parser.exceptions import InvalidRowError
+
+
+class StatefulRowReader:
+    def __init__(self, reader: Reader) -> None:
+        self._reader = reader
+        self._current_row: list[str] | None = None
+
+    def fetch_next_row(self) -> list[str] | None:
+        self._current_row = next(self._reader, None)
+        return self._current_row
+
+    def get_current_row(self) -> list[str] | None:
+        return self._current_row
+
+    def get_current_row_checked(self, min_length: int) -> list[str]:
+        row = self.get_current_row()
+        if row is None or len(row) == 0:
+            raise InvalidRowError("row is not available")
+        if len(row) < min_length:
+            raise InvalidRowError("row has too few columns")
+        return row