oleksiisaiun_lab6_monaco 1.0__py3-none-any.whl

oleksiisaiun_lab6_monaco/__init__.py

@@ -0,0 +1,5 @@
+from .core import race_report
+__all__ = ["main_run"]
+
+
+

oleksiisaiun_lab6_monaco/constants.py

@@ -0,0 +1,16 @@
+import re
+
+
+ABBR_ROW_PATTERN = re.compile(
+    r"^(?P<abbr>[A-Z]{3})_(?P<driver>[A-Za-z .'-]+)_(?P<team>[A-Z0-9 &'()-]+)$"
+)
+
+
+START_STOP_ROW_PATTERN = re.compile(
+    r'^(?P<abbr>[A-Z]{3})(?P<time_event>\d{4}-\d{2}-\d{2}_\d{2}:\d{2}:\d{2}\.\d{3})$'
+)
+
+ERR_MSG__LAP_TIME_ZERO_OR_NEGATIVE="LAP_TIME_CAN_NOT_BE_ZERO_OR_NEGATIVE"
+ERR_MSG__EMPTY_START_OR_STOP_TIME="EMPTY_START_OR_STOP_TIME"
+ERR_MSG__INVALID_FORMAT_OF_TIME_EVENT_ROW ='INVALID_FORMAT_OF_TIME_EVENT_ROW'
+ERR_PREFIX='INVALID_ABBREVIATION_ROW_'

oleksiisaiun_lab6_monaco/data/abbreviations.txt

@@ -0,0 +1,19 @@
+DRR_Daniel Ricciardo_RED BULL RACING TAG HEUER
+SVF_Sebastian Vettel_FERRARI
+LHM_Lewis Hamilton_MERCEDES
+KRF_Kimi Räikkönen_FERRARI
+VBM_Valtteri Bottas_MERCEDES
+EOF_Esteban Ocon_FORCE INDIA MERCEDES
+FAM_Fernando Alonso_MCLAREN RENAULT
+CSR_Carlos Sainz_RENAULT
+SPF_Sergio Perez_FORCE INDIA MERCEDES
+PGS_Pierre Gasly_SCUDERIA TORO ROSSO HONDA
+NHR_Nico Hulkenberg_RENAULT
+SVM_Stoffel Vandoorne_MCLAREN RENAULT
+SSW_Sergey Sirotkin_WILLIAMS MERCEDES
+CLS_Charles Leclerc_SAUBER FERRARI
+RGH_Romain Grosjean_HAAS FERRARI
+BHS_Brendon Hartley_SCUDERIA TORO ROSSO HONDA
+MES_Marcus Ericsson_SAUBER FERRARI
+LSW_Lance Stroll_WILLIAMS MERCEDES
+KMH_Kevin Magnussen_HAAS FERRARI

oleksiisaiun_lab6_monaco/data/end.log

@@ -0,0 +1,19 @@
+MES2018-05-24_12:05:58.778 
+RGH2018-05-24_12:06:27.441
+SPF2018-05-24_12:13:13.883
+LSW2018-05-24_12:07:26.834
+DRR2018-05-24_12:11:24.067
+NHR2018-05-24_12:04:02.979
+CSR2018-05-24_12:04:28.095
+KMH2018-05-24_12:04:04.396
+BHS2018-05-24_12:16:05.164
+SVM2018-05-24_12:19:50.198
+KRF2018-05-24_12:04:13.889
+VBM2018-05-24_12:01:12.434
+SVF2018-05-24_12:04:03.332
+EOF2018-05-24_12:12:11.838
+PGS2018-05-24_12:08:36.586
+SSW2018-05-24_12:11:24.354
+FAM2018-05-24_12:14:17.169
+CLS2018-05-24_12:10:54.750
+LHM2018-05-24_12:11:32.585

oleksiisaiun_lab6_monaco/data/start.log

@@ -0,0 +1,20 @@
+SVF2018-05-25_12:59:58.917
+NHR2018-05-24_12:02:49.914
+FAM2018-05-24_12:13:04.512
+KRF2018-05-24_12:03:01.250
+SVM2018-05-24_12:18:37.735
+MES2018-05-24_12:04:45.513
+LSW2018-05-24_12:06:13.511
+BHS2018-05-24_12:14:51.985
+EOF2018-05-24_12:17:58.810
+RGH2018-05-24_12:05:14.511
+SSW2018-05-24_12:16:11.648
+KMH2018-05-24_12:02:51.003
+PGS2018-05-24_12:07:23.645
+CSR2018-05-24_12:03:15.145
+SPF2018-05-24_12:12:01.035
+DRR2018-05-24_12:14:12.054
+LHM2018-05-24_12:18:20.125
+CLS2018-05-24_12:09:41.921
+VBM2018-05-24_12:00:00.000
+

