lenexpy 3.0.2__tar.gz → 3.0.3__tar.gz

{lenexpy-3.0.2 → lenexpy-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lenexpy
-Version: 3.0.2
+Version: 3.0.3
 Summary: 
 Author: LordCode
 Author-email: 9999269010dddd@gmail.com
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: lxml (>=6.0.2,<7.0.0)
 Requires-Dist: pydantic-xml (>=2.18.0,<3.0.0)
 Description-Content-Type: text/markdown
 

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/__init__.py

@@ -1,3 +1,7 @@
+from lenexpy.models._bootstrap import bootstrap_models
+
+
+from typing import Tuple
 from .decoder import load as fromfile, save as tofile
 from .models.agedate import TypeAgeDate, AgeDate
 from .models.agegroup import Calculate, AgeGroup
@@ -25,7 +29,6 @@ from .models.pointtable import PointTable
 from .models.pool import TypePool, Pool
 from .models.qualify import Conversion, Qualify
 from .models.ranking import Ranking
-from .models.reactiontime import ReactionTime
 from .models.record import Record
 from .models.recordlist import RecordList
 from .models.relaymeet import RelayMeet
@@ -52,7 +55,11 @@ from .models_st.entry import Status as StatusST, Entry as EntryST
 from .models_st.heat import Final as FinalST, StatusHeat as StatusHeatST, Heat as HeatST
 from .models_st.result import StatusResult as StatusResultST, Result as ResultST
 
-__all__ = [
+Club.model_rebuild(force=True, _types_namespace={"Athlete": Athlete})
+Athlete.model_rebuild(force=True, _types_namespace={"Club": Club})
+RelayRecord.model_rebuild(force=True, _types_namespace={"Club": Club})
+
+__all__: Tuple[str, ...] = (
     "fromfile",
     "tofile",
     "TypeAgeDate",
@@ -96,7 +103,6 @@ __all__ = [
     "Conversion",
     "Qualify",
     "Ranking",
-    "ReactionTime",
     "Record",
     "RecordList",
     "RelayMeet",
@@ -126,4 +132,4 @@ __all__ = [
     "HeatST",
     "StatusResultST",
     "ResultST",
-]
+)

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/decoder/__init__.py

@@ -1,4 +1,4 @@
-from .decoder import decode as load
-from .encoder import encode as save
-from .lef_decoder import decode_lef_bytes
-from .lxf_decoder import decode_lxf_bytes
+from .decoder import decode as load
+from .encoder import encode as save
+from .lef_decoder import decode_lef_bytes
+from .lxf_decoder import decode_lxf_bytes

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/decoder/decoder.py

@@ -1,11 +1,11 @@
-
+
 from pathlib import Path
 
 from lenexpy.decoder.lef_decoder import decode_lef
 from lenexpy.decoder.lxf_decoder import decode_lxf
 from lenexpy.models.lenex import Lenex
-
-
+
+
 def decode(filename: str) -> Lenex:
     suffix = Path(filename).suffix.lower()
     if suffix in (".xml", ".lef"):

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/decoder/encoder.py

@@ -3,8 +3,8 @@ from pathlib import Path
 from lenexpy.models.lenex import Lenex
 from .lef_encoder import encode_lef
 from .lxf_encoder import encode_lxf
-
-
+
+
 def encode(lenex: Lenex, filename: str):
     suffix = Path(filename).suffix.lower()
     if suffix in (".xml", ".lef"):

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/decoder/lxf_encoder.py

@@ -4,8 +4,8 @@ from zipfile import ZipFile, ZIP_DEFLATED
 
 from lenexpy.models.lenex import Lenex
 from .lef_encoder import encode_lef_bytes
-
-
+
+
 def encode_lxf(lenex: Lenex, filename: str):
     if not filename.endswith('.lxf'):
         raise TypeError('The file type must be .lxf')

lenexpy-3.0.3/lenexpy/models/_bootstrap.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+_BOOTSTRAPPED = False
+
+
+def bootstrap_models() -> None:
+    """
+    Ensures pydantic-xml serializers are built after all model modules are loaded.
+    Must be called before Lenex.from_xml / to_xml.
+    """
+    global _BOOTSTRAPPED
+    if _BOOTSTRAPPED:
+        return
+
+    # Импортируем корневую модель и "узлы" графа.
+    # Важно: импорт внутри функции, чтобы не создавать круги при импорте пакета.
+    from .lenex import Lenex
+
+    # Эти импорты нужны, чтобы классы реально были в памяти и попали в namespace
+    from .club import Club
+    from .athelete import Athlete
+    from .relayrecord import RelayRecord
+
+    # Дополнительно (часто нужно) — базовые контейнеры цепочки:
+    from .meet import Meet
+    from .session import Session
+    from .event import Event
+    from .heat import Heat
+    from .result import Result
+    from .entry import Entry
+    from .recordlist import RecordList
+    from .record import Record
+    from .relaymeet import RelayMeet
+    from .relayposition import RelayPosition
+    from .split import Split
+    from .contact import Contact
+    from .official import Official
+    from .nation import Nation
+    from .pool import Pool
+    from .swimstyle import SwimStyle
+    from .stroke import Stroke
+    from .swimtime import SwimTime
+    from .timestandardlist import TimeStandardList
+    from .timestandard import TimeStandard
+    from .timestandardref import TimeStandardRef
+    from .timing import Timing
+    from .agedate import AgeDate
+    from .agegroup import AgeGroup
+    from .fee import Fee
+    from .qualify import Qualify
+    from .ranking import Ranking
+    from .pointtable import PointTable
+    from .handicap import Handicap
+    from .meetinfoentry import MeetInfoEntry
+    from .meetinforecord import MeetInfoRecord
+
+    ns = {
+        "Lenex": Lenex,
+        "Club": Club,
+        "Athlete": Athlete,
+        "RelayRecord": RelayRecord,
+        "Meet": Meet,
+        "Session": Session,
+        "Event": Event,
+        "Heat": Heat,
+        "Result": Result,
+        "Entry": Entry,
+        "RecordList": RecordList,
+        "Record": Record,
+        "RelayMeet": RelayMeet,
+        "RelayPosition": RelayPosition,
+        "Split": Split,
+        "Contact": Contact,
+        "Official": Official,
+        "Nation": Nation,
+        "Pool": Pool,
+        "SwimStyle": SwimStyle,
+        "Stroke": Stroke,
+        "SwimTime": SwimTime,
+        "TimeStandardList": TimeStandardList,
+        "TimeStandard": TimeStandard,
+        "TimeStandardRef": TimeStandardRef,
+        "Timing": Timing,
+        "AgeDate": AgeDate,
+        "AgeGroup": AgeGroup,
+        "Fee": Fee,
+        "Qualify": Qualify,
+        "Ranking": Ranking,
+        "PointTable": PointTable,
+        "Handicap": Handicap,
+        "MeetInfoEntry": MeetInfoEntry,
+        "MeetInfoRecord": MeetInfoRecord,
+    }
+
+    # Главная часть: rebuild корневой модели (она должна получить __xml_serializer__)
+    Lenex.model_rebuild(force=True, _types_namespace=ns)
+
+    # На всякий случай "дожмём" ключевые узлы графа (это дешево, но стабилизирует)
+    for m in (Club, Athlete, RelayRecord, RelayMeet, RelayPosition, Meet, Session, Event, Heat, Result, Entry, RecordList, Record):
+        m.model_rebuild(force=True, _types_namespace=ns)
+
+    _BOOTSTRAPPED = True
+
+
+bootstrap_models()

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/models/agedate.py

@@ -4,16 +4,16 @@ from lenexpy.strenum import StrEnum
 from pydantic_xml import attr
 
 from .base import LenexBaseXmlModel
-
-
-class TypeAgeDate(StrEnum):
-    YEAR = "YEAR"
-    DATE = "DATE"
-    POR = "POR"
-    CAN_FNQ = "CAN.FNQ"
-    LUX = "LUX"
-
-
+
+
+class TypeAgeDate(StrEnum):
+    YEAR = "YEAR"
+    DATE = "DATE"
+    POR = "POR"
+    CAN_FNQ = "CAN.FNQ"
+    LUX = "LUX"
+
+
 # TODO: confirm root tag for AgeDate.
 class AgeDate(LenexBaseXmlModel, tag="AGEDATE"):
     type: TypeAgeDate = attr(name="type")

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/models/agegroup.py

@@ -1,5 +1,5 @@
 from lenexpy.strenum import StrEnum
-from typing import List, Optional
+from typing import List, Optional, Union
 from pydantic_xml import attr, wrapped, element
 
 from .base import LenexBaseXmlModel
@@ -20,7 +20,8 @@ class AgeGroup(LenexBaseXmlModel, tag="AGEGROUP"):
     agemin: int = attr(name="agemin")
     gender: Optional[Gender] = attr(name="gender", default=None)
     calculate: Optional[Calculate] = attr(name="calculate", default=None)
-    handicap: Optional[int] = attr(name="handicap", default=None)
+    # list handicap, example "1,2,3", parsing for ,
+    handicap: Optional[Union[int, str]] = attr(name="handicap", default=None)
     levelmax: Optional[int] = attr(name="levelmax", default=None)
     levelmin: Optional[int] = attr(name="levelmin", default=None)
     levels: Optional[str] = attr(name="levels", default=None)

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/models/athelete.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from datetime import date
-from typing import List, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 from pydantic import model_validator
 from pydantic_xml import attr, element, wrapped
@@ -13,6 +15,9 @@ from .handicap import Handicap
 from .nation import Nation
 from .result import Result
 
+if TYPE_CHECKING:
+    from .club import Club
+
 
 class AthleteStatus(StrEnum):
     EXHIBITION = "EXHIBITION"
@@ -26,18 +31,20 @@ class AthleteStatus(StrEnum):
 
 # TODO: confirm root tag for Athlete.
 class Athlete(LenexBaseXmlModel, tag="ATHLETE"):
-    athleteid: int = attr(name="athleteid")
-    birthdate: date = attr(name="birthdate")
+    athleteid: Optional[int] = attr(name="athleteid", default=None)
+    sdmsid: Optional[int] = attr(name="sdmsid", default=None)
+    birthdate: Optional[date] = attr(name="birthdate", default=None)
+    firstname: Optional[str] = attr(name="firstname", default=None)
+    firstname_en: Optional[str] = attr(name="firstname.en", default=None)
+    gender: Gender = attr(name="gender", default="")
+    club: Optional[Club] = element(name="CLUB", default=None)
+    handicap: Optional[Handicap] = element(tag="HANDICAP", default=None)
     entries: List[Entry] = wrapped(
         "ENTRIES",
         element(tag="ENTRY"),
         default_factory=list,
     )
-    firstname: str = attr(name="firstname")
-    firstname_en: Optional[str] = attr(name="firstname.en", default=None)
-    gender: Gender = attr(name="gender")
-    handicap: Optional[Handicap] = element(tag="HANDICAP", default=None)
-    lastname: str = attr(name="lastname")
+    lastname: Optional[str] = attr(name="lastname", default=None)
     lastname_en: Optional[str] = attr(name="lastname.en", default=None)
     level: Optional[str] = attr(name="level", default=None)
     license: Optional[str] = attr(name="license", default=None)
@@ -54,6 +61,7 @@ class Athlete(LenexBaseXmlModel, tag="ATHLETE"):
     )
     status: Optional[AthleteStatus] = attr(name="status", default=None)
     swrid: Optional[int] = attr(name="swrid", default=None)
+    domicile: Optional[str] = attr(name="domicile", default=None)
 
     @model_validator(mode="before")
     @classmethod

lenexpy-3.0.3/lenexpy/models/base.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from datetime import time as dtime
+from typing import Any
+
+from pydantic import ConfigDict, model_validator, model_serializer
+from pydantic_xml import BaseXmlModel
+from pydantic_xml.model import SearchMode
+
+
+def _lenex_time_str(t: dtime) -> str:
+    if t.microsecond == 0:
+        if t.second == 0:
+            return t.strftime("%H:%M")
+        return t.strftime("%H:%M:%S")
+    return t.isoformat()
+
+
+def _convert_times(obj: Any) -> Any:
+    if isinstance(obj, dtime):
+        return _lenex_time_str(obj)
+    if isinstance(obj, dict):
+        return {k: _convert_times(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        t = [_convert_times(v) for v in obj]
+        return t if isinstance(obj, list) else tuple(t)
+    return obj
+
+
+class LenexBaseXmlModel(BaseXmlModel):
+    # ! DEV VERSION ! #
+    # model_config = ConfigDict(
+    #     arbitrary_types_allowed=True,
+    #     extra="allow",
+    #     protected_namespaces=(),
+    #     search_mode="unordered",
+    # )
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=False,
+        extra="forbid",
+    )
+    __xml_search_mode__ = SearchMode.UNORDERED
+
+    @model_validator(mode="before")
+    @classmethod
+    def _normalize_empty_strings(cls, data: Any):
+        def normalize(value: Any):
+            if isinstance(value, str) and value == "":
+                return None
+            if isinstance(value, list):
+                return [normalize(item) for item in value]
+            if isinstance(value, dict):
+                return {key: normalize(val) for key, val in value.items()}
+            return value
+
+        if isinstance(data, (dict, list)):
+            return normalize(data)
+        return data
+
+    @model_serializer(mode="wrap")
+    def _lenex_serialize(self, handler, info):
+        """
+        Глобально приводит все datetime.time к нужному формату на выходе.
+        Работает для всех наследников LenexBaseXmlModel.
+        """
+        data = handler(self)
+        return _convert_times(data)

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/models/club.py

@@ -7,14 +7,14 @@ from .base import LenexBaseXmlModel
 from .nation import Nation
 from .official import Official
 from .relaymeet import RelayMeet
-from .athelete import Athlete
 from .contact import Contact
+from .athelete import Athlete
 
 
 class TypeClub(StrEnum):
-    CLUB = "CLUB",
-    NATIONALTEAM = "NATIONALTEAM",
-    REGIONALTEAM = "REGIONALTEAM",
+    CLUB = "CLUB"
+    NATIONALTEAM = "NATIONALTEAM"
+    REGIONALTEAM = "REGIONALTEAM"
     UNATTACHED = "UNATTACHED"
 
 
@@ -22,12 +22,13 @@ class TypeClub(StrEnum):
 class Club(LenexBaseXmlModel, tag="CLUB"):
     contact: Optional[Contact] = element(tag="CONTACT", default=None)
     code: Optional[str] = attr(name="code", default=None)
+    clubid: Optional[int] = attr(name="clubid", default=None)
     athletes: List[Athlete] = wrapped(
         "ATHLETES",
         element(tag="ATHLETE"),
         default_factory=list,
     )
-    name: str = attr(name="name")
+    name: Optional[str] = attr(name="name", default=None)
     name_en: Optional[str] = attr(name="name.en", default=None)
     nation: Optional[Nation] = attr(name="nation", default=None)
     number: Optional[int] = attr(name="number", default=None)

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/models/contact.py

@@ -9,7 +9,7 @@ from .base import LenexBaseXmlModel
 class Contact(LenexBaseXmlModel, tag="CONTACT"):
     city: Optional[str] = attr(name="city", default=None)
     country: Optional[str] = attr(name="country", default=None)
-    email: str = attr(name="email")
+    email: Optional[str] = attr(name="email", default=None)
     fax: Optional[str] = attr(name="fax", default=None)
     internet: Optional[str] = attr(name="internet", default=None)
     name: Optional[str] = attr(name="name", default=None)

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/models/course.py

@@ -1,15 +1,15 @@
-from lenexpy.strenum import StrEnum
-
-
-class Course(StrEnum):
-    LCM = "LCM",
-    SCM = "SCM",
-    SCY = "SCY",
-    SCM16 = "SCM16",
-    SCM20 = "SCM20",
-    SCM33 = "SCM33",
-    SCY20 = "SCY20",
-    SCY27 = "SCY27",
-    SCY33 = "SCY33",
-    SCY36 = "SCY36",
-    OPEN = "OPEN"
+from lenexpy.strenum import StrEnum
+
+
+class Course(StrEnum):
+    LCM = "LCM",
+    SCM = "SCM",
+    SCY = "SCY",
+    SCM16 = "SCM16",
+    SCM20 = "SCM20",
+    SCM33 = "SCM33",
+    SCY20 = "SCY20",
+    SCY27 = "SCY27",
+    SCY33 = "SCY33",
+    SCY36 = "SCY36",
+    OPEN = "OPEN"

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/models/currency.py

@@ -1,32 +1,32 @@
-from lenexpy.strenum import StrEnum
-
-
-class Currency(StrEnum):
-    AUD = "Australian dollar"
-    BRL = "Brazilian real"
-    CAD = "Canadian dollar"
-    CHF = "Swiss franc"
-    DKK = "Danish krone"
-    DZD = "Algerian dinar"
-    GBP = "British pound"
-    DR = "Indonesian rupiah"
-    EUR = "Euro"
-    HRK = "Croatian Kuna"
-    INR = "Indian rupee"
-    IQD = "Iraqi dinar"
-    IRR = "Iranian rial"
-    JPY = "Japanese yen"
-    KRW = "Korea won"
-    KWD = "Kuwaiti dinar"
-    MXP = "Mexican peso"
-    NGN = "Nigerian naira"
-    NOK = "Norwegian krone"
-    NZD = "New Zealand dollar"
-    PHP = "Philippine peso"
-    PKR = "Pakistan rupee"
-    PYG = "Paraguay guarani"
-    RUR = "Russian rouble"
-    SAR = "Saudi Arabian riyal"
-    SEK = "Swedish krona"
-    TND = "Tunisian dinar"
-    USD = "US dollar"
+from lenexpy.strenum import StrEnum
+
+
+class Currency(StrEnum):
+    AUD = "Australian dollar"
+    BRL = "Brazilian real"
+    CAD = "Canadian dollar"
+    CHF = "Swiss franc"
+    DKK = "Danish krone"
+    DZD = "Algerian dinar"
+    GBP = "British pound"
+    DR = "Indonesian rupiah"
+    EUR = "Euro"
+    HRK = "Croatian Kuna"
+    INR = "Indian rupee"
+    IQD = "Iraqi dinar"
+    IRR = "Iranian rial"
+    JPY = "Japanese yen"
+    KRW = "Korea won"
+    KWD = "Kuwaiti dinar"
+    MXP = "Mexican peso"
+    NGN = "Nigerian naira"
+    NOK = "Norwegian krone"
+    NZD = "New Zealand dollar"
+    PHP = "Philippine peso"
+    PKR = "Pakistan rupee"
+    PYG = "Paraguay guarani"
+    RUR = "Russian rouble"
+    SAR = "Saudi Arabian riyal"
+    SEK = "Swedish krona"
+    TND = "Tunisian dinar"
+    USD = "US dollar"

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/models/entry.py

@@ -19,8 +19,9 @@ class Status(StrEnum):
     RJC = "RJC"
     SICK = "SICK"
     WDR = "WDR"
-
-
+    DNS = "DNS"
+
+
 # TODO: confirm root tag for Entry.
 class Entry(LenexBaseXmlModel, tag="ENTRY"):
     agegroupid: Optional[int] = attr(name="agegroupid", default=None)
@@ -37,7 +38,10 @@ class Entry(LenexBaseXmlModel, tag="ENTRY"):
         element(tag="RELAYPOSITION"),
         default_factory=list,
     )
-    status: Optional[Status] = attr(name="status", default=None)
+    # Accept any status string to avoid losing data from fixtures that use
+    # additional values like DNS.
+    status: Optional[str] = attr(name="status", default=None)
+    late: Optional[str] = attr(name="late", default=None)
 
     @field_validator("entrytime", mode="before")
     @classmethod

{lenexpy-3.0.2 → lenexpy-3.0.3}/lenexpy/models/event.py

@@ -2,7 +2,7 @@ from datetime import time as dtime
 from typing import List, Optional
 
 from lenexpy.strenum import StrEnum
-from pydantic import model_validator
+from pydantic import field_serializer, field_validator, model_validator
 from pydantic_xml import attr, element, wrapped
 
 from .base import LenexBaseXmlModel
@@ -27,6 +27,10 @@ class Round(StrEnum):
     SOP = "SOP"
     SOS = "SOS"
     SOQ = "SOQ"
+    # Additional values observed in fixtures; keep here for reference while
+    # allowing arbitrary strings through the model.
+    EXTRAHEATS = "EXTRAHEATS"
+    TIMETRIAL = "TIMETRIAL"
 
 
 class TypeEvent(StrEnum):
@@ -36,38 +40,66 @@ class TypeEvent(StrEnum):
 
 # TODO: confirm root tag for Event.
 class Event(LenexBaseXmlModel, tag="EVENT"):
+    # Preserve child order observed in fixtures: SWIMSTYLE, AGEGROUPS,
+    # TIMESTANDARDREFS, HEATS.
+    swimstyle: SwimStyle = element(tag="SWIMSTYLE")
     agegroups: List[AgeGroup] = wrapped(
         "AGEGROUPS",
         element(tag="AGEGROUP"),
         default_factory=list,
     )
-    daytime: Optional[dtime] = attr(name="daytime", default=None)
-    eventid: int = attr(name="eventid")
-    fee: Optional[Fee] = element(tag="FEE", default=None)
-    gender: Optional[Gender] = attr(name="gender", default=None)
+    time_standard_refs: List[TimeStandardRef] = wrapped(
+        "TIMESTANDARDREFS",
+        element(tag="TIMESTANDARDREF"),
+        default_factory=list,
+    )
     heats: List[Heat] = wrapped(
         "HEATS",
         element(tag="HEAT"),
         default_factory=list,
     )
+    fee: Optional[Fee] = element(tag="FEE", default=None)
+
+    daytime: Optional[dtime] = attr(name="daytime", default=None)
+    eventid: int = attr(name="eventid")
+    gender: Optional[Gender] = attr(name="gender", default=None)
     maxentries: Optional[int] = attr(name="maxentries", default=None)
     number: int = attr(name="number")
     order: Optional[int] = attr(name="order", default=None)
     preveventid: Optional[int] = attr(name="preveventid", default=None)
-    round: Optional[Round] = attr(name="round", default=None)
+    # Use str to avoid dropping non-standard round values such as EXTRAHEATS
+    # or TIMETRIAL found in fixtures.
+    round: Optional[str] = attr(name="round", default=None)
     run: Optional[int] = attr(name="run", default=None)
     status: Optional[StatusEvent] = attr(name="status", default=None)
-    swimstyle: SwimStyle = element(tag="SWIMSTYLE")
-    time_standard_refs: List[TimeStandardRef] = wrapped(
-        "TIMESTANDARDREFS",
-        element(tag="TIMESTANDARDREF"),
-        default_factory=list,
-    )
     timing: Optional[Timing] = attr(name="timing", default=None)
     type: Optional[TypeEvent] = attr(name="type", default=None)
 
     @model_validator(mode="after")
     def _validate_agegroups(self):
         if any(agegroup.id is None for agegroup in self.agegroups):
-            raise ValueError("AGEGROUP elements inside EVENT must define agegroupid")
+            raise ValueError(
+                "AGEGROUP elements inside EVENT must define agegroupid")
         return self
+
+    @field_validator("daytime", mode="before")
+    @classmethod
+    def _parse_daytime(cls, v):
+        if v is None or v == "":
+            return None
+        if isinstance(v, dtime):
+            return v
+        # fromisoformat понимает "HH:MM", "HH:MM:SS", "HH:MM:SS.ffffff"
+        return dtime.fromisoformat(v)
+
+    @field_serializer("daytime")
+    def _serialize_daytime(self, v: Optional[dtime], _info):
+        if v is None:
+            return None
+        if v.second == 0 and v.microsecond == 0:
+            return v.strftime("%H:%M")
+        if v.microsecond == 0:
+            return v.strftime("%H:%M:%S")
+
+        # иначе ISO с микросекундами (стандартное поведение)
+        return v.isoformat()