oleksiisaiun_lab6_monaco/race_report.py

@@ -0,0 +1,183 @@
+import os
+from dataclasses import dataclass
+from datetime import datetime
+import utilities as util
+from constants import *
+
+
+@dataclass
+class RecordData:
+    abbr: str = None
+    driver: str = None
+    team: str = None
+    _start: datetime = None
+    _stop: datetime = None
+    _lap_time_seconds: int = None
+    error: list[dict[str, str]] = None
+
+    @property
+    def start(self):
+        return self._start
+
+    @start.setter
+    def start(self, value):
+        self._start = value
+
+    @property
+    def stop(self):
+        return self._stop
+
+    @stop.setter
+    def stop(self, value):
+        self._stop = value
+
+    @property
+    def lap_time_seconds(self):
+        return self._lap_time_seconds
+
+    @lap_time_seconds.setter
+    def lap_time_seconds(self, value):
+        if float(value) <= 0:
+            error_value = {self.abbr: ERR_MSG__LAP_TIME_ZERO_OR_NEGATIVE}
+            if self.error is None:
+                self.error = []
+            self.error.append(error_value)
+        else:
+            self._lap_time_seconds = value
+
+    def __str__(self):
+        return (
+            f"RecordData("
+            f"abbr='{self.abbr}', "
+            f"driver='{self.driver}', "
+            f"team='{self.team}', "
+            f"start='{self.start}', "
+            f"stop='{self.stop}', "
+            f"lap_time_seconds={self.lap_time_seconds}, "
+            f"error={self.error}"
+            f")"
+        )
+
+
+def _create_driver_record(row) -> RecordData:
+    record_driver_out = util.validate_abbreviation_row(row)
+    if record_driver_out is None:
+        error_val = {row: ERR_PREFIX}
+        record_driver_out = RecordData(error=[error_val])
+    return record_driver_out
+
+
+def _read_file_abbreviation(filepath) -> list[dict[str, RecordData], dict[str, RecordData]]:
+    dict_records_good = dict()
+    dict_records_bad = dict()
+    with open(filepath, 'r', encoding='utf-8') as file:
+        for line_numerator, line in enumerate(file, start=1):
+            row = line.strip()
+
+            if not row:
+                continue  # skip empty lines
+            driver_record = _create_driver_record(row)
+
+            if not driver_record.error:
+                dict_records_good[driver_record.abbr] = driver_record
+            else:
+                key_invalid_row = str(ERR_PREFIX + str(line_numerator))
+                dict_records_bad[key_invalid_row] = driver_record
+    return [dict_records_good, dict_records_bad]
+
+
+def _read_file_start_stop(filepath: str) -> dict[str, datetime]:
+    dict_out = dict()
+    with open(filepath, 'r', encoding='utf-8') as file:
+        for line in file:
+            line = line.strip()
+            if not line:
+                continue  # Skip empty lines
+
+            time_event_record = util.validate_start_stop_row(line)
+
+            if time_event_record is not None:
+                abbr = time_event_record[0]
+                time_event = time_event_record[1]
+                dict_out[abbr] = time_event
+    return dict_out
+
+
+def build_report(
+        folder: str,
+        file_abbr: str,
+        file_start: str,
+        file_stop: str,
+) -> tuple[list[RecordData], list[RecordData]]:
+    filepath_abbr = os.path.join(os.path.dirname(__file__), folder, file_abbr)
+    filepath_start = os.path.join(os.path.dirname(__file__), folder, file_start)
+    filepath_stop = os.path.join(os.path.dirname(__file__), folder, file_stop)
+    list_records_good = list()
+    list_records_bad = list()
+
+    if (util.validate_if_file_exists(filepath_abbr)) and (util.validate_if_file_exists(filepath_start)) and (
+            util.validate_if_file_exists(filepath_stop)):
+        [dict_records_good, dict_records_bad] = _read_file_abbreviation(filepath_abbr)
+
+        dict_start = _read_file_start_stop(filepath=filepath_start)
+        dict_stop = _read_file_start_stop(filepath=filepath_stop)
+
+        for key_abbr, val_abbr in dict_records_good.items():
+            driver_record_current = dict_records_good[key_abbr]
+            key_start_time = dict_start[key_abbr]
+            key_stop_time = dict_stop[key_abbr]
+
+            if key_start_time and key_stop_time:
+                driver_record_current.start = key_start_time
+                driver_record_current.stop = key_stop_time
+                lap_time_seconds = (key_stop_time - key_start_time).total_seconds()
+                driver_record_current.lap_time_seconds = lap_time_seconds
+                list_records_good.append(driver_record_current)
+            else:
+                list_records_bad.append()
+
+        for k in dict_records_bad:
+            list_records_bad.append(dict_records_bad[k])
+
+        # error values can be assigned in the property [lap_time_seconds]. I check if there are any Records with errors:
+        for key_abbr, val_abbr in dict_records_good.items():
+            driver_record_current = dict_records_good[key_abbr]
+            if driver_record_current.error is not None:
+                list_records_good.remove(driver_record_current)
+                list_records_bad.append(driver_record_current)
+    output = [list_records_good, list_records_bad]
+
+    return output
+
+
+def print_report(records_good: list[RecordData], records_bad: list[RecordData], sort_by_lap_asc: bool = True):
+    print(f"---------RACE REPORT OF GOOD RECORDS--------------")
+    if sort_by_lap_asc:
+        sorted_good_records = sorted(records_good, key=lambda r: r.lap_time_seconds, reverse=False)
+    else:
+        sorted_good_records = sorted(records_good, key=lambda r: r.lap_time_seconds, reverse=True)
+
+    for j in sorted_good_records:
+        print(j)
+
+    if records_bad:
+        print(f"---------RACE REPORT OF INVALID RECORDS--------------")
+        for j in records_bad:
+            print(j)
+
+
+def main_run():
+
+    #folder = '/Users/oleksiisaiun/Documents/ALESHA/REPO/PYCHARM/GIT_FOXMINDED_LABS/TRAINING_PYTHON/python_lab_6_oop_monaco_report/data'
+    folder = 'data'
+    file_abbr = 'abbreviations.txt'
+    file_start = 'start.log'
+    file_stop = 'end.log'
+
+
+    data_report = build_report(folder=folder, file_abbr=file_abbr, file_start=file_start, file_stop=file_stop)
+    print_report(records_good=data_report[0], records_bad=data_report[1],sort_by_lap_asc=False)
+
+
+if __name__ == '__main__':
+    main_run()

oleksiisaiun_lab6_monaco/utilities.py

@@ -0,0 +1,43 @@
+import os
+from datetime import datetime
+from race_report import RecordData
+from constants import ABBR_ROW_PATTERN,START_STOP_ROW_PATTERN,ERR_MSG__INVALID_FORMAT_OF_TIME_EVENT_ROW
+
+def is_valid_datetime(value: str, datetime_format: str = "%Y-%m-%d_%H:%M:%S.%f") -> bool:
+    try:
+        datetime.strptime(value, datetime_format)
+        return True
+    except ValueError:
+        return False
+
+def validate_if_file_exists(filepath) -> bool:
+    """Check if the folder and file exist, raise error if not."""
+    if not os.path.isfile(filepath):
+        raise FileNotFoundError(f"File not found: {filepath}")
+
+    folder = os.path.dirname(filepath)
+    if folder and not os.path.exists(folder):
+        raise FileNotFoundError(f"Folder does not exist: {folder}")
+    return True
+
+
+def validate_abbreviation_row(row: str) -> RecordData:
+    match = ABBR_ROW_PATTERN.match(row)
+    if match:
+        driver_entry = RecordData(abbr=match.group('abbr'), driver=match.group('driver'), team=match.group('team'))
+        return driver_entry
+
+    return None
+
+def validate_start_stop_row(row: str) -> (str, datetime):
+    match = START_STOP_ROW_PATTERN.match(row)
+    if match:
+        abbr = match.group('abbr')
+        time_event_raw=match.group('time_event')
+        if is_valid_datetime(time_event_raw):
+            time_event = datetime.strptime(time_event_raw, "%Y-%m-%d_%H:%M:%S.%f")
+            event_time_out = (abbr, time_event)
+            return event_time_out
+
+    print(f"discard row: [{row}], because {ERR_MSG__INVALID_FORMAT_OF_TIME_EVENT_ROW}")
+    return None  # if start or stop row has invalid then a row is discarded

oleksiisaiun_lab6_monaco-1.0.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: oleksiisaiun_lab6_monaco
+Version: 1.0
+Summary: The Python application that implements Monaco Racing Report in OOP format
+Author-email: Oleksii Saiun <oleksiisaiun@example.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: black==25.1.0
+Requires-Dist: click==8.1.8
+Requires-Dist: exceptiongroup==1.2.2
+Requires-Dist: flake8==7.1.2
+Requires-Dist: iniconfig==2.1.0
+Requires-Dist: mccabe==0.7.0
+Requires-Dist: mypy-extensions==1.0.0
+Requires-Dist: packaging==24.2
+Requires-Dist: pathspec==0.12.1
+Requires-Dist: platformdirs==4.3.7
+Requires-Dist: pluggy==1.5.0
+Requires-Dist: pycodestyle==2.12.1
+Requires-Dist: pyflakes==3.2.0
+Requires-Dist: pytest==8.3.5
+Requires-Dist: tomli==2.2.1
+Requires-Dist: typing-extensions==4.13.0
+Dynamic: license-file
+
+# Python_Lab_6_OOP_monaco_report
+It's the Python app that implements Monaco Racing Report in OOP format
+
+
+# How publish a package to PyPi using uv from a local computer:
+#1. Go to root folder of this package:
+#2. Run command
+uv build
+uv publish --token pypi-AgEIcHlwaS5vcmcCJGRhNmIxOTBlLTg3NTUtNGNmZi1iN2IyLWJkNGIwYWUxZjA2MwACKlszLCIzM2M1MmJiZS01NzhhLTQ5NGYtYjlmOS1hYzQzZTI4NTVkZTQiXQAABiDaegtzwu6CCdvCLNhLmzk9layeLZeP5-pYbnmR9aZYLA

oleksiisaiun_lab6_monaco-1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+oleksiisaiun_lab6_monaco/__init__.py,sha256=sODP91Uw0rmjnK00ZzhgDUPm-SxlNiTdc_2OBDFPiD4,56
+oleksiisaiun_lab6_monaco/constants.py,sha256=AhfKQOCkcLiILoQ5vf9CD-oBoPMSrXIaPiQhegg5tAw,504
+oleksiisaiun_lab6_monaco/race_report.py,sha256=lyahDK62FCEsHmt6DfGJabyK63Z4643spdzsKiHfVs8,6224
+oleksiisaiun_lab6_monaco/utilities.py,sha256=c3BCr1RdAsvCGNUhQW-Rx4eZszDGjFsIs_POL5BXs3M,1628
+oleksiisaiun_lab6_monaco/data/abbreviations.txt,sha256=3GAAVS7XOzXvfIC90WS8pEuCKtavQwGHV97do8xJ20o,663
+oleksiisaiun_lab6_monaco/data/end.log,sha256=4wE9PQZfaPeFOfKGf24XUCiNfVe2DJwbOzyDuIt7FNs,513
+oleksiisaiun_lab6_monaco/data/start.log,sha256=rKe7QZzeUVN8j4KVzs11sFfGtGZUw2Zuz3z-1RA9gv8,514
+oleksiisaiun_lab6_monaco-1.0.dist-info/licenses/LICENSE,sha256=SLpkaez9xkCMD5ce3l3sJM59kS962nWIiMb-jdywXlg,1070
+oleksiisaiun_lab6_monaco-1.0.dist-info/METADATA,sha256=4gT_KaSHuTGkh_wva154L_lmDZ1OrMDpwBsC_mu7vy8,1418
+oleksiisaiun_lab6_monaco-1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+oleksiisaiun_lab6_monaco-1.0.dist-info/top_level.txt,sha256=M7B-GnGgDZrj10nblmrJGJMRFcOZ7d2hU_J_mijACfQ,25
+oleksiisaiun_lab6_monaco-1.0.dist-info/RECORD,,

oleksiisaiun_lab6_monaco-1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

oleksiisaiun_lab6_monaco-1.0.dist-info/licenses/LICENSE

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

oleksiisaiun_lab6_monaco-1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+oleksiisaiun_lab6_monaco